208 files changed, 10705 insertions, 10514 deletions
diff --git a/src/core/arm/arm_interface.h b/src/core/arm/arm_interface.h
index 480c90e66..919da6737 100644
--- a/src/core/arm/arm_interface.h
+++ b/src/core/arm/arm_interface.h
@@ -9,7 +9,7 @@
 #include "core/arm/skyeye_common/vfp/asm_vfp.h"
 namespace Core {
-    struct ThreadContext;
+struct ThreadContext;
 }
 /// Generic ARM11 CPU interface
@@ -141,10 +141,10 @@ public:
        return num_instructions;
    }
-    s64 down_count = 0; ///< A decreasing counter of remaining cycles before the next event, decreased by the cpu run loop
+    s64 down_count = 0; ///< A decreasing counter of remaining cycles before the next event,
+                        /// decreased by the cpu run loop
 protected:
    /**
     * Executes the given number of instructions
     * @param num_instructions Number of instructions to executes
@@ -152,6 +152,5 @@ protected:
    virtual void ExecuteInstructions(int num_instructions) = 0;
 private:
    u64 num_instructions = 0; ///< Number of instructions executed
 };
diff --git a/src/core/arm/disassembler/arm_disasm.cpp b/src/core/arm/disassembler/arm_disasm.cpp
index 5ad1f1c29..b3b9971e8 100644
--- a/src/core/arm/disassembler/arm_disasm.cpp
+++ b/src/core/arm/disassembler/arm_disasm.cpp
@@ -9,401 +9,225 @@
 #include "core/arm/disassembler/arm_disasm.h"
 #include "core/arm/skyeye_common/armsupp.h"
-static const char *cond_names[] = {
+static const char* cond_names[] = {"eq", "ne", "cs", "cc", "mi", "pl", "vs", "vc",
-    "eq",
+                                   "hi", "ls", "ge", "lt", "gt", "le", "",   "RESERVED"};
-    "ne",
-    "cs",
+static const char* opcode_names[] = {
-    "cc",
+    "invalid",   "undefined", "adc",    "add",     "and",    "b",      "bl",     "bic",
-    "mi",
+    "bkpt",      "blx",       "bx",     "cdp",     "clrex",  "clz",    "cmn",    "cmp",
-    "pl",
+    "eor",       "ldc",       "ldm",    "ldr",     "ldrb",   "ldrbt",  "ldrex",  "ldrexb",
-    "vs",
+    "ldrexd",    "ldrexh",    "ldrh",   "ldrsb",   "ldrsh",  "ldrt",   "mcr",    "mla",
-    "vc",
+    "mov",       "mrc",       "mrs",    "msr",     "mul",    "mvn",    "nop",    "orr",
-    "hi",
+    "pkh",       "pld",       "qadd16", "qadd8",   "qasx",   "qsax",   "qsub16", "qsub8",
-    "ls",
+    "rev",       "rev16",     "revsh",  "rsb",     "rsc",    "sadd16", "sadd8",  "sasx",
-    "ge",
+    "sbc",       "sel",       "sev",    "shadd16", "shadd8", "shasx",  "shsax",  "shsub16",
-    "lt",
+    "shsub8",    "smlad",     "smlal",  "smlald",  "smlsd",  "smlsld", "smmla",  "smmls",
-    "gt",
+    "smmul",     "smuad",     "smull",  "smusd",   "ssat",   "ssat16", "ssax",   "ssub16",
-    "le",
+    "ssub8",     "stc",       "stm",    "str",     "strb",   "strbt",  "strex",  "strexb",
-    "",
+    "strexd",    "strexh",    "strh",   "strt",    "sub",    "swi",    "swp",    "swpb",
-    "RESERVED"
+    "sxtab",     "sxtab16",   "sxtah",  "sxtb",    "sxtb16", "sxth",   "teq",    "tst",
-};
+    "uadd16",    "uadd8",     "uasx",   "uhadd16", "uhadd8", "uhasx",  "uhsax",  "uhsub16",
+    "uhsub8",    "umlal",     "umull",  "uqadd16", "uqadd8", "uqasx",  "uqsax",  "uqsub16",
-static const char *opcode_names[] = {
+    "uqsub8",    "usad8",     "usada8", "usat",    "usat16", "usax",   "usub16", "usub8",
-    "invalid",
+    "uxtab",     "uxtab16",   "uxtah",  "uxtb",    "uxtb16", "uxth",   "wfe",    "wfi",
-    "undefined",
-    "adc",
-    "add",
-    "and",
-    "b",
-    "bl",
-    "bic",
-    "bkpt",
-    "blx",
-    "bx",
-    "cdp",
-    "clrex",
-    "clz",
-    "cmn",
-    "cmp",
-    "eor",
-    "ldc",
-    "ldm",
-    "ldr",
-    "ldrb",
-    "ldrbt",
-    "ldrex",
-    "ldrexb",
-    "ldrexd",
-    "ldrexh",
-    "ldrh",
-    "ldrsb",
-    "ldrsh",
-    "ldrt",
-    "mcr",
-    "mla",
-    "mov",
-    "mrc",
-    "mrs",
-    "msr",
-    "mul",
-    "mvn",
-    "nop",
-    "orr",
-    "pkh",
-    "pld",
-    "qadd16",
-    "qadd8",
-    "qasx",
-    "qsax",
-    "qsub16",
-    "qsub8",
-    "rev",
-    "rev16",
-    "revsh",
-    "rsb",
-    "rsc",
-    "sadd16",
-    "sadd8",
-    "sasx",
-    "sbc",
-    "sel",
-    "sev",
-    "shadd16",
-    "shadd8",
-    "shasx",
-    "shsax",
-    "shsub16",
-    "shsub8",
-    "smlad",
-    "smlal",
-    "smlald",
-    "smlsd",
-    "smlsld",
-    "smmla",
-    "smmls",
-    "smmul",
-    "smuad",
-    "smull",
-    "smusd",
-    "ssat",
-    "ssat16",
-    "ssax",
-    "ssub16",
-    "ssub8",
-    "stc",
-    "stm",
-    "str",
-    "strb",
-    "strbt",
-    "strex",
-    "strexb",
-    "strexd",
-    "strexh",
-    "strh",
-    "strt",
-    "sub",
-    "swi",
-    "swp",
-    "swpb",
-    "sxtab",
-    "sxtab16",
-    "sxtah",
-    "sxtb",
-    "sxtb16",
-    "sxth",
-    "teq",
-    "tst",
-    "uadd16",
-    "uadd8",
-    "uasx",
-    "uhadd16",
-    "uhadd8",
-    "uhasx",
-    "uhsax",
-    "uhsub16",
-    "uhsub8",
-    "umlal",
-    "umull",
-    "uqadd16",
-    "uqadd8",
-    "uqasx",
-    "uqsax",
-    "uqsub16",
-    "uqsub8",
-    "usad8",
-    "usada8",
-    "usat",
-    "usat16",
-    "usax",
-    "usub16",
-    "usub8",
-    "uxtab",
-    "uxtab16",
-    "uxtah",
-    "uxtb",
-    "uxtb16",
-    "uxth",
-    "wfe",
-    "wfi",
    "yield",
-    "undefined",
+    "undefined", "adc",       "add",    "and",     "asr",    "b",      "bic",    "bkpt",
-    "adc",
+    "bl",        "blx",       "bx",     "cmn",     "cmp",    "eor",    "ldmia",  "ldr",
-    "add",
+    "ldrb",      "ldrh",      "ldrsb",  "ldrsh",   "lsl",    "lsr",    "mov",    "mul",
-    "and",
+    "mvn",       "neg",       "orr",    "pop",     "push",   "ror",    "sbc",    "stmia",
-    "asr",
+    "str",       "strb",      "strh",   "sub",     "swi",    "tst",
-    "b",
-    "bic",
+    nullptr};
-    "bkpt",
-    "bl",
-    "blx",
-    "bx",
-    "cmn",
-    "cmp",
-    "eor",
-    "ldmia",
-    "ldr",
-    "ldrb",
-    "ldrh",
-    "ldrsb",
-    "ldrsh",
-    "lsl",
-    "lsr",
-    "mov",
-    "mul",
-    "mvn",
-    "neg",
-    "orr",
-    "pop",
-    "push",
-    "ror",
-    "sbc",
-    "stmia",
-    "str",
-    "strb",
-    "strh",
-    "sub",
-    "swi",
-    "tst",
-    nullptr
-};
 // Indexed by the shift type (bits 6-5)
-static const char *shift_names[] = {
+static const char* shift_names[] = {"LSL", "LSR", "ASR", "ROR"};
-    "LSL",
-    "LSR",
-    "ASR",
-    "ROR"
-};
 static const char* cond_to_str(u32 cond) {
    return cond_names[cond];
 }
-std::string ARM_Disasm::Disassemble(u32 addr, u32 insn)
+std::string ARM_Disasm::Disassemble(u32 addr, u32 insn) {
-{
    Opcode opcode = Decode(insn);
    switch (opcode) {
-        case OP_INVALID:
+    case OP_INVALID:
-            return "Invalid";
+        return "Invalid";
-        case OP_UNDEFINED:
+    case OP_UNDEFINED:
-            return "Undefined";
+        return "Undefined";
-        case OP_ADC:
+    case OP_ADC:
-        case OP_ADD:
+    case OP_ADD:
-        case OP_AND:
+    case OP_AND:
-        case OP_BIC:
+    case OP_BIC:
-        case OP_CMN:
+    case OP_CMN:
-        case OP_CMP:
+    case OP_CMP:
-        case OP_EOR:
+    case OP_EOR:
-        case OP_MOV:
+    case OP_MOV:
-        case OP_MVN:
+    case OP_MVN:
-        case OP_ORR:
+    case OP_ORR:
-        case OP_RSB:
+    case OP_RSB:
-        case OP_RSC:
+    case OP_RSC:
-        case OP_SBC:
+    case OP_SBC:
-        case OP_SUB:
+    case OP_SUB:
-        case OP_TEQ:
+    case OP_TEQ:
-        case OP_TST:
+    case OP_TST:
-            return DisassembleALU(opcode, insn);
+        return DisassembleALU(opcode, insn);
-        case OP_B:
+    case OP_B:
-        case OP_BL:
+    case OP_BL:
-            return DisassembleBranch(addr, opcode, insn);
+        return DisassembleBranch(addr, opcode, insn);
-        case OP_BKPT:
+    case OP_BKPT:
-            return DisassembleBKPT(insn);
+        return DisassembleBKPT(insn);
-        case OP_BLX:
+    case OP_BLX:
-            // not supported yet
+        // not supported yet
-            break;
+        break;
-        case OP_BX:
+    case OP_BX:
-            return DisassembleBX(insn);
+        return DisassembleBX(insn);
-        case OP_CDP:
+    case OP_CDP:
-            return "cdp";
+        return "cdp";
-        case OP_CLREX:
+    case OP_CLREX:
-            return "clrex";
+        return "clrex";
-        case OP_CLZ:
+    case OP_CLZ:
-            return DisassembleCLZ(insn);
+        return DisassembleCLZ(insn);
-        case OP_LDC:
+    case OP_LDC:
-            return "ldc";
+        return "ldc";
-        case OP_LDM:
+    case OP_LDM:
-        case OP_STM:
+    case OP_STM:
-            return DisassembleMemblock(opcode, insn);
+        return DisassembleMemblock(opcode, insn);
-        case OP_LDR:
+    case OP_LDR:
-        case OP_LDRB:
+    case OP_LDRB:
-        case OP_LDRBT:
+    case OP_LDRBT:
-        case OP_LDRT:
+    case OP_LDRT:
-        case OP_STR:
+    case OP_STR:
-        case OP_STRB:
+    case OP_STRB:
-        case OP_STRBT:
+    case OP_STRBT:
-        case OP_STRT:
+    case OP_STRT:
-            return DisassembleMem(insn);
+        return DisassembleMem(insn);
-        case OP_LDREX:
+    case OP_LDREX:
-        case OP_LDREXB:
+    case OP_LDREXB:
-        case OP_LDREXD:
+    case OP_LDREXD:
-        case OP_LDREXH:
+    case OP_LDREXH:
-        case OP_STREX:
+    case OP_STREX:
-        case OP_STREXB:
+    case OP_STREXB:
-        case OP_STREXD:
+    case OP_STREXD:
-        case OP_STREXH:
+    case OP_STREXH:
-            return DisassembleREX(opcode, insn);
+        return DisassembleREX(opcode, insn);
-        case OP_LDRH:
+    case OP_LDRH:
-        case OP_LDRSB:
+    case OP_LDRSB:
-        case OP_LDRSH:
+    case OP_LDRSH:
-        case OP_STRH:
+    case OP_STRH:
-            return DisassembleMemHalf(insn);
+        return DisassembleMemHalf(insn);
-        case OP_MCR:
+    case OP_MCR:
-        case OP_MRC:
+    case OP_MRC:
-            return DisassembleMCR(opcode, insn);
+        return DisassembleMCR(opcode, insn);
-        case OP_MLA:
+    case OP_MLA:
-            return DisassembleMLA(opcode, insn);
+        return DisassembleMLA(opcode, insn);
-        case OP_MRS:
+    case OP_MRS:
-            return DisassembleMRS(insn);
+        return DisassembleMRS(insn);
-        case OP_MSR:
+    case OP_MSR:
-            return DisassembleMSR(insn);
+        return DisassembleMSR(insn);
-        case OP_MUL:
+    case OP_MUL:
-            return DisassembleMUL(opcode, insn);
+        return DisassembleMUL(opcode, insn);
-        case OP_NOP:
+    case OP_NOP:
-        case OP_SEV:
+    case OP_SEV:
-        case OP_WFE:
+    case OP_WFE:
-        case OP_WFI:
+    case OP_WFI:
-        case OP_YIELD:
+    case OP_YIELD:
-            return DisassembleNoOperands(opcode, insn);
+        return DisassembleNoOperands(opcode, insn);
-        case OP_PKH:
+    case OP_PKH:
-            return DisassemblePKH(insn);
+        return DisassemblePKH(insn);
-        case OP_PLD:
+    case OP_PLD:
-            return DisassemblePLD(insn);
+        return DisassemblePLD(insn);
-        case OP_QADD16:
+    case OP_QADD16:
-        case OP_QADD8:
+    case OP_QADD8:
-        case OP_QASX:
+    case OP_QASX:
-        case OP_QSAX:
+    case OP_QSAX:
-        case OP_QSUB16:
+    case OP_QSUB16:
-        case OP_QSUB8:
+    case OP_QSUB8:
-        case OP_SADD16:
+    case OP_SADD16:
-        case OP_SADD8:
+    case OP_SADD8:
-        case OP_SASX:
+    case OP_SASX:
-        case OP_SHADD16:
+    case OP_SHADD16:
-        case OP_SHADD8:
+    case OP_SHADD8:
-        case OP_SHASX:
+    case OP_SHASX:
-        case OP_SHSAX:
+    case OP_SHSAX:
-        case OP_SHSUB16:
+    case OP_SHSUB16:
-        case OP_SHSUB8:
+    case OP_SHSUB8:
-        case OP_SSAX:
+    case OP_SSAX:
-        case OP_SSUB16:
+    case OP_SSUB16:
-        case OP_SSUB8:
+    case OP_SSUB8:
-        case OP_UADD16:
+    case OP_UADD16:
-        case OP_UADD8:
+    case OP_UADD8:
-        case OP_UASX:
+    case OP_UASX:
-        case OP_UHADD16:
+    case OP_UHADD16:
-        case OP_UHADD8:
+    case OP_UHADD8:
-        case OP_UHASX:
+    case OP_UHASX:
-        case OP_UHSAX:
+    case OP_UHSAX:
-        case OP_UHSUB16:
+    case OP_UHSUB16:
-        case OP_UHSUB8:
+    case OP_UHSUB8:
-        case OP_UQADD16:
+    case OP_UQADD16:
-        case OP_UQADD8:
+    case OP_UQADD8:
-        case OP_UQASX:
+    case OP_UQASX:
-        case OP_UQSAX:
+    case OP_UQSAX:
-        case OP_UQSUB16:
+    case OP_UQSUB16:
-        case OP_UQSUB8:
+    case OP_UQSUB8:
-        case OP_USAX:
+    case OP_USAX:
-        case OP_USUB16:
+    case OP_USUB16:
-        case OP_USUB8:
+    case OP_USUB8:
-            return DisassembleParallelAddSub(opcode, insn);
+        return DisassembleParallelAddSub(opcode, insn);
-        case OP_REV:
+    case OP_REV:
-        case OP_REV16:
+    case OP_REV16:
-        case OP_REVSH:
+    case OP_REVSH:
-            return DisassembleREV(opcode, insn);
+        return DisassembleREV(opcode, insn);
-        case OP_SEL:
+    case OP_SEL:
-            return DisassembleSEL(insn);
+        return DisassembleSEL(insn);
-        case OP_SMLAD:
+    case OP_SMLAD:
-        case OP_SMLALD:
+    case OP_SMLALD:
-        case OP_SMLSD:
+    case OP_SMLSD:
-        case OP_SMLSLD:
+    case OP_SMLSLD:
-        case OP_SMMLA:
+    case OP_SMMLA:
-        case OP_SMMLS:
+    case OP_SMMLS:
-        case OP_SMMUL:
+    case OP_SMMUL:
-        case OP_SMUAD:
+    case OP_SMUAD:
-        case OP_SMUSD:
+    case OP_SMUSD:
-        case OP_USAD8:
+    case OP_USAD8:
-        case OP_USADA8:
+    case OP_USADA8:
-            return DisassembleMediaMulDiv(opcode, insn);
+        return DisassembleMediaMulDiv(opcode, insn);
-        case OP_SSAT:
+    case OP_SSAT:
-        case OP_SSAT16:
+    case OP_SSAT16:
-        case OP_USAT:
+    case OP_USAT:
-        case OP_USAT16:
+    case OP_USAT16:
-            return DisassembleSAT(opcode, insn);
+        return DisassembleSAT(opcode, insn);
-        case OP_STC:
+    case OP_STC:
-            return "stc";
+        return "stc";
-        case OP_SWI:
+    case OP_SWI:
-            return DisassembleSWI(insn);
+        return DisassembleSWI(insn);
-        case OP_SWP:
+    case OP_SWP:
-        case OP_SWPB:
+    case OP_SWPB:
-            return DisassembleSWP(opcode, insn);
+        return DisassembleSWP(opcode, insn);
-        case OP_SXTAB:
+    case OP_SXTAB:
-        case OP_SXTAB16:
+    case OP_SXTAB16:
-        case OP_SXTAH:
+    case OP_SXTAH:
-        case OP_SXTB:
+    case OP_SXTB:
-        case OP_SXTB16:
+    case OP_SXTB16:
-        case OP_SXTH:
+    case OP_SXTH:
-        case OP_UXTAB:
+    case OP_UXTAB:
-        case OP_UXTAB16:
+    case OP_UXTAB16:
-        case OP_UXTAH:
+    case OP_UXTAH:
-        case OP_UXTB:
+    case OP_UXTB:
-        case OP_UXTB16:
+    case OP_UXTB16:
-        case OP_UXTH:
+    case OP_UXTH:
-            return DisassembleXT(opcode, insn);
+        return DisassembleXT(opcode, insn);
-        case OP_UMLAL:
+    case OP_UMLAL:
-        case OP_UMULL:
+    case OP_UMULL:
-        case OP_SMLAL:
+    case OP_SMLAL:
-        case OP_SMULL:
+    case OP_SMULL:
-            return DisassembleUMLAL(opcode, insn);
+        return DisassembleUMLAL(opcode, insn);
-        default:
+    default:
-            return "Error";
+        return "Error";
    }
    return nullptr;
 }
-std::string ARM_Disasm::DisassembleALU(Opcode opcode, u32 insn)
+std::string ARM_Disasm::DisassembleALU(Opcode opcode, u32 insn) {
-{
    static const u8 kNoOperand1 = 1;
    static const u8 kNoDest = 2;
    static const u8 kNoSbit = 4;
@@ -421,18 +245,18 @@ std::string ARM_Disasm::DisassembleALU(Opcode opcode, u32 insn)
    const char* opname = opcode_names[opcode];
    switch (opcode) {
-        case OP_CMN:
+    case OP_CMN:
-        case OP_CMP:
+    case OP_CMP:
-        case OP_TEQ:
+    case OP_TEQ:
-        case OP_TST:
+    case OP_TST:
-            flags = kNoDest | kNoSbit;
+        flags = kNoDest | kNoSbit;
-            break;
+        break;
-        case OP_MOV:
+    case OP_MOV:
-        case OP_MVN:
+    case OP_MVN:
-            flags = kNoOperand1;
+        flags = kNoOperand1;
-            break;
+        break;
-        default:
+    default:
-            break;
+        break;
    }
    // The "mov" instruction ignores the first operand (rn).
@@ -448,13 +272,13 @@ std::string ARM_Disasm::DisassembleALU(Opcode opcode, u32 insn)
        rd_str = Common::StringFromFormat("r%d, ", rd);
    }
-    const char *sbit_str = "";
+    const char* sbit_str = "";
    if (bit_s && !(flags & kNoSbit))
        sbit_str = "s";
    if (is_immed) {
-        return Common::StringFromFormat("%s%s%s\t%s%s#%u  ; 0x%x",
+        return Common::StringFromFormat("%s%s%s\t%s%s#%u  ; 0x%x", opname, cond_to_str(cond),
-                opname, cond_to_str(cond), sbit_str, rd_str.c_str(), rn_str.c_str(), immed, immed);
+                                        sbit_str, rd_str.c_str(), rn_str.c_str(), immed, immed);
    }
    u8 shift_is_reg = (insn >> 4) & 1;
@@ -468,30 +292,28 @@ std::string ARM_Disasm::DisassembleALU(Opcode opcode, u32 insn)
    rotated_val = (rotated_val >> rotate2) | (rotated_val << (32 - rotate2));
    if (!shift_is_reg && shift_type == 0 && shift_amount == 0) {
-        return Common::StringFromFormat("%s%s%s\t%s%sr%d",
+        return Common::StringFromFormat("%s%s%s\t%s%sr%d", opname, cond_to_str(cond), sbit_str,
-                opname, cond_to_str(cond), sbit_str, rd_str.c_str(), rn_str.c_str(), rm);
+                                        rd_str.c_str(), rn_str.c_str(), rm);
    }
-    const char *shift_name = shift_names[shift_type];
+    const char* shift_name = shift_names[shift_type];
    if (shift_is_reg) {
-        return Common::StringFromFormat("%s%s%s\t%s%sr%d, %s r%d",
+        return Common::StringFromFormat("%s%s%s\t%s%sr%d, %s r%d", opname, cond_to_str(cond),
-                opname, cond_to_str(cond), sbit_str, rd_str.c_str(), rn_str.c_str(), rm,
+                                        sbit_str, rd_str.c_str(), rn_str.c_str(), rm, shift_name,
-                shift_name, rs);
+                                        rs);
    }
    if (shift_amount == 0) {
        if (shift_type == 3) {
-            return Common::StringFromFormat("%s%s%s\t%s%sr%d, RRX",
+            return Common::StringFromFormat("%s%s%s\t%s%sr%d, RRX", opname, cond_to_str(cond),
-                    opname, cond_to_str(cond), sbit_str, rd_str.c_str(), rn_str.c_str(), rm);
+                                            sbit_str, rd_str.c_str(), rn_str.c_str(), rm);
        }
        shift_amount = 32;
    }
-    return Common::StringFromFormat("%s%s%s\t%s%sr%d, %s #%u",
+    return Common::StringFromFormat("%s%s%s\t%s%sr%d, %s #%u", opname, cond_to_str(cond), sbit_str,
-            opname, cond_to_str(cond), sbit_str, rd_str.c_str(), rn_str.c_str(), rm,
+                                    rd_str.c_str(), rn_str.c_str(), rm, shift_name, shift_amount);
-            shift_name, shift_amount);
 }
-std::string ARM_Disasm::DisassembleBranch(u32 addr, Opcode opcode, u32 insn)
+std::string ARM_Disasm::DisassembleBranch(u32 addr, Opcode opcode, u32 insn) {
-{
    u8 cond = (insn >> 28) & 0xf;
    u32 offset = insn & 0xffffff;
    // Sign-extend the 24-bit offset
@@ -502,26 +324,23 @@ std::string ARM_Disasm::DisassembleBranch(u32 addr, Opcode opcode, u32 insn)
    offset <<= 2;
    offset += 8;
    addr += offset;
-    const char *opname = opcode_names[opcode];
+    const char* opname = opcode_names[opcode];
    return Common::StringFromFormat("%s%s\t0x%x", opname, cond_to_str(cond), addr);
 }
-std::string ARM_Disasm::DisassembleBX(u32 insn)
+std::string ARM_Disasm::DisassembleBX(u32 insn) {
-{
    u8 cond = (insn >> 28) & 0xf;
    u8 rn = insn & 0xf;
    return Common::StringFromFormat("bx%s\tr%d", cond_to_str(cond), rn);
 }
-std::string ARM_Disasm::DisassembleBKPT(u32 insn)
+std::string ARM_Disasm::DisassembleBKPT(u32 insn) {
-{
    u8 cond = (insn >> 28) & 0xf;
    u32 immed = (((insn >> 8) & 0xfff) << 4) | (insn & 0xf);
    return Common::StringFromFormat("bkpt%s\t#%d", cond_to_str(cond), immed);
 }
-std::string ARM_Disasm::DisassembleCLZ(u32 insn)
+std::string ARM_Disasm::DisassembleCLZ(u32 insn) {
-{
    u8 cond = (insn >> 28) & 0xf;
    u8 rd = (insn >> 12) & 0xf;
    u8 rm = insn & 0xf;
@@ -545,9 +364,8 @@ std::string ARM_Disasm::DisassembleMediaMulDiv(Opcode opcode, u32 insn) {
    }
    std::string ext_reg = "";
-    std::unordered_set<Opcode, std::hash<int>> with_ext_reg = {
+    std::unordered_set<Opcode, std::hash<int>> with_ext_reg = {OP_SMLAD, OP_SMLSD, OP_SMMLA,
-            OP_SMLAD, OP_SMLSD, OP_SMMLA, OP_SMMLS, OP_USADA8
+                                                               OP_SMMLS, OP_USADA8};
-    };
    if (with_ext_reg.find(opcode) != with_ext_reg.end())
        ext_reg = Common::StringFromFormat(", r%u", ra);
@@ -560,8 +378,7 @@ std::string ARM_Disasm::DisassembleMediaMulDiv(Opcode opcode, u32 insn) {
                                    ext_reg.c_str());
 }
-std::string ARM_Disasm::DisassembleMemblock(Opcode opcode, u32 insn)
+std::string ARM_Disasm::DisassembleMemblock(Opcode opcode, u32 insn) {
-{
    std::string tmp_list;
    u8 cond = (insn >> 28) & 0xf;
@@ -572,17 +389,17 @@ std::string ARM_Disasm::DisassembleMemblock(Opcode opcode, u32 insn)
    u8 rn = (insn >> 16) & 0xf;
    u16 reg_list = insn & 0xffff;
-    const char *opname = opcode_names[opcode];
+    const char* opname = opcode_names[opcode];
-    const char *bang = "";
+    const char* bang = "";
    if (write_back)
        bang = "!";
-    const char *carret = "";
+    const char* carret = "";
    if (bit_s)
        carret = "^";
-    const char *comma = "";
+    const char* comma = "";
    tmp_list[0] = 0;
    for (int ii = 0; ii < 16; ++ii) {
        if (reg_list & (1 << ii)) {
@@ -591,7 +408,7 @@ std::string ARM_Disasm::DisassembleMemblock(Opcode opcode, u32 insn)
        }
    }
-    const char *addr_mode = "";
+    const char* addr_mode = "";
    if (is_pre) {
        if (is_up) {
            addr_mode = "ib";
@@ -606,12 +423,11 @@ std::string ARM_Disasm::DisassembleMemblock(Opcode opcode, u32 insn)
        }
    }
-    return Common::StringFromFormat("%s%s%s\tr%d%s, {%s}%s",
+    return Common::StringFromFormat("%s%s%s\tr%d%s, {%s}%s", opname, cond_to_str(cond), addr_mode,
-            opname, cond_to_str(cond), addr_mode, rn, bang, tmp_list.c_str(), carret);
+                                    rn, bang, tmp_list.c_str(), carret);
 }
-std::string ARM_Disasm::DisassembleMem(u32 insn)
+std::string ARM_Disasm::DisassembleMem(u32 insn) {
-{
    u8 cond = (insn >> 28) & 0xf;
    u8 is_reg = (insn >> 25) & 0x1;
    u8 is_load = (insn >> 20) & 0x1;
@@ -623,38 +439,40 @@ std::string ARM_Disasm::DisassembleMem(u32 insn)
    u8 rd = (insn >> 12) & 0xf;
    u16 offset = insn & 0xfff;
-    const char *opname = "ldr";
+    const char* opname = "ldr";
    if (!is_load)
        opname = "str";
-    const char *bang = "";
+    const char* bang = "";
    if (write_back)
        bang = "!";
-    const char *minus = "";
+    const char* minus = "";
    if (is_up == 0)
        minus = "-";
-    const char *byte = "";
+    const char* byte = "";
    if (is_byte)
        byte = "b";
    if (is_reg == 0) {
        if (is_pre) {
            if (offset == 0) {
-                return Common::StringFromFormat("%s%s%s\tr%d, [r%d]",
+                return Common::StringFromFormat("%s%s%s\tr%d, [r%d]", opname, cond_to_str(cond),
-                        opname, cond_to_str(cond), byte, rd, rn);
+                                                byte, rd, rn);
            } else {
-                return Common::StringFromFormat("%s%s%s\tr%d, [r%d, #%s%u]%s",
+                return Common::StringFromFormat("%s%s%s\tr%d, [r%d, #%s%u]%s", opname,
-                        opname, cond_to_str(cond), byte, rd, rn, minus, offset, bang);
+                                                cond_to_str(cond), byte, rd, rn, minus, offset,
+                                                bang);
            }
        } else {
-            const char *transfer = "";
+            const char* transfer = "";
            if (write_back)
                transfer = "t";
-            return Common::StringFromFormat("%s%s%s%s\tr%d, [r%d], #%s%u",
+            return Common::StringFromFormat("%s%s%s%s\tr%d, [r%d], #%s%u", opname,
-                    opname, cond_to_str(cond), byte, transfer, rd, rn, minus, offset);
+                                            cond_to_str(cond), byte, transfer, rd, rn, minus,
+                                            offset);
        }
    }
@@ -662,48 +480,47 @@ std::string ARM_Disasm::DisassembleMem(u32 insn)
    u8 shift_type = (insn >> 5) & 0x3;
    u8 shift_amount = (insn >> 7) & 0x1f;
-    const char *shift_name = shift_names[shift_type];
+    const char* shift_name = shift_names[shift_type];
    if (is_pre) {
        if (shift_amount == 0) {
            if (shift_type == 0) {
-                return Common::StringFromFormat("%s%s%s\tr%d, [r%d, %sr%d]%s",
+                return Common::StringFromFormat("%s%s%s\tr%d, [r%d, %sr%d]%s", opname,
-                        opname, cond_to_str(cond), byte, rd, rn, minus, rm, bang);
+                                                cond_to_str(cond), byte, rd, rn, minus, rm, bang);
            }
            if (shift_type == 3) {
-                return Common::StringFromFormat("%s%s%s\tr%d, [r%d, %sr%d, RRX]%s",
+                return Common::StringFromFormat("%s%s%s\tr%d, [r%d, %sr%d, RRX]%s", opname,
-                        opname, cond_to_str(cond), byte, rd, rn, minus, rm, bang);
+                                                cond_to_str(cond), byte, rd, rn, minus, rm, bang);
            }
            shift_amount = 32;
        }
-        return Common::StringFromFormat("%s%s%s\tr%d, [r%d, %sr%d, %s #%u]%s",
+        return Common::StringFromFormat("%s%s%s\tr%d, [r%d, %sr%d, %s #%u]%s", opname,
-                opname, cond_to_str(cond), byte, rd, rn, minus, rm,
+                                        cond_to_str(cond), byte, rd, rn, minus, rm, shift_name,
-                shift_name, shift_amount, bang);
+                                        shift_amount, bang);
    }
-    const char *transfer = "";
+    const char* transfer = "";
    if (write_back)
        transfer = "t";
    if (shift_amount == 0) {
        if (shift_type == 0) {
-            return Common::StringFromFormat("%s%s%s%s\tr%d, [r%d], %sr%d",
+            return Common::StringFromFormat("%s%s%s%s\tr%d, [r%d], %sr%d", opname,
-                    opname, cond_to_str(cond), byte, transfer, rd, rn, minus, rm);
+                                            cond_to_str(cond), byte, transfer, rd, rn, minus, rm);
        }
        if (shift_type == 3) {
-            return Common::StringFromFormat("%s%s%s%s\tr%d, [r%d], %sr%d, RRX",
+            return Common::StringFromFormat("%s%s%s%s\tr%d, [r%d], %sr%d, RRX", opname,
-                    opname, cond_to_str(cond), byte, transfer, rd, rn, minus, rm);
+                                            cond_to_str(cond), byte, transfer, rd, rn, minus, rm);
        }
        shift_amount = 32;
    }
-    return Common::StringFromFormat("%s%s%s%s\tr%d, [r%d], %sr%d, %s #%u",
+    return Common::StringFromFormat("%s%s%s%s\tr%d, [r%d], %sr%d, %s #%u", opname,
-            opname, cond_to_str(cond), byte, transfer, rd, rn, minus, rm,
+                                    cond_to_str(cond), byte, transfer, rd, rn, minus, rm,
-            shift_name, shift_amount);
+                                    shift_name, shift_amount);
 }
-std::string ARM_Disasm::DisassembleMemHalf(u32 insn)
+std::string ARM_Disasm::DisassembleMemHalf(u32 insn) {
-{
    u8 cond = (insn >> 28) & 0xf;
    u8 is_load = (insn >> 20) & 0x1;
    u8 write_back = (insn >> 21) & 0x1;
@@ -716,11 +533,11 @@ std::string ARM_Disasm::DisassembleMemHalf(u32 insn)
    u8 rm = insn & 0xf;
    u8 offset = (((insn >> 8) & 0xf) << 4) | (insn & 0xf);
-    const char *opname = "ldr";
+    const char* opname = "ldr";
    if (is_load == 0)
        opname = "str";
-    const char *width = "";
+    const char* width = "";
    if (bits_65 == 1)
        width = "h";
    else if (bits_65 == 2)
@@ -728,38 +545,39 @@ std::string ARM_Disasm::DisassembleMemHalf(u32 insn)
    else
        width = "sh";
-    const char *bang = "";
+    const char* bang = "";
    if (write_back)
        bang = "!";
-    const char *minus = "";
+    const char* minus = "";
    if (is_up == 0)
        minus = "-";
    if (is_immed) {
        if (is_pre) {
            if (offset == 0) {
-                return Common::StringFromFormat("%s%s%s\tr%d, [r%d]", opname, cond_to_str(cond), width, rd, rn);
+                return Common::StringFromFormat("%s%s%s\tr%d, [r%d]", opname, cond_to_str(cond),
+                                                width, rd, rn);
            } else {
-                return Common::StringFromFormat("%s%s%s\tr%d, [r%d, #%s%u]%s",
+                return Common::StringFromFormat("%s%s%s\tr%d, [r%d, #%s%u]%s", opname,
-                        opname, cond_to_str(cond), width, rd, rn, minus, offset, bang);
+                                                cond_to_str(cond), width, rd, rn, minus, offset,
+                                                bang);
            }
        } else {
-            return Common::StringFromFormat("%s%s%s\tr%d, [r%d], #%s%u",
+            return Common::StringFromFormat("%s%s%s\tr%d, [r%d], #%s%u", opname, cond_to_str(cond),
-                    opname, cond_to_str(cond), width, rd, rn, minus, offset);
+                                            width, rd, rn, minus, offset);
        }
    }
    if (is_pre) {
-        return Common::StringFromFormat("%s%s%s\tr%d, [r%d, %sr%d]%s",
+        return Common::StringFromFormat("%s%s%s\tr%d, [r%d, %sr%d]%s", opname, cond_to_str(cond),
-                opname, cond_to_str(cond), width, rd, rn, minus, rm, bang);
+                                        width, rd, rn, minus, rm, bang);
    } else {
-        return Common::StringFromFormat("%s%s%s\tr%d, [r%d], %sr%d",
+        return Common::StringFromFormat("%s%s%s\tr%d, [r%d], %sr%d", opname, cond_to_str(cond),
-                opname, cond_to_str(cond), width, rd, rn, minus, rm);
+                                        width, rd, rn, minus, rm);
    }
 }
-std::string ARM_Disasm::DisassembleMCR(Opcode opcode, u32 insn)
+std::string ARM_Disasm::DisassembleMCR(Opcode opcode, u32 insn) {
-{
    u8 cond = (insn >> 28) & 0xf;
    u8 crn = (insn >> 16) & 0xf;
    u8 crd = (insn >> 12) & 0xf;
@@ -767,13 +585,12 @@ std::string ARM_Disasm::DisassembleMCR(Opcode opcode, u32 insn)
    u8 opcode2 = (insn >> 5) & 0x7;
    u8 crm = insn & 0xf;
-    const char *opname = opcode_names[opcode];
+    const char* opname = opcode_names[opcode];
-    return Common::StringFromFormat("%s%s\t%d, 0, r%d, cr%d, cr%d, {%d}",
+    return Common::StringFromFormat("%s%s\t%d, 0, r%d, cr%d, cr%d, {%d}", opname, cond_to_str(cond),
-            opname, cond_to_str(cond), cpnum, crd, crn, crm, opcode2);
+                                    cpnum, crd, crn, crm, opcode2);
 }
-std::string ARM_Disasm::DisassembleMLA(Opcode opcode, u32 insn)
+std::string ARM_Disasm::DisassembleMLA(Opcode opcode, u32 insn) {
-{
    u8 cond = (insn >> 28) & 0xf;
    u8 rd = (insn >> 16) & 0xf;
    u8 rn = (insn >> 12) & 0xf;
@@ -781,13 +598,12 @@ std::string ARM_Disasm::DisassembleMLA(Opcode opcode, u32 insn)
    u8 rm = insn & 0xf;
    u8 bit_s = (insn >> 20) & 1;
-    const char *opname = opcode_names[opcode];
+    const char* opname = opcode_names[opcode];
-    return Common::StringFromFormat("%s%s%s\tr%d, r%d, r%d, r%d",
+    return Common::StringFromFormat("%s%s%s\tr%d, r%d, r%d, r%d", opname, cond_to_str(cond),
-            opname, cond_to_str(cond), bit_s ? "s" : "", rd, rm, rs, rn);
+                                    bit_s ? "s" : "", rd, rm, rs, rn);
 }
-std::string ARM_Disasm::DisassembleUMLAL(Opcode opcode, u32 insn)
+std::string ARM_Disasm::DisassembleUMLAL(Opcode opcode, u32 insn) {
-{
    u8 cond = (insn >> 28) & 0xf;
    u8 rdhi = (insn >> 16) & 0xf;
    u8 rdlo = (insn >> 12) & 0xf;
@@ -795,26 +611,24 @@ std::string ARM_Disasm::DisassembleUMLAL(Opcode opcode, u32 insn)
    u8 rm = insn & 0xf;
    u8 bit_s = (insn >> 20) & 1;
-    const char *opname = opcode_names[opcode];
+    const char* opname = opcode_names[opcode];
-    return Common::StringFromFormat("%s%s%s\tr%d, r%d, r%d, r%d",
+    return Common::StringFromFormat("%s%s%s\tr%d, r%d, r%d, r%d", opname, cond_to_str(cond),
-            opname, cond_to_str(cond), bit_s ? "s" : "", rdlo, rdhi, rm, rs);
+                                    bit_s ? "s" : "", rdlo, rdhi, rm, rs);
 }
-std::string ARM_Disasm::DisassembleMUL(Opcode opcode, u32 insn)
+std::string ARM_Disasm::DisassembleMUL(Opcode opcode, u32 insn) {
-{
    u8 cond = (insn >> 28) & 0xf;
    u8 rd = (insn >> 16) & 0xf;
    u8 rs = (insn >> 8) & 0xf;
    u8 rm = insn & 0xf;
    u8 bit_s = (insn >> 20) & 1;
-    const char *opname = opcode_names[opcode];
+    const char* opname = opcode_names[opcode];
-    return Common::StringFromFormat("%s%s%s\tr%d, r%d, r%d",
+    return Common::StringFromFormat("%s%s%s\tr%d, r%d, r%d", opname, cond_to_str(cond),
-            opname, cond_to_str(cond), bit_s ? "s" : "", rd, rm, rs);
+                                    bit_s ? "s" : "", rd, rm, rs);
 }
-std::string ARM_Disasm::DisassembleMRS(u32 insn)
+std::string ARM_Disasm::DisassembleMRS(u32 insn) {
-{
    u8 cond = (insn >> 28) & 0xf;
    u8 rd = (insn >> 12) & 0xf;
    u8 ps = (insn >> 22) & 1;
@@ -822,8 +636,7 @@ std::string ARM_Disasm::DisassembleMRS(u32 insn)
    return Common::StringFromFormat("mrs%s\tr%d, %s", cond_to_str(cond), rd, ps ? "spsr" : "cpsr");
 }
-std::string ARM_Disasm::DisassembleMSR(u32 insn)
+std::string ARM_Disasm::DisassembleMSR(u32 insn) {
-{
    char flags[8];
    int flag_index = 0;
    u8 cond = (insn >> 28) & 0xf;
@@ -846,18 +659,17 @@ std::string ARM_Disasm::DisassembleMSR(u32 insn)
        u8 rotate = (insn >> 8) & 0xf;
        u8 rotate2 = rotate << 1;
        u32 rotated_val = (immed >> rotate2) | (immed << (32 - rotate2));
-        return Common::StringFromFormat("msr%s\t%s_%s, #0x%x",
+        return Common::StringFromFormat("msr%s\t%s_%s, #0x%x", cond_to_str(cond),
-                cond_to_str(cond), pd ? "spsr" : "cpsr", flags, rotated_val);
+                                        pd ? "spsr" : "cpsr", flags, rotated_val);
    }
    u8 rm = insn & 0xf;
-    return Common::StringFromFormat("msr%s\t%s_%s, r%d",
+    return Common::StringFromFormat("msr%s\t%s_%s, r%d", cond_to_str(cond), pd ? "spsr" : "cpsr",
-            cond_to_str(cond), pd ? "spsr" : "cpsr", flags, rm);
+                                    flags, rm);
 }
-std::string ARM_Disasm::DisassembleNoOperands(Opcode opcode, u32 insn)
+std::string ARM_Disasm::DisassembleNoOperands(Opcode opcode, u32 insn) {
-{
    u32 cond = BITS(insn, 28, 31);
    return Common::StringFromFormat("%s%s", opcode_names[opcode], cond_to_str(cond));
 }
@@ -872,8 +684,7 @@ std::string ARM_Disasm::DisassembleParallelAddSub(Opcode opcode, u32 insn) {
                                    rd, rn, rm);
 }
-std::string ARM_Disasm::DisassemblePKH(u32 insn)
+std::string ARM_Disasm::DisassemblePKH(u32 insn) {
-{
    u32 cond = BITS(insn, 28, 31);
    u32 rn = BITS(insn, 16, 19);
    u32 rd = BITS(insn, 12, 15);
@@ -896,13 +707,12 @@ std::string ARM_Disasm::DisassemblePKH(u32 insn)
                                    rd, rn, rm, shift.c_str());
 }
-std::string ARM_Disasm::DisassemblePLD(u32 insn)
+std::string ARM_Disasm::DisassemblePLD(u32 insn) {
-{
    u8 is_reg = (insn >> 25) & 0x1;
    u8 is_up = (insn >> 23) & 0x1;
    u8 rn = (insn >> 16) & 0xf;
-    const char *minus = "";
+    const char* minus = "";
    if (is_up == 0)
        minus = "-";
@@ -924,8 +734,8 @@ std::string ARM_Disasm::DisassembleREV(Opcode opcode, u32 insn) {
    u32 rd = BITS(insn, 12, 15);
    u32 rm = BITS(insn, 0, 3);
-    return Common::StringFromFormat("%s%s\tr%u, r%u", opcode_names[opcode], cond_to_str(cond),
+    return Common::StringFromFormat("%s%s\tr%u, r%u", opcode_names[opcode], cond_to_str(cond), rd,
-                                    rd, rm);
+                                    rm);
 }
 std::string ARM_Disasm::DisassembleREX(Opcode opcode, u32 insn) {
@@ -935,26 +745,26 @@ std::string ARM_Disasm::DisassembleREX(Opcode opcode, u32 insn) {
    u32 cond = BITS(insn, 28, 31);
    switch (opcode) {
-        case OP_STREX:
+    case OP_STREX:
-        case OP_STREXB:
+    case OP_STREXB:
-        case OP_STREXH:
+    case OP_STREXH:
-            return Common::StringFromFormat("%s%s\tr%d, r%d, [r%d]", opcode_names[opcode],
+        return Common::StringFromFormat("%s%s\tr%d, r%d, [r%d]", opcode_names[opcode],
-                                            cond_to_str(cond), rd, rt, rn);
+                                        cond_to_str(cond), rd, rt, rn);
-        case OP_STREXD:
+    case OP_STREXD:
-            return Common::StringFromFormat("%s%s\tr%d, r%d, r%d, [r%d]", opcode_names[opcode],
+        return Common::StringFromFormat("%s%s\tr%d, r%d, r%d, [r%d]", opcode_names[opcode],
-                                            cond_to_str(cond), rd, rt, rt + 1, rn);
+                                        cond_to_str(cond), rd, rt, rt + 1, rn);
-        // for LDREX instructions, rd corresponds to Rt from reference manual
+    // for LDREX instructions, rd corresponds to Rt from reference manual
-        case OP_LDREX:
+    case OP_LDREX:
-        case OP_LDREXB:
+    case OP_LDREXB:
-        case OP_LDREXH:
+    case OP_LDREXH:
-            return Common::StringFromFormat("%s%s\tr%d, [r%d]", opcode_names[opcode],
+        return Common::StringFromFormat("%s%s\tr%d, [r%d]", opcode_names[opcode], cond_to_str(cond),
-                                            cond_to_str(cond), rd, rn);
+                                        rd, rn);
-        case OP_LDREXD:
+    case OP_LDREXD:
-            return Common::StringFromFormat("%s%s\tr%d, r%d, [r%d]", opcode_names[opcode],
+        return Common::StringFromFormat("%s%s\tr%d, r%d, [r%d]", opcode_names[opcode],
-                                            cond_to_str(cond), rd, rd + 1, rn);
+                                        cond_to_str(cond), rd, rd + 1, rn);
-        default:
+    default:
-            return opcode_names[OP_UNDEFINED];
+        return opcode_names[OP_UNDEFINED];
    }
 }
@@ -982,8 +792,8 @@ std::string ARM_Disasm::DisassembleSAT(Opcode opcode, u32 insn) {
    if (opcode == OP_SSAT || opcode == OP_SSAT16)
        sat_imm++;
-    return Common::StringFromFormat("%s%s\tr%u, #%u, r%u%s", opcode_names[opcode], cond_to_str(cond), rd,
+    return Common::StringFromFormat("%s%s\tr%u, #%u, r%u%s", opcode_names[opcode],
-                                    sat_imm, rn, shift_part.c_str());
+                                    cond_to_str(cond), rd, sat_imm, rn, shift_part.c_str());
 }
 std::string ARM_Disasm::DisassembleSEL(u32 insn) {
@@ -996,27 +806,24 @@ std::string ARM_Disasm::DisassembleSEL(u32 insn) {
                                    rd, rn, rm);
 }
-std::string ARM_Disasm::DisassembleSWI(u32 insn)
+std::string ARM_Disasm::DisassembleSWI(u32 insn) {
-{
    u8 cond = (insn >> 28) & 0xf;
    u32 sysnum = insn & 0x00ffffff;
    return Common::StringFromFormat("swi%s 0x%x", cond_to_str(cond), sysnum);
 }
-std::string ARM_Disasm::DisassembleSWP(Opcode opcode, u32 insn)
+std::string ARM_Disasm::DisassembleSWP(Opcode opcode, u32 insn) {
-{
    u8 cond = (insn >> 28) & 0xf;
    u8 rn = (insn >> 16) & 0xf;
    u8 rd = (insn >> 12) & 0xf;
    u8 rm = insn & 0xf;
-    const char *opname = opcode_names[opcode];
+    const char* opname = opcode_names[opcode];
    return Common::StringFromFormat("%s%s\tr%d, r%d, [r%d]", opname, cond_to_str(cond), rd, rm, rn);
 }
-std::string ARM_Disasm::DisassembleXT(Opcode opcode, u32 insn)
+std::string ARM_Disasm::DisassembleXT(Opcode opcode, u32 insn) {
-{
    u32 cond = BITS(insn, 28, 31);
    u32 rn = BITS(insn, 16, 19);
    u32 rd = BITS(insn, 12, 15);
@@ -1025,9 +832,7 @@ std::string ARM_Disasm::DisassembleXT(Opcode opcode, u32 insn)
    std::string rn_part = "";
    static std::unordered_set<Opcode, std::hash<int>> extend_with_add = {
-        OP_SXTAB, OP_SXTAB16, OP_SXTAH,
+        OP_SXTAB, OP_SXTAB16, OP_SXTAH, OP_UXTAB, OP_UXTAB16, OP_UXTAH};
-        OP_UXTAB, OP_UXTAB16, OP_UXTAH
-    };
    if (extend_with_add.find(opcode) != extend_with_add.end())
        rn_part = ", r" + std::to_string(rn);
@@ -1042,14 +847,14 @@ std::string ARM_Disasm::DisassembleXT(Opcode opcode, u32 insn)
 Opcode ARM_Disasm::Decode(u32 insn) {
    u32 bits27_26 = (insn >> 26) & 0x3;
    switch (bits27_26) {
-        case 0x0:
+    case 0x0:
-            return Decode00(insn);
+        return Decode00(insn);
-        case 0x1:
+    case 0x1:
-            return Decode01(insn);
+        return Decode01(insn);
-        case 0x2:
+    case 0x2:
-            return Decode10(insn);
+        return Decode10(insn);
-        case 0x3:
+    case 0x3:
-            return Decode11(insn);
+        return Decode11(insn);
    }
    return OP_INVALID;
 }
@@ -1198,28 +1003,28 @@ Opcode ARM_Disasm::DecodeSyncPrimitive(u32 insn) {
    u32 op = BITS(insn, 20, 23);
    u32 bit22 = BIT(insn, 22);
    switch (op) {
-        case 0x0:
+    case 0x0:
-            if (bit22)
+        if (bit22)
-                return OP_SWPB;
+            return OP_SWPB;
-            return OP_SWP;
+        return OP_SWP;
-        case 0x8:
+    case 0x8:
-            return OP_STREX;
+        return OP_STREX;
-        case 0x9:
+    case 0x9:
-            return OP_LDREX;
+        return OP_LDREX;
-        case 0xA:
+    case 0xA:
-            return OP_STREXD;
+        return OP_STREXD;
-        case 0xB:
+    case 0xB:
-            return OP_LDREXD;
+        return OP_LDREXD;
-        case 0xC:
+    case 0xC:
-            return OP_STREXB;
+        return OP_STREXB;
-        case 0xD:
+    case 0xD:
-            return OP_LDREXB;
+        return OP_LDREXB;
-        case 0xE:
+    case 0xE:
-            return OP_STREXH;
+        return OP_STREXH;
-        case 0xF:
+    case 0xF:
-            return OP_LDREXH;
+        return OP_LDREXH;
-        default:
+    default:
-            return OP_UNDEFINED;
+        return OP_UNDEFINED;
    }
 }
@@ -1240,27 +1045,14 @@ Opcode ARM_Disasm::DecodeParallelAddSub(u32 insn) {
    static std::vector<Opcode> opcodes = {
        // op1 = 0
-        OP_SADD16, OP_UADD16,
+        OP_SADD16, OP_UADD16, OP_SASX, OP_UASX, OP_SSAX, OP_USAX, OP_SSUB16, OP_USUB16, OP_SADD8,
-        OP_SASX, OP_UASX,
+        OP_UADD8, OP_SSUB8, OP_USUB8,
-        OP_SSAX, OP_USAX,
-        OP_SSUB16, OP_USUB16,
-        OP_SADD8, OP_UADD8,
-        OP_SSUB8, OP_USUB8,
        // op1 = 1
-        OP_QADD16, OP_UQADD16,
+        OP_QADD16, OP_UQADD16, OP_QASX, OP_UQASX, OP_QSAX, OP_UQSAX, OP_QSUB16, OP_UQSUB16,
-        OP_QASX, OP_UQASX,
+        OP_QADD8, OP_UQADD8, OP_QSUB8, OP_UQSUB8,
-        OP_QSAX, OP_UQSAX,
-        OP_QSUB16, OP_UQSUB16,
-        OP_QADD8, OP_UQADD8,
-        OP_QSUB8, OP_UQSUB8,
        // op1 = 2
-        OP_SHADD16, OP_UHADD16,
+        OP_SHADD16, OP_UHADD16, OP_SHASX, OP_UHASX, OP_SHSAX, OP_UHSAX, OP_SHSUB16, OP_UHSUB16,
-        OP_SHASX, OP_UHASX,
+        OP_SHADD8, OP_UHADD8, OP_SHSUB8, OP_UHSUB8};
-        OP_SHSAX, OP_UHSAX,
-        OP_SHSUB16, OP_UHSUB16,
-        OP_SHADD8, OP_UHADD8,
-        OP_SHSUB8, OP_UHSUB8
-    };
    u32 opcode_index = op1 * 12 + op2 * 2 + is_unsigned;
    return opcodes[opcode_index];
@@ -1272,66 +1064,66 @@ Opcode ARM_Disasm::DecodePackingSaturationReversal(u32 insn) {
    u32 op2 = BITS(insn, 5, 7);
    switch (op1) {
-        case 0x0:
+    case 0x0:
-            if (BIT(op2, 0) == 0)
+        if (BIT(op2, 0) == 0)
-                return OP_PKH;
+            return OP_PKH;
-            if (op2 == 0x3 && a != 0xf)
+        if (op2 == 0x3 && a != 0xf)
-                return OP_SXTAB16;
+            return OP_SXTAB16;
-            if (op2 == 0x3 && a == 0xf)
+        if (op2 == 0x3 && a == 0xf)
-                return OP_SXTB16;
+            return OP_SXTB16;
-            if (op2 == 0x5)
+        if (op2 == 0x5)
-                return OP_SEL;
+            return OP_SEL;
-            break;
+        break;
-        case 0x2:
+    case 0x2:
-            if (BIT(op2, 0) == 0)
+        if (BIT(op2, 0) == 0)
-                return OP_SSAT;
+            return OP_SSAT;
-            if (op2 == 0x1)
+        if (op2 == 0x1)
-                return OP_SSAT16;
+            return OP_SSAT16;
-            if (op2 == 0x3 && a != 0xf)
+        if (op2 == 0x3 && a != 0xf)
-                return OP_SXTAB;
+            return OP_SXTAB;
-            if (op2 == 0x3 && a == 0xf)
+        if (op2 == 0x3 && a == 0xf)
-                return OP_SXTB;
+            return OP_SXTB;
-            break;
+        break;
-        case 0x3:
+    case 0x3:
-            if (op2 == 0x1)
+        if (op2 == 0x1)
-                return OP_REV;
+            return OP_REV;
-            if (BIT(op2, 0) == 0)
+        if (BIT(op2, 0) == 0)
-                return OP_SSAT;
+            return OP_SSAT;
-            if (op2 == 0x3 && a != 0xf)
+        if (op2 == 0x3 && a != 0xf)
-                return OP_SXTAH;
+            return OP_SXTAH;
-            if (op2 == 0x3 && a == 0xf)
+        if (op2 == 0x3 && a == 0xf)
-                return OP_SXTH;
+            return OP_SXTH;
-            if (op2 == 0x5)
+        if (op2 == 0x5)
-                return OP_REV16;
+            return OP_REV16;
-            break;
+        break;
-        case 0x4:
+    case 0x4:
-            if (op2 == 0x3 && a != 0xf)
+        if (op2 == 0x3 && a != 0xf)
-                return OP_UXTAB16;
+            return OP_UXTAB16;
-            if (op2 == 0x3 && a == 0xf)
+        if (op2 == 0x3 && a == 0xf)
-                return OP_UXTB16;
+            return OP_UXTB16;
-            break;
+        break;
-        case 0x6:
+    case 0x6:
-            if (BIT(op2, 0) == 0)
+        if (BIT(op2, 0) == 0)
-                return OP_USAT;
+            return OP_USAT;
-            if (op2 == 0x1)
+        if (op2 == 0x1)
-                return OP_USAT16;
+            return OP_USAT16;
-            if (op2 == 0x3 && a != 0xf)
+        if (op2 == 0x3 && a != 0xf)
-                return OP_UXTAB;
+            return OP_UXTAB;
-            if (op2 == 0x3 && a == 0xf)
+        if (op2 == 0x3 && a == 0xf)
-                return OP_UXTB;
+            return OP_UXTB;
-            break;
+        break;
-        case 0x7:
+    case 0x7:
-            if (BIT(op2, 0) == 0)
+        if (BIT(op2, 0) == 0)
-                return OP_USAT;
+            return OP_USAT;
-            if (op2 == 0x3 && a != 0xf)
+        if (op2 == 0x3 && a != 0xf)
-                return OP_UXTAH;
+            return OP_UXTAH;
-            if (op2 == 0x3 && a == 0xf)
+        if (op2 == 0x3 && a == 0xf)
-                return OP_UXTH;
+            return OP_UXTH;
-            if (op2 == 0x5)
+        if (op2 == 0x5)
-                return OP_REVSH;
+            return OP_REVSH;
-            break;
+        break;
-        default:
+    default:
-            break;
+        break;
    }
    return OP_UNDEFINED;
@@ -1378,18 +1170,18 @@ Opcode ARM_Disasm::DecodeMSRImmAndHints(u32 insn) {
    if (op == 0 && op1 == 0) {
        switch (op2) {
-            case 0x0:
+        case 0x0:
-                return OP_NOP;
+            return OP_NOP;
-            case 0x1:
+        case 0x1:
-                return OP_YIELD;
+            return OP_YIELD;
-            case 0x2:
+        case 0x2:
-                return OP_WFE;
+            return OP_WFE;
-            case 0x3:
+        case 0x3:
-                return OP_WFI;
+            return OP_WFI;
-            case 0x4:
+        case 0x4:
-                return OP_SEV;
+            return OP_SEV;
-            default:
+        default:
-                return OP_UNDEFINED;
+            return OP_UNDEFINED;
        }
    }
@@ -1402,37 +1194,37 @@ Opcode ARM_Disasm::DecodeMediaMulDiv(u32 insn) {
    u32 a = BITS(insn, 12, 15);
    switch (op1) {
-        case 0x0:
+    case 0x0:
-            if (op2_h == 0x0) {
+        if (op2_h == 0x0) {
-                if (a != 0xf)
+            if (a != 0xf)
-                    return OP_SMLAD;
+                return OP_SMLAD;
-                else
+            else
-                    return OP_SMUAD;
+                return OP_SMUAD;
-            } else if (op2_h == 0x1) {
+        } else if (op2_h == 0x1) {
-                if (a != 0xf)
+            if (a != 0xf)
-                    return OP_SMLSD;
+                return OP_SMLSD;
-                else
+            else
-                    return OP_SMUSD;
+                return OP_SMUSD;
-            }
+        }
-            break;
+        break;
-        case 0x4:
+    case 0x4:
-            if (op2_h == 0x0)
+        if (op2_h == 0x0)
-                return OP_SMLALD;
+            return OP_SMLALD;
-            else if (op2_h == 0x1)
+        else if (op2_h == 0x1)
-                return OP_SMLSLD;
+            return OP_SMLSLD;
-            break;
+        break;
-        case 0x5:
+    case 0x5:
-            if (op2_h == 0x0) {
+        if (op2_h == 0x0) {
-                if (a != 0xf)
+            if (a != 0xf)
-                    return OP_SMMLA;
+                return OP_SMMLA;
-                else
+            else
-                    return OP_SMMUL;
+                return OP_SMMUL;
-            } else if (op2_h == 0x3) {
+        } else if (op2_h == 0x3) {
-                return OP_SMMLS;
+            return OP_SMMLS;
-            }
+        }
-            break;
+        break;
-        default:
+    default:
-            break;
+        break;
    }
    return OP_UNDEFINED;
@@ -1444,23 +1236,23 @@ Opcode ARM_Disasm::DecodeMedia(u32 insn) {
    u32 op2 = BITS(insn, 5, 7);
    switch (BITS(op1, 3, 4)) {
-        case 0x0:
+    case 0x0:
-            // unsigned and signed parallel addition and subtraction
+        // unsigned and signed parallel addition and subtraction
-            return DecodeParallelAddSub(insn);
+        return DecodeParallelAddSub(insn);
-        case 0x1:
+    case 0x1:
-            // Packing, unpacking, saturation, and reversal
+        // Packing, unpacking, saturation, and reversal
-            return DecodePackingSaturationReversal(insn);
+        return DecodePackingSaturationReversal(insn);
-        case 0x2:
+    case 0x2:
-            // Signed multiply, signed and unsigned divide
+        // Signed multiply, signed and unsigned divide
-            return DecodeMediaMulDiv(insn);
+        return DecodeMediaMulDiv(insn);
-        case 0x3:
+    case 0x3:
-            if (op2 == 0 && rd == 0xf)
+        if (op2 == 0 && rd == 0xf)
-                return OP_USAD8;
+            return OP_USAD8;
-            if (op2 == 0 && rd != 0xf)
+        if (op2 == 0 && rd != 0xf)
-                return OP_USADA8;
+            return OP_USADA8;
-            break;
+        break;
-        default:
+    default:
-            break;
+        break;
    }
    return OP_UNDEFINED;
@@ -1508,46 +1300,46 @@ Opcode ARM_Disasm::DecodeALU(u32 insn) {
        return OP_UNDEFINED;
    }
    switch (opcode) {
-        case 0x0:
+    case 0x0:
-            return OP_AND;
+        return OP_AND;
-        case 0x1:
+    case 0x1:
-            return OP_EOR;
+        return OP_EOR;
-        case 0x2:
+    case 0x2:
-            return OP_SUB;
+        return OP_SUB;
-        case 0x3:
+    case 0x3:
-            return OP_RSB;
+        return OP_RSB;
-        case 0x4:
+    case 0x4:
-            return OP_ADD;
+        return OP_ADD;
-        case 0x5:
+    case 0x5:
-            return OP_ADC;
+        return OP_ADC;
-        case 0x6:
+    case 0x6:
-            return OP_SBC;
+        return OP_SBC;
-        case 0x7:
+    case 0x7:
-            return OP_RSC;
+        return OP_RSC;
-        case 0x8:
+    case 0x8:
-            if (bit_s)
+        if (bit_s)
-                return OP_TST;
+            return OP_TST;
-            return OP_MRS;
+        return OP_MRS;
-        case 0x9:
+    case 0x9:
-            if (bit_s)
+        if (bit_s)
-                return OP_TEQ;
+            return OP_TEQ;
-            return OP_MSR;
+        return OP_MSR;
-        case 0xa:
+    case 0xa:
-            if (bit_s)
+        if (bit_s)
-                return OP_CMP;
+            return OP_CMP;
-            return OP_MRS;
+        return OP_MRS;
-        case 0xb:
+    case 0xb:
-            if (bit_s)
+        if (bit_s)
-                return OP_CMN;
+            return OP_CMN;
-            return OP_MSR;
+        return OP_MSR;
-        case 0xc:
+    case 0xc:
-            return OP_ORR;
+        return OP_ORR;
-        case 0xd:
+    case 0xd:
-            return OP_MOV;
+        return OP_MOV;
-        case 0xe:
+    case 0xe:
-            return OP_BIC;
+        return OP_BIC;
-        case 0xf:
+    case 0xf:
-            return OP_MVN;
+        return OP_MVN;
    }
    // Unreachable
    return OP_INVALID;
diff --git a/src/core/arm/disassembler/arm_disasm.h b/src/core/arm/disassembler/arm_disasm.h
index 53d9c6a74..031f973d6 100644
--- a/src/core/arm/disassembler/arm_disasm.h
+++ b/src/core/arm/disassembler/arm_disasm.h
@@ -187,53 +187,53 @@ enum Opcode {
    OP_THUMB_SWI,
    OP_THUMB_TST,
-    OP_END                // must be last
+    OP_END // must be last
 };
 class ARM_Disasm {
- public:
+public:
-  static std::string Disassemble(u32 addr, u32 insn);
+    static std::string Disassemble(u32 addr, u32 insn);
-  static Opcode Decode(u32 insn);
+    static Opcode Decode(u32 insn);
- private:
+private:
-  static Opcode Decode00(u32 insn);
+    static Opcode Decode00(u32 insn);
-  static Opcode Decode01(u32 insn);
+    static Opcode Decode01(u32 insn);
-  static Opcode Decode10(u32 insn);
+    static Opcode Decode10(u32 insn);
-  static Opcode Decode11(u32 insn);
+    static Opcode Decode11(u32 insn);
-  static Opcode DecodeSyncPrimitive(u32 insn);
+    static Opcode DecodeSyncPrimitive(u32 insn);
-  static Opcode DecodeParallelAddSub(u32 insn);
+    static Opcode DecodeParallelAddSub(u32 insn);
-  static Opcode DecodePackingSaturationReversal(u32 insn);
+    static Opcode DecodePackingSaturationReversal(u32 insn);
-  static Opcode DecodeMUL(u32 insn);
+    static Opcode DecodeMUL(u32 insn);
-  static Opcode DecodeMSRImmAndHints(u32 insn);
+    static Opcode DecodeMSRImmAndHints(u32 insn);
-  static Opcode DecodeMediaMulDiv(u32 insn);
+    static Opcode DecodeMediaMulDiv(u32 insn);
-  static Opcode DecodeMedia(u32 insn);
+    static Opcode DecodeMedia(u32 insn);
-  static Opcode DecodeLDRH(u32 insn);
+    static Opcode DecodeLDRH(u32 insn);
-  static Opcode DecodeALU(u32 insn);
+    static Opcode DecodeALU(u32 insn);
-  static std::string DisassembleALU(Opcode opcode, u32 insn);
+    static std::string DisassembleALU(Opcode opcode, u32 insn);
-  static std::string DisassembleBranch(u32 addr, Opcode opcode, u32 insn);
+    static std::string DisassembleBranch(u32 addr, Opcode opcode, u32 insn);
-  static std::string DisassembleBX(u32 insn);
+    static std::string DisassembleBX(u32 insn);
-  static std::string DisassembleBKPT(u32 insn);
+    static std::string DisassembleBKPT(u32 insn);
-  static std::string DisassembleCLZ(u32 insn);
+    static std::string DisassembleCLZ(u32 insn);
-  static std::string DisassembleMediaMulDiv(Opcode opcode, u32 insn);
+    static std::string DisassembleMediaMulDiv(Opcode opcode, u32 insn);
-  static std::string DisassembleMemblock(Opcode opcode, u32 insn);
+    static std::string DisassembleMemblock(Opcode opcode, u32 insn);
-  static std::string DisassembleMem(u32 insn);
+    static std::string DisassembleMem(u32 insn);
-  static std::string DisassembleMemHalf(u32 insn);
+    static std::string DisassembleMemHalf(u32 insn);
-  static std::string DisassembleMCR(Opcode opcode, u32 insn);
+    static std::string DisassembleMCR(Opcode opcode, u32 insn);
-  static std::string DisassembleMLA(Opcode opcode, u32 insn);
+    static std::string DisassembleMLA(Opcode opcode, u32 insn);
-  static std::string DisassembleUMLAL(Opcode opcode, u32 insn);
+    static std::string DisassembleUMLAL(Opcode opcode, u32 insn);
-  static std::string DisassembleMUL(Opcode opcode, u32 insn);
+    static std::string DisassembleMUL(Opcode opcode, u32 insn);
-  static std::string DisassembleMRS(u32 insn);
+    static std::string DisassembleMRS(u32 insn);
-  static std::string DisassembleMSR(u32 insn);
+    static std::string DisassembleMSR(u32 insn);
-  static std::string DisassembleNoOperands(Opcode opcode, u32 insn);
+    static std::string DisassembleNoOperands(Opcode opcode, u32 insn);
-  static std::string DisassembleParallelAddSub(Opcode opcode, u32 insn);
+    static std::string DisassembleParallelAddSub(Opcode opcode, u32 insn);
-  static std::string DisassemblePKH(u32 insn);
+    static std::string DisassemblePKH(u32 insn);
-  static std::string DisassemblePLD(u32 insn);
+    static std::string DisassemblePLD(u32 insn);
-  static std::string DisassembleREV(Opcode opcode, u32 insn);
+    static std::string DisassembleREV(Opcode opcode, u32 insn);
-  static std::string DisassembleREX(Opcode opcode, u32 insn);
+    static std::string DisassembleREX(Opcode opcode, u32 insn);
-  static std::string DisassembleSAT(Opcode opcode, u32 insn);
+    static std::string DisassembleSAT(Opcode opcode, u32 insn);
-  static std::string DisassembleSEL(u32 insn);
+    static std::string DisassembleSEL(u32 insn);
-  static std::string DisassembleSWI(u32 insn);
+    static std::string DisassembleSWI(u32 insn);
-  static std::string DisassembleSWP(Opcode opcode, u32 insn);
+    static std::string DisassembleSWP(Opcode opcode, u32 insn);
-  static std::string DisassembleXT(Opcode opcode, u32 insn);
+    static std::string DisassembleXT(Opcode opcode, u32 insn);
 };
diff --git a/src/core/arm/disassembler/load_symbol_map.cpp b/src/core/arm/disassembler/load_symbol_map.cpp
index eb20bf6f7..58e8e6fa1 100644
--- a/src/core/arm/disassembler/load_symbol_map.cpp
+++ b/src/core/arm/disassembler/load_symbol_map.cpp
@@ -6,8 +6,8 @@
 #include <string>
 #include <vector>
-#include "common/symbols.h"
 #include "common/file_util.h"
+#include "common/symbols.h"
 #include "core/arm/disassembler/load_symbol_map.h"
diff --git a/src/core/arm/dyncom/arm_dyncom_dec.cpp b/src/core/arm/dyncom/arm_dyncom_dec.cpp
index 6dbc92b91..64dcaae08 100644
--- a/src/core/arm/dyncom/arm_dyncom_dec.cpp
+++ b/src/core/arm/dyncom/arm_dyncom_dec.cpp
@@ -430,12 +430,15 @@ ARMDecodeStatus DecodeARMInstruction(u32 instr, s32* idx) {
            continue;
        while (n) {
-            if (arm_instruction[i].content[base + 1] == 31 && arm_instruction[i].content[base] == 0) {
+            if (arm_instruction[i].content[base + 1] == 31 &&
+                arm_instruction[i].content[base] == 0) {
                // clrex
                if (instr != arm_instruction[i].content[base + 2]) {
                    break;
                }
-            } else if (BITS(instr, arm_instruction[i].content[base], arm_instruction[i].content[base + 1]) != arm_instruction[i].content[base + 2]) {
+            } else if (BITS(instr, arm_instruction[i].content[base],
+                            arm_instruction[i].content[base + 1]) !=
+                       arm_instruction[i].content[base + 2]) {
                break;
            }
            base += 3;
@@ -451,7 +454,9 @@ ARMDecodeStatus DecodeARMInstruction(u32 instr, s32* idx) {
            if (n != 0) {
                base = 0;
                while (n) {
-                    if (BITS(instr, arm_exclusion_code[i].content[base], arm_exclusion_code[i].content[base + 1]) != arm_exclusion_code[i].content[base + 2]) {
+                    if (BITS(instr, arm_exclusion_code[i].content[base],
+                             arm_exclusion_code[i].content[base + 1]) !=
+                        arm_exclusion_code[i].content[base + 2]) {
                        break;
                    }
                    base += 3;
diff --git a/src/core/arm/dyncom/arm_dyncom_dec.h b/src/core/arm/dyncom/arm_dyncom_dec.h
index d7170e0fc..2fb7ac37c 100644
--- a/src/core/arm/dyncom/arm_dyncom_dec.h
+++ b/src/core/arm/dyncom/arm_dyncom_dec.h
@@ -6,15 +6,12 @@
 #include "common/common_types.h"
-enum class ARMDecodeStatus {
+enum class ARMDecodeStatus { SUCCESS, FAILURE };
-    SUCCESS,
-    FAILURE
-};
 ARMDecodeStatus DecodeARMInstruction(u32 instr, s32* idx);
 struct InstructionSetEncodingItem {
-    const char *name;
+    const char* name;
    int attribute_value;
    int version;
    u32 content[21];
diff --git a/src/core/arm/dyncom/arm_dyncom_interpreter.cpp b/src/core/arm/dyncom/arm_dyncom_interpreter.cpp
index c8d45c6db..211d49edb 100644
--- a/src/core/arm/dyncom/arm_dyncom_interpreter.cpp
+++ b/src/core/arm/dyncom/arm_dyncom_interpreter.cpp
@@ -11,29 +11,29 @@
 #include "common/logging/log.h"
 #include "common/microprofile.h"
-#include "core/memory.h"
-#include "core/hle/svc.h"
 #include "core/arm/disassembler/arm_disasm.h"
 #include "core/arm/dyncom/arm_dyncom_dec.h"
 #include "core/arm/dyncom/arm_dyncom_interpreter.h"
+#include "core/arm/dyncom/arm_dyncom_run.h"
 #include "core/arm/dyncom/arm_dyncom_thumb.h"
 #include "core/arm/dyncom/arm_dyncom_trans.h"
-#include "core/arm/dyncom/arm_dyncom_run.h"
 #include "core/arm/skyeye_common/armstate.h"
 #include "core/arm/skyeye_common/armsupp.h"
 #include "core/arm/skyeye_common/vfp/vfp.h"
+#include "core/hle/svc.h"
+#include "core/memory.h"
 #include "core/gdbstub/gdbstub.h"
-#define RM    BITS(sht_oper, 0, 3)
+#define RM BITS(sht_oper, 0, 3)
-#define RS    BITS(sht_oper, 8, 11)
+#define RS BITS(sht_oper, 8, 11)
-#define glue(x, y)            x ## y
+#define glue(x, y) x##y
-#define DPO(s)                glue(DataProcessingOperands, s)
+#define DPO(s) glue(DataProcessingOperands, s)
 #define ROTATE_RIGHT(n, i, l) ((n << (l - i)) | (n >> i))
-#define ROTATE_LEFT(n, i, l)  ((n >> (l - i)) | (n << i))
+#define ROTATE_LEFT(n, i, l) ((n >> (l - i)) | (n << i))
 #define ROTATE_RIGHT_32(n, i) ROTATE_RIGHT(n, i, 32)
-#define ROTATE_LEFT_32(n, i)  ROTATE_LEFT(n, i, 32)
+#define ROTATE_LEFT_32(n, i) ROTATE_LEFT(n, i, 32)
 static bool CondPassed(const ARMul_State* cpu, unsigned int cond) {
    const bool n_flag = cpu->NFlag != 0;
@@ -232,17 +232,19 @@ static unsigned int DPO(RotateRightByRegister)(ARMul_State* cpu, unsigned int sh
    return shifter_operand;
 }
-#define DEBUG_MSG LOG_DEBUG(Core_ARM11, "inst is %x", inst); CITRA_IGNORE_EXIT(0)
+#define DEBUG_MSG                                                                                  \
+    LOG_DEBUG(Core_ARM11, "inst is %x", inst);                                                     \
+    CITRA_IGNORE_EXIT(0)
-#define LnSWoUB(s)   glue(LnSWoUB, s)
+#define LnSWoUB(s) glue(LnSWoUB, s)
-#define MLnS(s)      glue(MLnS, s)
+#define MLnS(s) glue(MLnS, s)
-#define LdnStM(s)    glue(LdnStM, s)
+#define LdnStM(s) glue(LdnStM, s)
-#define W_BIT        BIT(inst, 21)
+#define W_BIT BIT(inst, 21)
-#define U_BIT        BIT(inst, 23)
+#define U_BIT BIT(inst, 23)
-#define I_BIT        BIT(inst, 25)
+#define I_BIT BIT(inst, 25)
-#define P_BIT        BIT(inst, 24)
+#define P_BIT BIT(inst, 24)
-#define OFFSET_12    BITS(inst, 0, 11)
+#define OFFSET_12 BITS(inst, 0, 11)
 static void LnSWoUB(ImmediateOffset)(ARMul_State* cpu, unsigned int inst, unsigned int& virt_addr) {
    unsigned int Rn = BITS(inst, 16, 19);
@@ -271,7 +273,8 @@ static void LnSWoUB(RegisterOffset)(ARMul_State* cpu, unsigned int inst, unsigne
    virt_addr = addr;
 }
-static void LnSWoUB(ImmediatePostIndexed)(ARMul_State* cpu, unsigned int inst, unsigned int& virt_addr) {
+static void LnSWoUB(ImmediatePostIndexed)(ARMul_State* cpu, unsigned int inst,
+                                          unsigned int& virt_addr) {
    unsigned int Rn = BITS(inst, 16, 19);
    unsigned int addr = CHECK_READ_REG15_WA(cpu, Rn);
@@ -283,7 +286,8 @@ static void LnSWoUB(ImmediatePostIndexed)(ARMul_State* cpu, unsigned int inst, u
    virt_addr = addr;
 }
-static void LnSWoUB(ImmediatePreIndexed)(ARMul_State* cpu, unsigned int inst, unsigned int& virt_addr) {
+static void LnSWoUB(ImmediatePreIndexed)(ARMul_State* cpu, unsigned int inst,
+                                         unsigned int& virt_addr) {
    unsigned int Rn = BITS(inst, 16, 19);
    unsigned int addr;
@@ -301,7 +305,7 @@ static void LnSWoUB(ImmediatePreIndexed)(ARMul_State* cpu, unsigned int inst, un
 static void MLnS(RegisterPreIndexed)(ARMul_State* cpu, unsigned int inst, unsigned int& virt_addr) {
    unsigned int addr;
    unsigned int Rn = BITS(inst, 16, 19);
-    unsigned int Rm = BITS(inst,  0,  3);
+    unsigned int Rm = BITS(inst, 0, 3);
    unsigned int rn = CHECK_READ_REG15_WA(cpu, Rn);
    unsigned int rm = CHECK_READ_REG15_WA(cpu, Rm);
@@ -316,7 +320,8 @@ static void MLnS(RegisterPreIndexed)(ARMul_State* cpu, unsigned int inst, unsign
        cpu->Reg[Rn] = addr;
 }
-static void LnSWoUB(RegisterPreIndexed)(ARMul_State* cpu, unsigned int inst, unsigned int& virt_addr) {
+static void LnSWoUB(RegisterPreIndexed)(ARMul_State* cpu, unsigned int inst,
+                                        unsigned int& virt_addr) {
    unsigned int Rn = BITS(inst, 16, 19);
    unsigned int Rm = BITS(inst, 0, 3);
    unsigned int rn = CHECK_READ_REG15_WA(cpu, Rn);
@@ -335,7 +340,8 @@ static void LnSWoUB(RegisterPreIndexed)(ARMul_State* cpu, unsigned int inst, uns
    }
 }
-static void LnSWoUB(ScaledRegisterPreIndexed)(ARMul_State* cpu, unsigned int inst, unsigned int& virt_addr) {
+static void LnSWoUB(ScaledRegisterPreIndexed)(ARMul_State* cpu, unsigned int inst,
+                                              unsigned int& virt_addr) {
    unsigned int shift = BITS(inst, 5, 6);
    unsigned int shift_imm = BITS(inst, 7, 11);
    unsigned int Rn = BITS(inst, 16, 19);
@@ -386,7 +392,8 @@ static void LnSWoUB(ScaledRegisterPreIndexed)(ARMul_State* cpu, unsigned int ins
        cpu->Reg[Rn] = addr;
 }
-static void LnSWoUB(ScaledRegisterPostIndexed)(ARMul_State* cpu, unsigned int inst, unsigned int& virt_addr) {
+static void LnSWoUB(ScaledRegisterPostIndexed)(ARMul_State* cpu, unsigned int inst,
+                                               unsigned int& virt_addr) {
    unsigned int shift = BITS(inst, 5, 6);
    unsigned int shift_imm = BITS(inst, 7, 11);
    unsigned int Rn = BITS(inst, 16, 19);
@@ -435,9 +442,10 @@ static void LnSWoUB(ScaledRegisterPostIndexed)(ARMul_State* cpu, unsigned int in
    }
 }
-static void LnSWoUB(RegisterPostIndexed)(ARMul_State* cpu, unsigned int inst, unsigned int& virt_addr) {
+static void LnSWoUB(RegisterPostIndexed)(ARMul_State* cpu, unsigned int inst,
+                                         unsigned int& virt_addr) {
    unsigned int Rn = BITS(inst, 16, 19);
-    unsigned int Rm = BITS(inst,  0,  3);
+    unsigned int Rm = BITS(inst, 0, 3);
    unsigned int rm = CHECK_READ_REG15_WA(cpu, Rm);
    virt_addr = CHECK_READ_REG15_WA(cpu, Rn);
@@ -454,7 +462,7 @@ static void LnSWoUB(RegisterPostIndexed)(ARMul_State* cpu, unsigned int inst, un
 static void MLnS(ImmediateOffset)(ARMul_State* cpu, unsigned int inst, unsigned int& virt_addr) {
    unsigned int immedL = BITS(inst, 0, 3);
    unsigned int immedH = BITS(inst, 8, 11);
-    unsigned int Rn     = BITS(inst, 16, 19);
+    unsigned int Rn = BITS(inst, 16, 19);
    unsigned int addr;
    unsigned int offset_8 = (immedH << 4) | immedL;
@@ -470,7 +478,7 @@ static void MLnS(ImmediateOffset)(ARMul_State* cpu, unsigned int inst, unsigned
 static void MLnS(RegisterOffset)(ARMul_State* cpu, unsigned int inst, unsigned int& virt_addr) {
    unsigned int addr;
    unsigned int Rn = BITS(inst, 16, 19);
-    unsigned int Rm = BITS(inst,  0,  3);
+    unsigned int Rm = BITS(inst, 0, 3);
    unsigned int rn = CHECK_READ_REG15_WA(cpu, Rn);
    unsigned int rm = CHECK_READ_REG15_WA(cpu, Rm);
@@ -482,10 +490,11 @@ static void MLnS(RegisterOffset)(ARMul_State* cpu, unsigned int inst, unsigned i
    virt_addr = addr;
 }
-static void MLnS(ImmediatePreIndexed)(ARMul_State* cpu, unsigned int inst, unsigned int& virt_addr) {
+static void MLnS(ImmediatePreIndexed)(ARMul_State* cpu, unsigned int inst,
-    unsigned int Rn     = BITS(inst, 16, 19);
+                                      unsigned int& virt_addr) {
-    unsigned int immedH = BITS(inst,  8, 11);
+    unsigned int Rn = BITS(inst, 16, 19);
-    unsigned int immedL = BITS(inst,  0,  3);
+    unsigned int immedH = BITS(inst, 8, 11);
+    unsigned int immedL = BITS(inst, 0, 3);
    unsigned int addr;
    unsigned int rn = CHECK_READ_REG15_WA(cpu, Rn);
    unsigned int offset_8 = (immedH << 4) | immedL;
@@ -501,10 +510,11 @@ static void MLnS(ImmediatePreIndexed)(ARMul_State* cpu, unsigned int inst, unsig
        cpu->Reg[Rn] = addr;
 }
-static void MLnS(ImmediatePostIndexed)(ARMul_State* cpu, unsigned int inst, unsigned int& virt_addr) {
+static void MLnS(ImmediatePostIndexed)(ARMul_State* cpu, unsigned int inst,
-    unsigned int Rn     = BITS(inst, 16, 19);
+                                       unsigned int& virt_addr) {
-    unsigned int immedH = BITS(inst,  8, 11);
+    unsigned int Rn = BITS(inst, 16, 19);
-    unsigned int immedL = BITS(inst,  0,  3);
+    unsigned int immedH = BITS(inst, 8, 11);
+    unsigned int immedL = BITS(inst, 0, 3);
    unsigned int rn = CHECK_READ_REG15_WA(cpu, Rn);
    virt_addr = rn;
@@ -520,9 +530,10 @@ static void MLnS(ImmediatePostIndexed)(ARMul_State* cpu, unsigned int inst, unsi
    }
 }
-static void MLnS(RegisterPostIndexed)(ARMul_State* cpu, unsigned int inst, unsigned int& virt_addr) {
+static void MLnS(RegisterPostIndexed)(ARMul_State* cpu, unsigned int inst,
+                                      unsigned int& virt_addr) {
    unsigned int Rn = BITS(inst, 16, 19);
-    unsigned int Rm = BITS(inst,  0,  3);
+    unsigned int Rm = BITS(inst, 0, 3);
    unsigned int rm = CHECK_READ_REG15_WA(cpu, Rm);
    virt_addr = CHECK_READ_REG15_WA(cpu, Rn);
@@ -541,7 +552,8 @@ static void LdnStM(DecrementBefore)(ARMul_State* cpu, unsigned int inst, unsigne
    int count = 0;
    while (i) {
-        if (i & 1) count++;
+        if (i & 1)
+            count++;
        i = i >> 1;
    }
@@ -557,7 +569,8 @@ static void LdnStM(IncrementBefore)(ARMul_State* cpu, unsigned int inst, unsigne
    int count = 0;
    while (i) {
-        if (i & 1) count++;
+        if (i & 1)
+            count++;
        i = i >> 1;
    }
@@ -572,8 +585,9 @@ static void LdnStM(IncrementAfter)(ARMul_State* cpu, unsigned int inst, unsigned
    unsigned int i = BITS(inst, 0, 15);
    int count = 0;
-    while(i) {
+    while (i) {
-        if (i & 1) count++;
+        if (i & 1)
+            count++;
        i = i >> 1;
    }
@@ -587,8 +601,9 @@ static void LdnStM(DecrementAfter)(ARMul_State* cpu, unsigned int inst, unsigned
    unsigned int Rn = BITS(inst, 16, 19);
    unsigned int i = BITS(inst, 0, 15);
    int count = 0;
-    while(i) {
+    while (i) {
-        if(i & 1) count++;
+        if (i & 1)
+            count++;
        i = i >> 1;
    }
    unsigned int rn = CHECK_READ_REG15_WA(cpu, Rn);
@@ -601,7 +616,8 @@ static void LdnStM(DecrementAfter)(ARMul_State* cpu, unsigned int inst, unsigned
    }
 }
-static void LnSWoUB(ScaledRegisterOffset)(ARMul_State* cpu, unsigned int inst, unsigned int& virt_addr) {
+static void LnSWoUB(ScaledRegisterOffset)(ARMul_State* cpu, unsigned int inst,
+                                          unsigned int& virt_addr) {
    unsigned int shift = BITS(inst, 5, 6);
    unsigned int shift_imm = BITS(inst, 7, 11);
    unsigned int Rn = BITS(inst, 16, 19);
@@ -693,17 +709,23 @@ get_addr_fp_t GetAddressingOp(unsigned int inst) {
        return LnSWoUB(RegisterPostIndexed);
    } else if (BITS(inst, 24, 27) == 6 && BIT(inst, 21) == 0 && BIT(inst, 4) == 0) {
        return LnSWoUB(ScaledRegisterPostIndexed);
-    } else if (BITS(inst, 24, 27) == 1 && BITS(inst, 21, 22) == 2 && BIT(inst, 7) == 1 && BIT(inst, 4) == 1) {
+    } else if (BITS(inst, 24, 27) == 1 && BITS(inst, 21, 22) == 2 && BIT(inst, 7) == 1 &&
+               BIT(inst, 4) == 1) {
        return MLnS(ImmediateOffset);
-    } else if (BITS(inst, 24, 27) == 1 && BITS(inst, 21, 22) == 0 && BIT(inst, 7) == 1 && BIT(inst, 4) == 1) {
+    } else if (BITS(inst, 24, 27) == 1 && BITS(inst, 21, 22) == 0 && BIT(inst, 7) == 1 &&
+               BIT(inst, 4) == 1) {
        return MLnS(RegisterOffset);
-    } else if (BITS(inst, 24, 27) == 1 && BITS(inst, 21, 22) == 3 && BIT(inst, 7) == 1 && BIT(inst, 4) == 1) {
+    } else if (BITS(inst, 24, 27) == 1 && BITS(inst, 21, 22) == 3 && BIT(inst, 7) == 1 &&
+               BIT(inst, 4) == 1) {
        return MLnS(ImmediatePreIndexed);
-    } else if (BITS(inst, 24, 27) == 1 && BITS(inst, 21, 22) == 1 && BIT(inst, 7) == 1 && BIT(inst, 4) == 1) {
+    } else if (BITS(inst, 24, 27) == 1 && BITS(inst, 21, 22) == 1 && BIT(inst, 7) == 1 &&
+               BIT(inst, 4) == 1) {
        return MLnS(RegisterPreIndexed);
-    } else if (BITS(inst, 24, 27) == 0 && BITS(inst, 21, 22) == 2 && BIT(inst, 7) == 1 && BIT(inst, 4) == 1) {
+    } else if (BITS(inst, 24, 27) == 0 && BITS(inst, 21, 22) == 2 && BIT(inst, 7) == 1 &&
+               BIT(inst, 4) == 1) {
        return MLnS(ImmediatePostIndexed);
-    } else if (BITS(inst, 24, 27) == 0 && BITS(inst, 21, 22) == 0 && BIT(inst, 7) == 1 && BIT(inst, 4) == 1) {
+    } else if (BITS(inst, 24, 27) == 0 && BITS(inst, 21, 22) == 0 && BIT(inst, 7) == 1 &&
+               BIT(inst, 4) == 1) {
        return MLnS(RegisterPostIndexed);
    } else if (BITS(inst, 23, 27) == 0x11) {
        return LdnStM(IncrementAfter);
@@ -732,14 +754,12 @@ get_addr_fp_t GetAddressingOpLoadStoreT(unsigned int inst) {
    return nullptr;
 }
-enum {
+enum { FETCH_SUCCESS, FETCH_FAILURE };
-    FETCH_SUCCESS,
-    FETCH_FAILURE
-};
-static ThumbDecodeStatus DecodeThumbInstruction(u32 inst, u32 addr, u32* arm_inst, u32* inst_size, ARM_INST_PTR* ptr_inst_base) {
+static ThumbDecodeStatus DecodeThumbInstruction(u32 inst, u32 addr, u32* arm_inst, u32* inst_size,
+                                                ARM_INST_PTR* ptr_inst_base) {
    // Check if in Thumb mode
-    ThumbDecodeStatus ret = TranslateThumbInstruction (addr, inst, arm_inst, inst_size);
+    ThumbDecodeStatus ret = TranslateThumbInstruction(addr, inst, arm_inst, inst_size);
    if (ret == ThumbDecodeStatus::BRANCH) {
        int inst_index;
        int table_length = arm_instruction_trans_len;
@@ -748,7 +768,7 @@ static ThumbDecodeStatus DecodeThumbInstruction(u32 inst, u32 addr, u32* arm_ins
        switch ((tinstr & 0xF800) >> 11) {
        case 26:
        case 27:
-            if (((tinstr & 0x0F00) != 0x0E00) && ((tinstr & 0x0F00) != 0x0F00)){
+            if (((tinstr & 0x0F00) != 0x0E00) && ((tinstr & 0x0F00) != 0x0F00)) {
                inst_index = table_length - 4;
                *ptr_inst_base = arm_instruction_trans[inst_index](tinstr, inst_index);
            } else {
@@ -785,21 +805,21 @@ static ThumbDecodeStatus DecodeThumbInstruction(u32 inst, u32 addr, u32* arm_ins
    return ret;
 }
-enum {
+enum { KEEP_GOING, FETCH_EXCEPTION };
-    KEEP_GOING,
-    FETCH_EXCEPTION
-};
 MICROPROFILE_DEFINE(DynCom_Decode, "DynCom", "Decode", MP_RGB(255, 64, 64));
-static unsigned int InterpreterTranslateInstruction(const ARMul_State* cpu, const u32 phys_addr, ARM_INST_PTR& inst_base) {
+static unsigned int InterpreterTranslateInstruction(const ARMul_State* cpu, const u32 phys_addr,
+                                                    ARM_INST_PTR& inst_base) {
    unsigned int inst_size = 4;
    unsigned int inst = Memory::Read32(phys_addr & 0xFFFFFFFC);
-    // If we are in Thumb mode, we'll translate one Thumb instruction to the corresponding ARM instruction
+    // If we are in Thumb mode, we'll translate one Thumb instruction to the corresponding ARM
+    // instruction
    if (cpu->TFlag) {
        u32 arm_inst;
-        ThumbDecodeStatus state = DecodeThumbInstruction(inst, phys_addr, &arm_inst, &inst_size, &inst_base);
+        ThumbDecodeStatus state =
+            DecodeThumbInstruction(inst, phys_addr, &arm_inst, &inst_size, &inst_base);
        // We have translated the Thumb branch instruction in the Thumb decoder
        if (state == ThumbDecodeStatus::BRANCH) {
@@ -811,8 +831,10 @@ static unsigned int InterpreterTranslateInstruction(const ARMul_State* cpu, cons
    int idx;
    if (DecodeARMInstruction(inst, &idx) == ARMDecodeStatus::FAILURE) {
        std::string disasm = ARM_Disasm::Disassemble(phys_addr, inst);
-        LOG_ERROR(Core_ARM11, "Decode failure.\tPC : [0x%x]\tInstruction : %s [%x]", phys_addr, disasm.c_str(), inst);
+        LOG_ERROR(Core_ARM11, "Decode failure.\tPC : [0x%x]\tInstruction : %s [%x]", phys_addr,
-        LOG_ERROR(Core_ARM11, "cpsr=0x%x, cpu->TFlag=%d, r15=0x%x", cpu->Cpsr, cpu->TFlag, cpu->Reg[15]);
+                  disasm.c_str(), inst);
+        LOG_ERROR(Core_ARM11, "cpsr=0x%x, cpu->TFlag=%d, r15=0x%x", cpu->Cpsr, cpu->TFlag,
+                  cpu->Reg[15]);
        CITRA_IGNORE_EXIT(-1);
    }
    inst_base = arm_instruction_trans[idx](inst, idx);
@@ -875,12 +897,25 @@ static int InterpreterTranslateSingle(ARMul_State* cpu, int& bb_start, u32 addr)
 static int clz(unsigned int x) {
    int n;
-    if (x == 0) return (32);
+    if (x == 0)
+        return (32);
    n = 1;
-    if ((x >> 16) == 0) { n = n + 16; x = x << 16;}
+    if ((x >> 16) == 0) {
-    if ((x >> 24) == 0) { n = n +  8; x = x <<  8;}
+        n = n + 16;
-    if ((x >> 28) == 0) { n = n +  4; x = x <<  4;}
+        x = x << 16;
-    if ((x >> 30) == 0) { n = n +  2; x = x <<  2;}
+    }
+    if ((x >> 24) == 0) {
+        n = n + 8;
+        x = x << 8;
+    }
+    if ((x >> 28) == 0) {
+        n = n + 4;
+        x = x << 4;
+    }
+    if ((x >> 30) == 0) {
+        n = n + 2;
+        x = x << 2;
+    }
    n = n - (x >> 31);
    return n;
 }
@@ -892,310 +927,698 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) {
    GDBStub::BreakpointAddress breakpoint_data;
-    #undef RM
+#undef RM
-    #undef RS
+#undef RS
-    #define CRn             inst_cream->crn
+#define CRn inst_cream->crn
-    #define OPCODE_1        inst_cream->opcode_1
+#define OPCODE_1 inst_cream->opcode_1
-    #define OPCODE_2        inst_cream->opcode_2
+#define OPCODE_2 inst_cream->opcode_2
-    #define CRm             inst_cream->crm
+#define CRm inst_cream->crm
-    #define RD              cpu->Reg[inst_cream->Rd]
+#define RD cpu->Reg[inst_cream->Rd]
-    #define RD2             cpu->Reg[inst_cream->Rd + 1]
+#define RD2 cpu->Reg[inst_cream->Rd + 1]
-    #define RN              cpu->Reg[inst_cream->Rn]
+#define RN cpu->Reg[inst_cream->Rn]
-    #define RM              cpu->Reg[inst_cream->Rm]
+#define RM cpu->Reg[inst_cream->Rm]
-    #define RS              cpu->Reg[inst_cream->Rs]
+#define RS cpu->Reg[inst_cream->Rs]
-    #define RDHI            cpu->Reg[inst_cream->RdHi]
+#define RDHI cpu->Reg[inst_cream->RdHi]
-    #define RDLO            cpu->Reg[inst_cream->RdLo]
+#define RDLO cpu->Reg[inst_cream->RdLo]
-    #define LINK_RTN_ADDR   (cpu->Reg[14] = cpu->Reg[15] + 4)
+#define LINK_RTN_ADDR (cpu->Reg[14] = cpu->Reg[15] + 4)
-    #define SET_PC          (cpu->Reg[15] = cpu->Reg[15] + 8 + inst_cream->signed_immed_24)
+#define SET_PC (cpu->Reg[15] = cpu->Reg[15] + 8 + inst_cream->signed_immed_24)
-    #define SHIFTER_OPERAND inst_cream->shtop_func(cpu, inst_cream->shifter_operand)
+#define SHIFTER_OPERAND inst_cream->shtop_func(cpu, inst_cream->shifter_operand)
-    #define FETCH_INST if (inst_base->br != TransExtData::NON_BRANCH) goto DISPATCH; \
+#define FETCH_INST                                                                                 \
-                       inst_base = (arm_inst *)&trans_cache_buf[ptr]
+    if (inst_base->br != TransExtData::NON_BRANCH)                                                 \
+        goto DISPATCH;                                                                             \
-    #define INC_PC(l)   ptr += sizeof(arm_inst) + l
+    inst_base = (arm_inst*)&trans_cache_buf[ptr]
-    #define INC_PC_STUB ptr += sizeof(arm_inst)
+#define INC_PC(l) ptr += sizeof(arm_inst) + l
-#define GDB_BP_CHECK \
+#define INC_PC_STUB ptr += sizeof(arm_inst)
-    cpu->Cpsr &= ~(1 << 5); \
-    cpu->Cpsr |= cpu->TFlag << 5; \
+#define GDB_BP_CHECK                                                                               \
-    if (GDBStub::g_server_enabled) { \
+    cpu->Cpsr &= ~(1 << 5);                                                                        \
-        if (GDBStub::IsMemoryBreak() || (breakpoint_data.type != GDBStub::BreakpointType::None && PC == breakpoint_data.address)) { \
+    cpu->Cpsr |= cpu->TFlag << 5;                                                                  \
-            GDBStub::Break(); \
+    if (GDBStub::g_server_enabled) {                                                               \
-            goto END; \
+        if (GDBStub::IsMemoryBreak() || (breakpoint_data.type != GDBStub::BreakpointType::None &&  \
-        } \
+                                         PC == breakpoint_data.address)) {                         \
+            GDBStub::Break();                                                                      \
+            goto END;                                                                              \
+        }                                                                                          \
    }
 // GCC and Clang have a C++ extension to support a lookup table of labels. Otherwise, fallback to a
 // clunky switch statement.
 #if defined __GNUC__ || defined __clang__
-#define GOTO_NEXT_INST \
+#define GOTO_NEXT_INST                                                                             \
-    GDB_BP_CHECK; \
+    GDB_BP_CHECK;                                                                                  \
-    if (num_instrs >= cpu->NumInstrsToExecute) goto END; \
+    if (num_instrs >= cpu->NumInstrsToExecute)                                                     \
-    num_instrs++; \
+        goto END;                                                                                  \
-    goto *InstLabel[inst_base->idx]
+    num_instrs++;                                                                                  \
+    goto* InstLabel[inst_base->idx]
 #else
-#define GOTO_NEXT_INST \
+#define GOTO_NEXT_INST                                                                             \
-    GDB_BP_CHECK; \
+    GDB_BP_CHECK;                                                                                  \
-    if (num_instrs >= cpu->NumInstrsToExecute) goto END; \
+    if (num_instrs >= cpu->NumInstrsToExecute)                                                     \
-    num_instrs++; \
+        goto END;                                                                                  \
-    switch(inst_base->idx) { \
+    num_instrs++;                                                                                  \
-    case 0: goto VMLA_INST; \
+    switch (inst_base->idx) {                                                                      \
-    case 1: goto VMLS_INST; \
+    case 0:                                                                                        \
-    case 2: goto VNMLA_INST; \
+        goto VMLA_INST;                                                                            \
-    case 3: goto VNMLS_INST; \
+    case 1:                                                                                        \
-    case 4: goto VNMUL_INST; \
+        goto VMLS_INST;                                                                            \
-    case 5: goto VMUL_INST; \
+    case 2:                                                                                        \
-    case 6: goto VADD_INST; \
+        goto VNMLA_INST;                                                                           \
-    case 7: goto VSUB_INST; \
+    case 3:                                                                                        \
-    case 8: goto VDIV_INST; \
+        goto VNMLS_INST;                                                                           \
-    case 9: goto VMOVI_INST; \
+    case 4:                                                                                        \
-    case 10: goto VMOVR_INST; \
+        goto VNMUL_INST;                                                                           \
-    case 11: goto VABS_INST; \
+    case 5:                                                                                        \
-    case 12: goto VNEG_INST; \
+        goto VMUL_INST;                                                                            \
-    case 13: goto VSQRT_INST; \
+    case 6:                                                                                        \
-    case 14: goto VCMP_INST; \
+        goto VADD_INST;                                                                            \
-    case 15: goto VCMP2_INST; \
+    case 7:                                                                                        \
-    case 16: goto VCVTBDS_INST; \
+        goto VSUB_INST;                                                                            \
-    case 17: goto VCVTBFF_INST; \
+    case 8:                                                                                        \
-    case 18: goto VCVTBFI_INST; \
+        goto VDIV_INST;                                                                            \
-    case 19: goto VMOVBRS_INST; \
+    case 9:                                                                                        \
-    case 20: goto VMSR_INST; \
+        goto VMOVI_INST;                                                                           \
-    case 21: goto VMOVBRC_INST; \
+    case 10:                                                                                       \
-    case 22: goto VMRS_INST; \
+        goto VMOVR_INST;                                                                           \
-    case 23: goto VMOVBCR_INST; \
+    case 11:                                                                                       \
-    case 24: goto VMOVBRRSS_INST; \
+        goto VABS_INST;                                                                            \
-    case 25: goto VMOVBRRD_INST; \
+    case 12:                                                                                       \
-    case 26: goto VSTR_INST; \
+        goto VNEG_INST;                                                                            \
-    case 27: goto VPUSH_INST; \
+    case 13:                                                                                       \
-    case 28: goto VSTM_INST; \
+        goto VSQRT_INST;                                                                           \
-    case 29: goto VPOP_INST; \
+    case 14:                                                                                       \
-    case 30: goto VLDR_INST; \
+        goto VCMP_INST;                                                                            \
-    case 31: goto VLDM_INST ; \
+    case 15:                                                                                       \
-    case 32: goto SRS_INST; \
+        goto VCMP2_INST;                                                                           \
-    case 33: goto RFE_INST; \
+    case 16:                                                                                       \
-    case 34: goto BKPT_INST; \
+        goto VCVTBDS_INST;                                                                         \
-    case 35: goto BLX_INST; \
+    case 17:                                                                                       \
-    case 36: goto CPS_INST; \
+        goto VCVTBFF_INST;                                                                         \
-    case 37: goto PLD_INST; \
+    case 18:                                                                                       \
-    case 38: goto SETEND_INST; \
+        goto VCVTBFI_INST;                                                                         \
-    case 39: goto CLREX_INST; \
+    case 19:                                                                                       \
-    case 40: goto REV16_INST; \
+        goto VMOVBRS_INST;                                                                         \
-    case 41: goto USAD8_INST; \
+    case 20:                                                                                       \
-    case 42: goto SXTB_INST; \
+        goto VMSR_INST;                                                                            \
-    case 43: goto UXTB_INST; \
+    case 21:                                                                                       \
-    case 44: goto SXTH_INST; \
+        goto VMOVBRC_INST;                                                                         \
-    case 45: goto SXTB16_INST; \
+    case 22:                                                                                       \
-    case 46: goto UXTH_INST; \
+        goto VMRS_INST;                                                                            \
-    case 47: goto UXTB16_INST; \
+    case 23:                                                                                       \
-    case 48: goto CPY_INST; \
+        goto VMOVBCR_INST;                                                                         \
-    case 49: goto UXTAB_INST; \
+    case 24:                                                                                       \
-    case 50: goto SSUB8_INST; \
+        goto VMOVBRRSS_INST;                                                                       \
-    case 51: goto SHSUB8_INST; \
+    case 25:                                                                                       \
-    case 52: goto SSUBADDX_INST; \
+        goto VMOVBRRD_INST;                                                                        \
-    case 53: goto STREX_INST; \
+    case 26:                                                                                       \
-    case 54: goto STREXB_INST; \
+        goto VSTR_INST;                                                                            \
-    case 55: goto SWP_INST; \
+    case 27:                                                                                       \
-    case 56: goto SWPB_INST; \
+        goto VPUSH_INST;                                                                           \
-    case 57: goto SSUB16_INST; \
+    case 28:                                                                                       \
-    case 58: goto SSAT16_INST; \
+        goto VSTM_INST;                                                                            \
-    case 59: goto SHSUBADDX_INST; \
+    case 29:                                                                                       \
-    case 60: goto QSUBADDX_INST; \
+        goto VPOP_INST;                                                                            \
-    case 61: goto SHADDSUBX_INST; \
+    case 30:                                                                                       \
-    case 62: goto SHADD8_INST; \
+        goto VLDR_INST;                                                                            \
-    case 63: goto SHADD16_INST; \
+    case 31:                                                                                       \
-    case 64: goto SEL_INST; \
+        goto VLDM_INST;                                                                            \
-    case 65: goto SADDSUBX_INST; \
+    case 32:                                                                                       \
-    case 66: goto SADD8_INST; \
+        goto SRS_INST;                                                                             \
-    case 67: goto SADD16_INST; \
+    case 33:                                                                                       \
-    case 68: goto SHSUB16_INST; \
+        goto RFE_INST;                                                                             \
-    case 69: goto UMAAL_INST; \
+    case 34:                                                                                       \
-    case 70: goto UXTAB16_INST; \
+        goto BKPT_INST;                                                                            \
-    case 71: goto USUBADDX_INST; \
+    case 35:                                                                                       \
-    case 72: goto USUB8_INST; \
+        goto BLX_INST;                                                                             \
-    case 73: goto USUB16_INST; \
+    case 36:                                                                                       \
-    case 74: goto USAT16_INST; \
+        goto CPS_INST;                                                                             \
-    case 75: goto USADA8_INST; \
+    case 37:                                                                                       \
-    case 76: goto UQSUBADDX_INST; \
+        goto PLD_INST;                                                                             \
-    case 77: goto UQSUB8_INST; \
+    case 38:                                                                                       \
-    case 78: goto UQSUB16_INST; \
+        goto SETEND_INST;                                                                          \
-    case 79: goto UQADDSUBX_INST; \
+    case 39:                                                                                       \
-    case 80: goto UQADD8_INST; \
+        goto CLREX_INST;                                                                           \
-    case 81: goto UQADD16_INST; \
+    case 40:                                                                                       \
-    case 82: goto SXTAB_INST; \
+        goto REV16_INST;                                                                           \
-    case 83: goto UHSUBADDX_INST; \
+    case 41:                                                                                       \
-    case 84: goto UHSUB8_INST; \
+        goto USAD8_INST;                                                                           \
-    case 85: goto UHSUB16_INST; \
+    case 42:                                                                                       \
-    case 86: goto UHADDSUBX_INST; \
+        goto SXTB_INST;                                                                            \
-    case 87: goto UHADD8_INST; \
+    case 43:                                                                                       \
-    case 88: goto UHADD16_INST; \
+        goto UXTB_INST;                                                                            \
-    case 89: goto UADDSUBX_INST; \
+    case 44:                                                                                       \
-    case 90: goto UADD8_INST; \
+        goto SXTH_INST;                                                                            \
-    case 91: goto UADD16_INST; \
+    case 45:                                                                                       \
-    case 92: goto SXTAH_INST; \
+        goto SXTB16_INST;                                                                          \
-    case 93: goto SXTAB16_INST; \
+    case 46:                                                                                       \
-    case 94: goto QADD8_INST; \
+        goto UXTH_INST;                                                                            \
-    case 95: goto BXJ_INST; \
+    case 47:                                                                                       \
-    case 96: goto CLZ_INST; \
+        goto UXTB16_INST;                                                                          \
-    case 97: goto UXTAH_INST; \
+    case 48:                                                                                       \
-    case 98: goto BX_INST; \
+        goto CPY_INST;                                                                             \
-    case 99: goto REV_INST; \
+    case 49:                                                                                       \
-    case 100: goto BLX_INST; \
+        goto UXTAB_INST;                                                                           \
-    case 101: goto REVSH_INST; \
+    case 50:                                                                                       \
-    case 102: goto QADD_INST; \
+        goto SSUB8_INST;                                                                           \
-    case 103: goto QADD16_INST; \
+    case 51:                                                                                       \
-    case 104: goto QADDSUBX_INST; \
+        goto SHSUB8_INST;                                                                          \
-    case 105: goto LDREX_INST; \
+    case 52:                                                                                       \
-    case 106: goto QDADD_INST; \
+        goto SSUBADDX_INST;                                                                        \
-    case 107: goto QDSUB_INST; \
+    case 53:                                                                                       \
-    case 108: goto QSUB_INST; \
+        goto STREX_INST;                                                                           \
-    case 109: goto LDREXB_INST; \
+    case 54:                                                                                       \
-    case 110: goto QSUB8_INST; \
+        goto STREXB_INST;                                                                          \
-    case 111: goto QSUB16_INST; \
+    case 55:                                                                                       \
-    case 112: goto SMUAD_INST; \
+        goto SWP_INST;                                                                             \
-    case 113: goto SMMUL_INST; \
+    case 56:                                                                                       \
-    case 114: goto SMUSD_INST; \
+        goto SWPB_INST;                                                                            \
-    case 115: goto SMLSD_INST; \
+    case 57:                                                                                       \
-    case 116: goto SMLSLD_INST; \
+        goto SSUB16_INST;                                                                          \
-    case 117: goto SMMLA_INST; \
+    case 58:                                                                                       \
-    case 118: goto SMMLS_INST; \
+        goto SSAT16_INST;                                                                          \
-    case 119: goto SMLALD_INST; \
+    case 59:                                                                                       \
-    case 120: goto SMLAD_INST; \
+        goto SHSUBADDX_INST;                                                                       \
-    case 121: goto SMLAW_INST; \
+    case 60:                                                                                       \
-    case 122: goto SMULW_INST; \
+        goto QSUBADDX_INST;                                                                        \
-    case 123: goto PKHTB_INST; \
+    case 61:                                                                                       \
-    case 124: goto PKHBT_INST; \
+        goto SHADDSUBX_INST;                                                                       \
-    case 125: goto SMUL_INST; \
+    case 62:                                                                                       \
-    case 126: goto SMLALXY_INST; \
+        goto SHADD8_INST;                                                                          \
-    case 127: goto SMLA_INST; \
+    case 63:                                                                                       \
-    case 128: goto MCRR_INST; \
+        goto SHADD16_INST;                                                                         \
-    case 129: goto MRRC_INST; \
+    case 64:                                                                                       \
-    case 130: goto CMP_INST; \
+        goto SEL_INST;                                                                             \
-    case 131: goto TST_INST; \
+    case 65:                                                                                       \
-    case 132: goto TEQ_INST; \
+        goto SADDSUBX_INST;                                                                        \
-    case 133: goto CMN_INST; \
+    case 66:                                                                                       \
-    case 134: goto SMULL_INST; \
+        goto SADD8_INST;                                                                           \
-    case 135: goto UMULL_INST; \
+    case 67:                                                                                       \
-    case 136: goto UMLAL_INST; \
+        goto SADD16_INST;                                                                          \
-    case 137: goto SMLAL_INST; \
+    case 68:                                                                                       \
-    case 138: goto MUL_INST; \
+        goto SHSUB16_INST;                                                                         \
-    case 139: goto MLA_INST; \
+    case 69:                                                                                       \
-    case 140: goto SSAT_INST; \
+        goto UMAAL_INST;                                                                           \
-    case 141: goto USAT_INST; \
+    case 70:                                                                                       \
-    case 142: goto MRS_INST; \
+        goto UXTAB16_INST;                                                                         \
-    case 143: goto MSR_INST; \
+    case 71:                                                                                       \
-    case 144: goto AND_INST; \
+        goto USUBADDX_INST;                                                                        \
-    case 145: goto BIC_INST; \
+    case 72:                                                                                       \
-    case 146: goto LDM_INST; \
+        goto USUB8_INST;                                                                           \
-    case 147: goto EOR_INST; \
+    case 73:                                                                                       \
-    case 148: goto ADD_INST; \
+        goto USUB16_INST;                                                                          \
-    case 149: goto RSB_INST; \
+    case 74:                                                                                       \
-    case 150: goto RSC_INST; \
+        goto USAT16_INST;                                                                          \
-    case 151: goto SBC_INST; \
+    case 75:                                                                                       \
-    case 152: goto ADC_INST; \
+        goto USADA8_INST;                                                                          \
-    case 153: goto SUB_INST; \
+    case 76:                                                                                       \
-    case 154: goto ORR_INST; \
+        goto UQSUBADDX_INST;                                                                       \
-    case 155: goto MVN_INST; \
+    case 77:                                                                                       \
-    case 156: goto MOV_INST; \
+        goto UQSUB8_INST;                                                                          \
-    case 157: goto STM_INST; \
+    case 78:                                                                                       \
-    case 158: goto LDM_INST; \
+        goto UQSUB16_INST;                                                                         \
-    case 159: goto LDRSH_INST; \
+    case 79:                                                                                       \
-    case 160: goto STM_INST; \
+        goto UQADDSUBX_INST;                                                                       \
-    case 161: goto LDM_INST; \
+    case 80:                                                                                       \
-    case 162: goto LDRSB_INST; \
+        goto UQADD8_INST;                                                                          \
-    case 163: goto STRD_INST; \
+    case 81:                                                                                       \
-    case 164: goto LDRH_INST; \
+        goto UQADD16_INST;                                                                         \
-    case 165: goto STRH_INST; \
+    case 82:                                                                                       \
-    case 166: goto LDRD_INST; \
+        goto SXTAB_INST;                                                                           \
-    case 167: goto STRT_INST; \
+    case 83:                                                                                       \
-    case 168: goto STRBT_INST; \
+        goto UHSUBADDX_INST;                                                                       \
-    case 169: goto LDRBT_INST; \
+    case 84:                                                                                       \
-    case 170: goto LDRT_INST; \
+        goto UHSUB8_INST;                                                                          \
-    case 171: goto MRC_INST; \
+    case 85:                                                                                       \
-    case 172: goto MCR_INST; \
+        goto UHSUB16_INST;                                                                         \
-    case 173: goto MSR_INST; \
+    case 86:                                                                                       \
-    case 174: goto MSR_INST; \
+        goto UHADDSUBX_INST;                                                                       \
-    case 175: goto MSR_INST; \
+    case 87:                                                                                       \
-    case 176: goto MSR_INST; \
+        goto UHADD8_INST;                                                                          \
-    case 177: goto MSR_INST; \
+    case 88:                                                                                       \
-    case 178: goto LDRB_INST; \
+        goto UHADD16_INST;                                                                         \
-    case 179: goto STRB_INST; \
+    case 89:                                                                                       \
-    case 180: goto LDR_INST; \
+        goto UADDSUBX_INST;                                                                        \
-    case 181: goto LDRCOND_INST ; \
+    case 90:                                                                                       \
-    case 182: goto STR_INST; \
+        goto UADD8_INST;                                                                           \
-    case 183: goto CDP_INST; \
+    case 91:                                                                                       \
-    case 184: goto STC_INST; \
+        goto UADD16_INST;                                                                          \
-    case 185: goto LDC_INST; \
+    case 92:                                                                                       \
-    case 186: goto LDREXD_INST; \
+        goto SXTAH_INST;                                                                           \
-    case 187: goto STREXD_INST; \
+    case 93:                                                                                       \
-    case 188: goto LDREXH_INST; \
+        goto SXTAB16_INST;                                                                         \
-    case 189: goto STREXH_INST; \
+    case 94:                                                                                       \
-    case 190: goto NOP_INST; \
+        goto QADD8_INST;                                                                           \
-    case 191: goto YIELD_INST; \
+    case 95:                                                                                       \
-    case 192: goto WFE_INST; \
+        goto BXJ_INST;                                                                             \
-    case 193: goto WFI_INST; \
+    case 96:                                                                                       \
-    case 194: goto SEV_INST; \
+        goto CLZ_INST;                                                                             \
-    case 195: goto SWI_INST; \
+    case 97:                                                                                       \
-    case 196: goto BBL_INST; \
+        goto UXTAH_INST;                                                                           \
-    case 197: goto B_2_THUMB ; \
+    case 98:                                                                                       \
-    case 198: goto B_COND_THUMB ; \
+        goto BX_INST;                                                                              \
-    case 199: goto BL_1_THUMB ; \
+    case 99:                                                                                       \
-    case 200: goto BL_2_THUMB ; \
+        goto REV_INST;                                                                             \
-    case 201: goto BLX_1_THUMB ; \
+    case 100:                                                                                      \
-    case 202: goto DISPATCH; \
+        goto BLX_INST;                                                                             \
-    case 203: goto INIT_INST_LENGTH; \
+    case 101:                                                                                      \
-    case 204: goto END; \
+        goto REVSH_INST;                                                                           \
+    case 102:                                                                                      \
+        goto QADD_INST;                                                                            \
+    case 103:                                                                                      \
+        goto QADD16_INST;                                                                          \
+    case 104:                                                                                      \
+        goto QADDSUBX_INST;                                                                        \
+    case 105:                                                                                      \
+        goto LDREX_INST;                                                                           \
+    case 106:                                                                                      \
+        goto QDADD_INST;                                                                           \
+    case 107:                                                                                      \
+        goto QDSUB_INST;                                                                           \
+    case 108:                                                                                      \
+        goto QSUB_INST;                                                                            \
+    case 109:                                                                                      \
+        goto LDREXB_INST;                                                                          \
+    case 110:                                                                                      \
+        goto QSUB8_INST;                                                                           \
+    case 111:                                                                                      \
+        goto QSUB16_INST;                                                                          \
+    case 112:                                                                                      \
+        goto SMUAD_INST;                                                                           \
+    case 113:                                                                                      \
+        goto SMMUL_INST;                                                                           \
+    case 114:                                                                                      \
+        goto SMUSD_INST;                                                                           \
+    case 115:                                                                                      \
+        goto SMLSD_INST;                                                                           \
+    case 116:                                                                                      \
+        goto SMLSLD_INST;                                                                          \
+    case 117:                                                                                      \
+        goto SMMLA_INST;                                                                           \
+    case 118:                                                                                      \
+        goto SMMLS_INST;                                                                           \
+    case 119:                                                                                      \
+        goto SMLALD_INST;                                                                          \
+    case 120:                                                                                      \
+        goto SMLAD_INST;                                                                           \
+    case 121:                                                                                      \
+        goto SMLAW_INST;                                                                           \
+    case 122:                                                                                      \
+        goto SMULW_INST;                                                                           \
+    case 123:                                                                                      \
+        goto PKHTB_INST;                                                                           \
+    case 124:                                                                                      \
+        goto PKHBT_INST;                                                                           \
+    case 125:                                                                                      \
+        goto SMUL_INST;                                                                            \
+    case 126:                                                                                      \
+        goto SMLALXY_INST;                                                                         \
+    case 127:                                                                                      \
+        goto SMLA_INST;                                                                            \
+    case 128:                                                                                      \
+        goto MCRR_INST;                                                                            \
+    case 129:                                                                                      \
+        goto MRRC_INST;                                                                            \
+    case 130:                                                                                      \
+        goto CMP_INST;                                                                             \
+    case 131:                                                                                      \
+        goto TST_INST;                                                                             \
+    case 132:                                                                                      \
+        goto TEQ_INST;                                                                             \
+    case 133:                                                                                      \
+        goto CMN_INST;                                                                             \
+    case 134:                                                                                      \
+        goto SMULL_INST;                                                                           \
+    case 135:                                                                                      \
+        goto UMULL_INST;                                                                           \
+    case 136:                                                                                      \
+        goto UMLAL_INST;                                                                           \
+    case 137:                                                                                      \
+        goto SMLAL_INST;                                                                           \
+    case 138:                                                                                      \
+        goto MUL_INST;                                                                             \
+    case 139:                                                                                      \
+        goto MLA_INST;                                                                             \
+    case 140:                                                                                      \
+        goto SSAT_INST;                                                                            \
+    case 141:                                                                                      \
+        goto USAT_INST;                                                                            \
+    case 142:                                                                                      \
+        goto MRS_INST;                                                                             \
+    case 143:                                                                                      \
+        goto MSR_INST;                                                                             \
+    case 144:                                                                                      \
+        goto AND_INST;                                                                             \
+    case 145:                                                                                      \
+        goto BIC_INST;                                                                             \
+    case 146:                                                                                      \
+        goto LDM_INST;                                                                             \
+    case 147:                                                                                      \
+        goto EOR_INST;                                                                             \
+    case 148:                                                                                      \
+        goto ADD_INST;                                                                             \
+    case 149:                                                                                      \
+        goto RSB_INST;                                                                             \
+    case 150:                                                                                      \
+        goto RSC_INST;                                                                             \
+    case 151:                                                                                      \
+        goto SBC_INST;                                                                             \
+    case 152:                                                                                      \
+        goto ADC_INST;                                                                             \
+    case 153:                                                                                      \
+        goto SUB_INST;                                                                             \
+    case 154:                                                                                      \
+        goto ORR_INST;                                                                             \
+    case 155:                                                                                      \
+        goto MVN_INST;                                                                             \
+    case 156:                                                                                      \
+        goto MOV_INST;                                                                             \
+    case 157:                                                                                      \
+        goto STM_INST;                                                                             \
+    case 158:                                                                                      \
+        goto LDM_INST;                                                                             \
+    case 159:                                                                                      \
+        goto LDRSH_INST;                                                                           \
+    case 160:                                                                                      \
+        goto STM_INST;                                                                             \
+    case 161:                                                                                      \
+        goto LDM_INST;                                                                             \
+    case 162:                                                                                      \
+        goto LDRSB_INST;                                                                           \
+    case 163:                                                                                      \
+        goto STRD_INST;                                                                            \
+    case 164:                                                                                      \
+        goto LDRH_INST;                                                                            \
+    case 165:                                                                                      \
+        goto STRH_INST;                                                                            \
+    case 166:                                                                                      \
+        goto LDRD_INST;                                                                            \
+    case 167:                                                                                      \
+        goto STRT_INST;                                                                            \
+    case 168:                                                                                      \
+        goto STRBT_INST;                                                                           \
+    case 169:                                                                                      \
+        goto LDRBT_INST;                                                                           \
+    case 170:                                                                                      \
+        goto LDRT_INST;                                                                            \
+    case 171:                                                                                      \
+        goto MRC_INST;                                                                             \
+    case 172:                                                                                      \
+        goto MCR_INST;                                                                             \
+    case 173:                                                                                      \
+        goto MSR_INST;                                                                             \
+    case 174:                                                                                      \
+        goto MSR_INST;                                                                             \
+    case 175:                                                                                      \
+        goto MSR_INST;                                                                             \
+    case 176:                                                                                      \
+        goto MSR_INST;                                                                             \
+    case 177:                                                                                      \
+        goto MSR_INST;                                                                             \
+    case 178:                                                                                      \
+        goto LDRB_INST;                                                                            \
+    case 179:                                                                                      \
+        goto STRB_INST;                                                                            \
+    case 180:                                                                                      \
+        goto LDR_INST;                                                                             \
+    case 181:                                                                                      \
+        goto LDRCOND_INST;                                                                         \
+    case 182:                                                                                      \
+        goto STR_INST;                                                                             \
+    case 183:                                                                                      \
+        goto CDP_INST;                                                                             \
+    case 184:                                                                                      \
+        goto STC_INST;                                                                             \
+    case 185:                                                                                      \
+        goto LDC_INST;                                                                             \
+    case 186:                                                                                      \
+        goto LDREXD_INST;                                                                          \
+    case 187:                                                                                      \
+        goto STREXD_INST;                                                                          \
+    case 188:                                                                                      \
+        goto LDREXH_INST;                                                                          \
+    case 189:                                                                                      \
+        goto STREXH_INST;                                                                          \
+    case 190:                                                                                      \
+        goto NOP_INST;                                                                             \
+    case 191:                                                                                      \
+        goto YIELD_INST;                                                                           \
+    case 192:                                                                                      \
+        goto WFE_INST;                                                                             \
+    case 193:                                                                                      \
+        goto WFI_INST;                                                                             \
+    case 194:                                                                                      \
+        goto SEV_INST;                                                                             \
+    case 195:                                                                                      \
+        goto SWI_INST;                                                                             \
+    case 196:                                                                                      \
+        goto BBL_INST;                                                                             \
+    case 197:                                                                                      \
+        goto B_2_THUMB;                                                                            \
+    case 198:                                                                                      \
+        goto B_COND_THUMB;                                                                         \
+    case 199:                                                                                      \
+        goto BL_1_THUMB;                                                                           \
+    case 200:                                                                                      \
+        goto BL_2_THUMB;                                                                           \
+    case 201:                                                                                      \
+        goto BLX_1_THUMB;                                                                          \
+    case 202:                                                                                      \
+        goto DISPATCH;                                                                             \
+    case 203:                                                                                      \
+        goto INIT_INST_LENGTH;                                                                     \
+    case 204:                                                                                      \
+        goto END;                                                                                  \
    }
 #endif
-    #define UPDATE_NFLAG(dst)    (cpu->NFlag = BIT(dst, 31) ? 1 : 0)
+#define UPDATE_NFLAG(dst) (cpu->NFlag = BIT(dst, 31) ? 1 : 0)
-    #define UPDATE_ZFLAG(dst)    (cpu->ZFlag = dst ? 0 : 1)
+#define UPDATE_ZFLAG(dst) (cpu->ZFlag = dst ? 0 : 1)
-    #define UPDATE_CFLAG_WITH_SC (cpu->CFlag = cpu->shifter_carry_out)
+#define UPDATE_CFLAG_WITH_SC (cpu->CFlag = cpu->shifter_carry_out)
-    #define SAVE_NZCVT cpu->Cpsr = (cpu->Cpsr & 0x0fffffdf) | \
+#define SAVE_NZCVT                                                                                 \
-                      (cpu->NFlag << 31) | \
+    cpu->Cpsr = (cpu->Cpsr & 0x0fffffdf) | (cpu->NFlag << 31) | (cpu->ZFlag << 30) |               \
-                      (cpu->ZFlag << 30) | \
+                (cpu->CFlag << 29) | (cpu->VFlag << 28) | (cpu->TFlag << 5)
-                      (cpu->CFlag << 29) | \
+#define LOAD_NZCVT                                                                                 \
-                      (cpu->VFlag << 28) | \
+    cpu->NFlag = (cpu->Cpsr >> 31);                                                                \
-                      (cpu->TFlag << 5)
+    cpu->ZFlag = (cpu->Cpsr >> 30) & 1;                                                            \
-    #define LOAD_NZCVT cpu->NFlag = (cpu->Cpsr >> 31);     \
+    cpu->CFlag = (cpu->Cpsr >> 29) & 1;                                                            \
-                       cpu->ZFlag = (cpu->Cpsr >> 30) & 1; \
+    cpu->VFlag = (cpu->Cpsr >> 28) & 1;                                                            \
-                       cpu->CFlag = (cpu->Cpsr >> 29) & 1; \
+    cpu->TFlag = (cpu->Cpsr >> 5) & 1;
-                       cpu->VFlag = (cpu->Cpsr >> 28) & 1; \
-                       cpu->TFlag = (cpu->Cpsr >> 5) & 1;
+#define CurrentModeHasSPSR (cpu->Mode != SYSTEM32MODE) && (cpu->Mode != USER32MODE)
+#define PC (cpu->Reg[15])
-    #define CurrentModeHasSPSR (cpu->Mode != SYSTEM32MODE) && (cpu->Mode != USER32MODE)
-    #define PC (cpu->Reg[15])
+// GCC and Clang have a C++ extension to support a lookup table of labels. Otherwise, fallback
+// to a clunky switch statement.
-    // GCC and Clang have a C++ extension to support a lookup table of labels. Otherwise, fallback
-    // to a clunky switch statement.
 #if defined __GNUC__ || defined __clang__
-    void *InstLabel[] = {
+    void* InstLabel[] = {&&VMLA_INST,
-        &&VMLA_INST, &&VMLS_INST, &&VNMLA_INST, &&VNMLS_INST, &&VNMUL_INST, &&VMUL_INST, &&VADD_INST, &&VSUB_INST,
+                         &&VMLS_INST,
-        &&VDIV_INST, &&VMOVI_INST, &&VMOVR_INST, &&VABS_INST, &&VNEG_INST, &&VSQRT_INST, &&VCMP_INST, &&VCMP2_INST, &&VCVTBDS_INST,
+                         &&VNMLA_INST,
-        &&VCVTBFF_INST, &&VCVTBFI_INST, &&VMOVBRS_INST, &&VMSR_INST, &&VMOVBRC_INST, &&VMRS_INST, &&VMOVBCR_INST, &&VMOVBRRSS_INST,
+                         &&VNMLS_INST,
-        &&VMOVBRRD_INST, &&VSTR_INST, &&VPUSH_INST, &&VSTM_INST, &&VPOP_INST, &&VLDR_INST, &&VLDM_INST,
+                         &&VNMUL_INST,
+                         &&VMUL_INST,
-        &&SRS_INST,&&RFE_INST,&&BKPT_INST,&&BLX_INST,&&CPS_INST,&&PLD_INST,&&SETEND_INST,&&CLREX_INST,&&REV16_INST,&&USAD8_INST,&&SXTB_INST,
+                         &&VADD_INST,
-        &&UXTB_INST,&&SXTH_INST,&&SXTB16_INST,&&UXTH_INST,&&UXTB16_INST,&&CPY_INST,&&UXTAB_INST,&&SSUB8_INST,&&SHSUB8_INST,&&SSUBADDX_INST,
+                         &&VSUB_INST,
-        &&STREX_INST,&&STREXB_INST,&&SWP_INST,&&SWPB_INST,&&SSUB16_INST,&&SSAT16_INST,&&SHSUBADDX_INST,&&QSUBADDX_INST,&&SHADDSUBX_INST,
+                         &&VDIV_INST,
-        &&SHADD8_INST,&&SHADD16_INST,&&SEL_INST,&&SADDSUBX_INST,&&SADD8_INST,&&SADD16_INST,&&SHSUB16_INST,&&UMAAL_INST,&&UXTAB16_INST,
+                         &&VMOVI_INST,
-        &&USUBADDX_INST,&&USUB8_INST,&&USUB16_INST,&&USAT16_INST,&&USADA8_INST,&&UQSUBADDX_INST,&&UQSUB8_INST,&&UQSUB16_INST,
+                         &&VMOVR_INST,
-        &&UQADDSUBX_INST,&&UQADD8_INST,&&UQADD16_INST,&&SXTAB_INST,&&UHSUBADDX_INST,&&UHSUB8_INST,&&UHSUB16_INST,&&UHADDSUBX_INST,&&UHADD8_INST,
+                         &&VABS_INST,
-        &&UHADD16_INST,&&UADDSUBX_INST,&&UADD8_INST,&&UADD16_INST,&&SXTAH_INST,&&SXTAB16_INST,&&QADD8_INST,&&BXJ_INST,&&CLZ_INST,&&UXTAH_INST,
+                         &&VNEG_INST,
-        &&BX_INST,&&REV_INST,&&BLX_INST,&&REVSH_INST,&&QADD_INST,&&QADD16_INST,&&QADDSUBX_INST,&&LDREX_INST,&&QDADD_INST,&&QDSUB_INST,
+                         &&VSQRT_INST,
-        &&QSUB_INST,&&LDREXB_INST,&&QSUB8_INST,&&QSUB16_INST,&&SMUAD_INST,&&SMMUL_INST,&&SMUSD_INST,&&SMLSD_INST,&&SMLSLD_INST,&&SMMLA_INST,
+                         &&VCMP_INST,
-        &&SMMLS_INST,&&SMLALD_INST,&&SMLAD_INST,&&SMLAW_INST,&&SMULW_INST,&&PKHTB_INST,&&PKHBT_INST,&&SMUL_INST,&&SMLALXY_INST,&&SMLA_INST,
+                         &&VCMP2_INST,
-        &&MCRR_INST,&&MRRC_INST,&&CMP_INST,&&TST_INST,&&TEQ_INST,&&CMN_INST,&&SMULL_INST,&&UMULL_INST,&&UMLAL_INST,&&SMLAL_INST,&&MUL_INST,
+                         &&VCVTBDS_INST,
-        &&MLA_INST,&&SSAT_INST,&&USAT_INST,&&MRS_INST,&&MSR_INST,&&AND_INST,&&BIC_INST,&&LDM_INST,&&EOR_INST,&&ADD_INST,&&RSB_INST,&&RSC_INST,
+                         &&VCVTBFF_INST,
-        &&SBC_INST,&&ADC_INST,&&SUB_INST,&&ORR_INST,&&MVN_INST,&&MOV_INST,&&STM_INST,&&LDM_INST,&&LDRSH_INST,&&STM_INST,&&LDM_INST,&&LDRSB_INST,
+                         &&VCVTBFI_INST,
-        &&STRD_INST,&&LDRH_INST,&&STRH_INST,&&LDRD_INST,&&STRT_INST,&&STRBT_INST,&&LDRBT_INST,&&LDRT_INST,&&MRC_INST,&&MCR_INST,
+                         &&VMOVBRS_INST,
-        &&MSR_INST, &&MSR_INST, &&MSR_INST, &&MSR_INST, &&MSR_INST,
+                         &&VMSR_INST,
-        &&LDRB_INST,&&STRB_INST,&&LDR_INST,&&LDRCOND_INST, &&STR_INST,&&CDP_INST,&&STC_INST,&&LDC_INST, &&LDREXD_INST,
+                         &&VMOVBRC_INST,
-        &&STREXD_INST,&&LDREXH_INST,&&STREXH_INST, &&NOP_INST, &&YIELD_INST, &&WFE_INST, &&WFI_INST, &&SEV_INST, &&SWI_INST,&&BBL_INST,
+                         &&VMRS_INST,
-        &&B_2_THUMB, &&B_COND_THUMB,&&BL_1_THUMB, &&BL_2_THUMB, &&BLX_1_THUMB, &&DISPATCH,
+                         &&VMOVBCR_INST,
-        &&INIT_INST_LENGTH,&&END
+                         &&VMOVBRRSS_INST,
-        };
+                         &&VMOVBRRD_INST,
+                         &&VSTR_INST,
+                         &&VPUSH_INST,
+                         &&VSTM_INST,
+                         &&VPOP_INST,
+                         &&VLDR_INST,
+                         &&VLDM_INST,
+                         &&SRS_INST,
+                         &&RFE_INST,
+                         &&BKPT_INST,
+                         &&BLX_INST,
+                         &&CPS_INST,
+                         &&PLD_INST,
+                         &&SETEND_INST,
+                         &&CLREX_INST,
+                         &&REV16_INST,
+                         &&USAD8_INST,
+                         &&SXTB_INST,
+                         &&UXTB_INST,
+                         &&SXTH_INST,
+                         &&SXTB16_INST,
+                         &&UXTH_INST,
+                         &&UXTB16_INST,
+                         &&CPY_INST,
+                         &&UXTAB_INST,
+                         &&SSUB8_INST,
+                         &&SHSUB8_INST,
+                         &&SSUBADDX_INST,
+                         &&STREX_INST,
+                         &&STREXB_INST,
+                         &&SWP_INST,
+                         &&SWPB_INST,
+                         &&SSUB16_INST,
+                         &&SSAT16_INST,
+                         &&SHSUBADDX_INST,
+                         &&QSUBADDX_INST,
+                         &&SHADDSUBX_INST,
+                         &&SHADD8_INST,
+                         &&SHADD16_INST,
+                         &&SEL_INST,
+                         &&SADDSUBX_INST,
+                         &&SADD8_INST,
+                         &&SADD16_INST,
+                         &&SHSUB16_INST,
+                         &&UMAAL_INST,
+                         &&UXTAB16_INST,
+                         &&USUBADDX_INST,
+                         &&USUB8_INST,
+                         &&USUB16_INST,
+                         &&USAT16_INST,
+                         &&USADA8_INST,
+                         &&UQSUBADDX_INST,
+                         &&UQSUB8_INST,
+                         &&UQSUB16_INST,
+                         &&UQADDSUBX_INST,
+                         &&UQADD8_INST,
+                         &&UQADD16_INST,
+                         &&SXTAB_INST,
+                         &&UHSUBADDX_INST,
+                         &&UHSUB8_INST,
+                         &&UHSUB16_INST,
+                         &&UHADDSUBX_INST,
+                         &&UHADD8_INST,
+                         &&UHADD16_INST,
+                         &&UADDSUBX_INST,
+                         &&UADD8_INST,
+                         &&UADD16_INST,
+                         &&SXTAH_INST,
+                         &&SXTAB16_INST,
+                         &&QADD8_INST,
+                         &&BXJ_INST,
+                         &&CLZ_INST,
+                         &&UXTAH_INST,
+                         &&BX_INST,
+                         &&REV_INST,
+                         &&BLX_INST,
+                         &&REVSH_INST,
+                         &&QADD_INST,
+                         &&QADD16_INST,
+                         &&QADDSUBX_INST,
+                         &&LDREX_INST,
+                         &&QDADD_INST,
+                         &&QDSUB_INST,
+                         &&QSUB_INST,
+                         &&LDREXB_INST,
+                         &&QSUB8_INST,
+                         &&QSUB16_INST,
+                         &&SMUAD_INST,
+                         &&SMMUL_INST,
+                         &&SMUSD_INST,
+                         &&SMLSD_INST,
+                         &&SMLSLD_INST,
+                         &&SMMLA_INST,
+                         &&SMMLS_INST,
+                         &&SMLALD_INST,
+                         &&SMLAD_INST,
+                         &&SMLAW_INST,
+                         &&SMULW_INST,
+                         &&PKHTB_INST,
+                         &&PKHBT_INST,
+                         &&SMUL_INST,
+                         &&SMLALXY_INST,
+                         &&SMLA_INST,
+                         &&MCRR_INST,
+                         &&MRRC_INST,
+                         &&CMP_INST,
+                         &&TST_INST,
+                         &&TEQ_INST,
+                         &&CMN_INST,
+                         &&SMULL_INST,
+                         &&UMULL_INST,
+                         &&UMLAL_INST,
+                         &&SMLAL_INST,
+                         &&MUL_INST,
+                         &&MLA_INST,
+                         &&SSAT_INST,
+                         &&USAT_INST,
+                         &&MRS_INST,
+                         &&MSR_INST,
+                         &&AND_INST,
+                         &&BIC_INST,
+                         &&LDM_INST,
+                         &&EOR_INST,
+                         &&ADD_INST,
+                         &&RSB_INST,
+                         &&RSC_INST,
+                         &&SBC_INST,
+                         &&ADC_INST,
+                         &&SUB_INST,
+                         &&ORR_INST,
+                         &&MVN_INST,
+                         &&MOV_INST,
+                         &&STM_INST,
+                         &&LDM_INST,
+                         &&LDRSH_INST,
+                         &&STM_INST,
+                         &&LDM_INST,
+                         &&LDRSB_INST,
+                         &&STRD_INST,
+                         &&LDRH_INST,
+                         &&STRH_INST,
+                         &&LDRD_INST,
+                         &&STRT_INST,
+                         &&STRBT_INST,
+                         &&LDRBT_INST,
+                         &&LDRT_INST,
+                         &&MRC_INST,
+                         &&MCR_INST,
+                         &&MSR_INST,
+                         &&MSR_INST,
+                         &&MSR_INST,
+                         &&MSR_INST,
+                         &&MSR_INST,
+                         &&LDRB_INST,
+                         &&STRB_INST,
+                         &&LDR_INST,
+                         &&LDRCOND_INST,
+                         &&STR_INST,
+                         &&CDP_INST,
+                         &&STC_INST,
+                         &&LDC_INST,
+                         &&LDREXD_INST,
+                         &&STREXD_INST,
+                         &&LDREXH_INST,
+                         &&STREXH_INST,
+                         &&NOP_INST,
+                         &&YIELD_INST,
+                         &&WFE_INST,
+                         &&WFI_INST,
+                         &&SEV_INST,
+                         &&SWI_INST,
+                         &&BBL_INST,
+                         &&B_2_THUMB,
+                         &&B_COND_THUMB,
+                         &&BL_1_THUMB,
+                         &&BL_2_THUMB,
+                         &&BLX_1_THUMB,
+                         &&DISPATCH,
+                         &&INIT_INST_LENGTH,
+                         &&END};
 #endif
    arm_inst* inst_base;
    unsigned int addr;
@@ -1204,516 +1627,517 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) {
    int ptr;
    LOAD_NZCVT;
-    DISPATCH:
+DISPATCH : {
-    {
+    if (!cpu->NirqSig) {
-        if (!cpu->NirqSig) {
+        if (!(cpu->Cpsr & 0x80)) {
-            if (!(cpu->Cpsr & 0x80)) {
+            goto END;
-                goto END;
-            }
        }
+    }
-        if (cpu->TFlag)
+    if (cpu->TFlag)
-            cpu->Reg[15] &= 0xfffffffe;
+        cpu->Reg[15] &= 0xfffffffe;
-        else
+    else
-            cpu->Reg[15] &= 0xfffffffc;
+        cpu->Reg[15] &= 0xfffffffc;
-        // Find the cached instruction cream, otherwise translate it...
+    // Find the cached instruction cream, otherwise translate it...
-        auto itr = cpu->instruction_cache.find(cpu->Reg[15]);
+    auto itr = cpu->instruction_cache.find(cpu->Reg[15]);
-        if (itr != cpu->instruction_cache.end()) {
+    if (itr != cpu->instruction_cache.end()) {
-            ptr = itr->second;
+        ptr = itr->second;
-        } else if (cpu->NumInstrsToExecute != 1) {
+    } else if (cpu->NumInstrsToExecute != 1) {
-            if (InterpreterTranslateBlock(cpu, ptr, cpu->Reg[15]) == FETCH_EXCEPTION)
+        if (InterpreterTranslateBlock(cpu, ptr, cpu->Reg[15]) == FETCH_EXCEPTION)
-                goto END;
+            goto END;
-        } else {
+    } else {
-            if (InterpreterTranslateSingle(cpu, ptr, cpu->Reg[15]) == FETCH_EXCEPTION)
+        if (InterpreterTranslateSingle(cpu, ptr, cpu->Reg[15]) == FETCH_EXCEPTION)
-                goto END;
+            goto END;
-        }
+    }
-        // Find breakpoint if one exists within the block
+    // Find breakpoint if one exists within the block
-        if (GDBStub::g_server_enabled && GDBStub::IsConnected()) {
+    if (GDBStub::g_server_enabled && GDBStub::IsConnected()) {
-            breakpoint_data = GDBStub::GetNextBreakpointFromAddress(cpu->Reg[15], GDBStub::BreakpointType::Execute);
+        breakpoint_data =
-        }
+            GDBStub::GetNextBreakpointFromAddress(cpu->Reg[15], GDBStub::BreakpointType::Execute);
+    }
-        inst_base = (arm_inst *)&trans_cache_buf[ptr];
+    inst_base = (arm_inst*)&trans_cache_buf[ptr];
-        GOTO_NEXT_INST;
+    GOTO_NEXT_INST;
+}
+ADC_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        adc_inst* const inst_cream = (adc_inst*)inst_base->component;
+        u32 rn_val = RN;
+        if (inst_cream->Rn == 15)
+            rn_val += 2 * cpu->GetInstructionSize();
+        bool carry;
+        bool overflow;
+        RD = AddWithCarry(rn_val, SHIFTER_OPERAND, cpu->CFlag, &carry, &overflow);
+        if (inst_cream->S && (inst_cream->Rd == 15)) {
+            if (CurrentModeHasSPSR) {
+                cpu->Cpsr = cpu->Spsr_copy;
+                cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
+                LOAD_NZCVT;
+            }
+        } else if (inst_cream->S) {
+            UPDATE_NFLAG(RD);
+            UPDATE_ZFLAG(RD);
+            cpu->CFlag = carry;
+            cpu->VFlag = overflow;
+        }
+        if (inst_cream->Rd == 15) {
+            INC_PC(sizeof(adc_inst));
+            goto DISPATCH;
+        }
    }
-    ADC_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(adc_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            adc_inst* const inst_cream = (adc_inst*)inst_base->component;
+    GOTO_NEXT_INST;
+}
+ADD_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        add_inst* const inst_cream = (add_inst*)inst_base->component;
-            u32 rn_val = RN;
+        u32 rn_val = CHECK_READ_REG15_WA(cpu, inst_cream->Rn);
-            if (inst_cream->Rn == 15)
-                rn_val += 2 * cpu->GetInstructionSize();
-            bool carry;
+        bool carry;
-            bool overflow;
+        bool overflow;
-            RD = AddWithCarry(rn_val, SHIFTER_OPERAND, cpu->CFlag, &carry, &overflow);
+        RD = AddWithCarry(rn_val, SHIFTER_OPERAND, 0, &carry, &overflow);
-            if (inst_cream->S && (inst_cream->Rd == 15)) {
+        if (inst_cream->S && (inst_cream->Rd == 15)) {
-                if (CurrentModeHasSPSR) {
+            if (CurrentModeHasSPSR) {
-                    cpu->Cpsr = cpu->Spsr_copy;
+                cpu->Cpsr = cpu->Spsr_copy;
-                    cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
+                cpu->ChangePrivilegeMode(cpu->Cpsr & 0x1F);
-                    LOAD_NZCVT;
+                LOAD_NZCVT;
-                }
-            } else if (inst_cream->S) {
-                UPDATE_NFLAG(RD);
-                UPDATE_ZFLAG(RD);
-                cpu->CFlag = carry;
-                cpu->VFlag = overflow;
-            }
-            if (inst_cream->Rd == 15) {
-                INC_PC(sizeof(adc_inst));
-                goto DISPATCH;
            }
+        } else if (inst_cream->S) {
+            UPDATE_NFLAG(RD);
+            UPDATE_ZFLAG(RD);
+            cpu->CFlag = carry;
+            cpu->VFlag = overflow;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        if (inst_cream->Rd == 15) {
-        INC_PC(sizeof(adc_inst));
+            INC_PC(sizeof(add_inst));
-        FETCH_INST;
+            goto DISPATCH;
-        GOTO_NEXT_INST;
-    }
-    ADD_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            add_inst* const inst_cream = (add_inst*)inst_base->component;
-            u32 rn_val = CHECK_READ_REG15_WA(cpu, inst_cream->Rn);
-            bool carry;
-            bool overflow;
-            RD = AddWithCarry(rn_val, SHIFTER_OPERAND, 0, &carry, &overflow);
-            if (inst_cream->S && (inst_cream->Rd == 15)) {
-                if (CurrentModeHasSPSR) {
-                    cpu->Cpsr = cpu->Spsr_copy;
-                    cpu->ChangePrivilegeMode(cpu->Cpsr & 0x1F);
-                    LOAD_NZCVT;
-                }
-            } else if (inst_cream->S) {
-                UPDATE_NFLAG(RD);
-                UPDATE_ZFLAG(RD);
-                cpu->CFlag = carry;
-                cpu->VFlag = overflow;
-            }
-            if (inst_cream->Rd == 15) {
-                INC_PC(sizeof(add_inst));
-                goto DISPATCH;
-            }
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(add_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    AND_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(add_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            and_inst* const inst_cream = (and_inst*)inst_base->component;
+    GOTO_NEXT_INST;
+}
+AND_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        and_inst* const inst_cream = (and_inst*)inst_base->component;
-            u32 lop = RN;
+        u32 lop = RN;
-            u32 rop = SHIFTER_OPERAND;
+        u32 rop = SHIFTER_OPERAND;
-            if (inst_cream->Rn == 15)
+        if (inst_cream->Rn == 15)
-                lop += 2 * cpu->GetInstructionSize();
+            lop += 2 * cpu->GetInstructionSize();
-            RD = lop & rop;
+        RD = lop & rop;
-            if (inst_cream->S && (inst_cream->Rd == 15)) {
+        if (inst_cream->S && (inst_cream->Rd == 15)) {
-                if (CurrentModeHasSPSR) {
+            if (CurrentModeHasSPSR) {
-                    cpu->Cpsr = cpu->Spsr_copy;
+                cpu->Cpsr = cpu->Spsr_copy;
-                    cpu->ChangePrivilegeMode(cpu->Cpsr & 0x1F);
+                cpu->ChangePrivilegeMode(cpu->Cpsr & 0x1F);
-                    LOAD_NZCVT;
+                LOAD_NZCVT;
-                }
-            } else if (inst_cream->S) {
-                UPDATE_NFLAG(RD);
-                UPDATE_ZFLAG(RD);
-                UPDATE_CFLAG_WITH_SC;
-            }
-            if (inst_cream->Rd == 15) {
-                INC_PC(sizeof(and_inst));
-                goto DISPATCH;
            }
+        } else if (inst_cream->S) {
+            UPDATE_NFLAG(RD);
+            UPDATE_ZFLAG(RD);
+            UPDATE_CFLAG_WITH_SC;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        if (inst_cream->Rd == 15) {
-        INC_PC(sizeof(and_inst));
+            INC_PC(sizeof(and_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    BBL_INST:
-    {
-        if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
-            bbl_inst *inst_cream = (bbl_inst *)inst_base->component;
-            if (inst_cream->L) {
-                LINK_RTN_ADDR;
-            }
-            SET_PC;
-            INC_PC(sizeof(bbl_inst));
            goto DISPATCH;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(and_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+BBL_INST : {
+    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
+        bbl_inst* inst_cream = (bbl_inst*)inst_base->component;
+        if (inst_cream->L) {
+            LINK_RTN_ADDR;
+        }
+        SET_PC;
        INC_PC(sizeof(bbl_inst));
        goto DISPATCH;
    }
-    BIC_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(bbl_inst));
-        bic_inst *inst_cream = (bic_inst *)inst_base->component;
+    goto DISPATCH;
-        if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
+}
-            u32 lop = RN;
+BIC_INST : {
-            if (inst_cream->Rn == 15) {
+    bic_inst* inst_cream = (bic_inst*)inst_base->component;
-                lop += 2 * cpu->GetInstructionSize();
+    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
-            }
+        u32 lop = RN;
-            u32 rop = SHIFTER_OPERAND;
+        if (inst_cream->Rn == 15) {
-            RD = lop & (~rop);
+            lop += 2 * cpu->GetInstructionSize();
-            if ((inst_cream->S) && (inst_cream->Rd == 15)) {
-                if (CurrentModeHasSPSR) {
-                    cpu->Cpsr = cpu->Spsr_copy;
-                    cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
-                    LOAD_NZCVT;
-                }
-            } else if (inst_cream->S) {
-                UPDATE_NFLAG(RD);
-                UPDATE_ZFLAG(RD);
-                UPDATE_CFLAG_WITH_SC;
-            }
-            if (inst_cream->Rd == 15) {
-                INC_PC(sizeof(bic_inst));
-                goto DISPATCH;
-            }
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(bic_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    BKPT_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            bkpt_inst* const inst_cream = (bkpt_inst*)inst_base->component;
-            LOG_DEBUG(Core_ARM11, "Breakpoint instruction hit. Immediate: 0x%08X", inst_cream->imm);
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        u32 rop = SHIFTER_OPERAND;
-        INC_PC(sizeof(bkpt_inst));
+        RD = lop & (~rop);
-        FETCH_INST;
+        if ((inst_cream->S) && (inst_cream->Rd == 15)) {
-        GOTO_NEXT_INST;
+            if (CurrentModeHasSPSR) {
-    }
+                cpu->Cpsr = cpu->Spsr_copy;
-    BLX_INST:
+                cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
-    {
+                LOAD_NZCVT;
-        blx_inst *inst_cream = (blx_inst *)inst_base->component;
-        if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
-            unsigned int inst = inst_cream->inst;
-            if (BITS(inst, 20, 27) == 0x12 && BITS(inst, 4, 7) == 0x3) {
-                const u32 jump_address = cpu->Reg[inst_cream->val.Rm];
-                cpu->Reg[14] = (cpu->Reg[15] + cpu->GetInstructionSize());
-                if(cpu->TFlag)
-                    cpu->Reg[14] |= 0x1;
-                cpu->Reg[15] = jump_address & 0xfffffffe;
-                cpu->TFlag = jump_address & 0x1;
-            } else {
-                cpu->Reg[14] = (cpu->Reg[15] + cpu->GetInstructionSize());
-                cpu->TFlag = 0x1;
-                int signed_int = inst_cream->val.signed_immed_24;
-                signed_int = (signed_int & 0x800000) ? (0x3F000000 | signed_int) : signed_int;
-                signed_int = signed_int << 2;
-                cpu->Reg[15] = cpu->Reg[15] + 8 + signed_int + (BIT(inst, 24) << 1);
            }
-            INC_PC(sizeof(blx_inst));
+        } else if (inst_cream->S) {
+            UPDATE_NFLAG(RD);
+            UPDATE_ZFLAG(RD);
+            UPDATE_CFLAG_WITH_SC;
+        }
+        if (inst_cream->Rd == 15) {
+            INC_PC(sizeof(bic_inst));
            goto DISPATCH;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(bic_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+BKPT_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        bkpt_inst* const inst_cream = (bkpt_inst*)inst_base->component;
+        LOG_DEBUG(Core_ARM11, "Breakpoint instruction hit. Immediate: 0x%08X", inst_cream->imm);
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(bkpt_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+BLX_INST : {
+    blx_inst* inst_cream = (blx_inst*)inst_base->component;
+    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
+        unsigned int inst = inst_cream->inst;
+        if (BITS(inst, 20, 27) == 0x12 && BITS(inst, 4, 7) == 0x3) {
+            const u32 jump_address = cpu->Reg[inst_cream->val.Rm];
+            cpu->Reg[14] = (cpu->Reg[15] + cpu->GetInstructionSize());
+            if (cpu->TFlag)
+                cpu->Reg[14] |= 0x1;
+            cpu->Reg[15] = jump_address & 0xfffffffe;
+            cpu->TFlag = jump_address & 0x1;
+        } else {
+            cpu->Reg[14] = (cpu->Reg[15] + cpu->GetInstructionSize());
+            cpu->TFlag = 0x1;
+            int signed_int = inst_cream->val.signed_immed_24;
+            signed_int = (signed_int & 0x800000) ? (0x3F000000 | signed_int) : signed_int;
+            signed_int = signed_int << 2;
+            cpu->Reg[15] = cpu->Reg[15] + 8 + signed_int + (BIT(inst, 24) << 1);
+        }
        INC_PC(sizeof(blx_inst));
        goto DISPATCH;
    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(blx_inst));
+    goto DISPATCH;
+}
-    BX_INST:
+BX_INST:
-    BXJ_INST:
+BXJ_INST : {
-    {
+    // Note that only the 'fail' case of BXJ is emulated. This is because
-        // Note that only the 'fail' case of BXJ is emulated. This is because
+    // the facilities for Jazelle emulation are not implemented.
-        // the facilities for Jazelle emulation are not implemented.
+    //
-        //
+    // According to the ARM documentation on BXJ, if setting the J bit in the APSR
-        // According to the ARM documentation on BXJ, if setting the J bit in the APSR
+    // fails, then BXJ functions identically like a regular BX instruction.
-        // fails, then BXJ functions identically like a regular BX instruction.
+    //
-        //
+    // This is sufficient for citra, as the CPU for the 3DS does not implement Jazelle.
-        // This is sufficient for citra, as the CPU for the 3DS does not implement Jazelle.
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            bx_inst* const inst_cream = (bx_inst*)inst_base->component;
+        bx_inst* const inst_cream = (bx_inst*)inst_base->component;
-            u32 address = RM;
+        u32 address = RM;
-            if (inst_cream->Rm == 15)
+        if (inst_cream->Rm == 15)
-                address += 2 * cpu->GetInstructionSize();
+            address += 2 * cpu->GetInstructionSize();
-            cpu->TFlag   = address & 1;
+        cpu->TFlag = address & 1;
-            cpu->Reg[15] = address & 0xfffffffe;
+        cpu->Reg[15] = address & 0xfffffffe;
-            INC_PC(sizeof(bx_inst));
-            goto DISPATCH;
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
        INC_PC(sizeof(bx_inst));
        goto DISPATCH;
    }
-    CDP_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(bx_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    goto DISPATCH;
-            // Undefined instruction here
+}
-            cpu->NumInstrsToExecute = 0;
-            return num_instrs;
+CDP_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        // Undefined instruction here
+        cpu->NumInstrsToExecute = 0;
+        return num_instrs;
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(cdp_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+CLREX_INST : {
+    cpu->UnsetExclusiveMemoryAddress();
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(clrex_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+CLZ_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        clz_inst* inst_cream = (clz_inst*)inst_base->component;
+        RD = clz(RM);
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(clz_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+CMN_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        cmn_inst* const inst_cream = (cmn_inst*)inst_base->component;
+        u32 rn_val = RN;
+        if (inst_cream->Rn == 15)
+            rn_val += 2 * cpu->GetInstructionSize();
+        bool carry;
+        bool overflow;
+        u32 result = AddWithCarry(rn_val, SHIFTER_OPERAND, 0, &carry, &overflow);
+        UPDATE_NFLAG(result);
+        UPDATE_ZFLAG(result);
+        cpu->CFlag = carry;
+        cpu->VFlag = overflow;
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(cmn_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+CMP_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        cmp_inst* const inst_cream = (cmp_inst*)inst_base->component;
+        u32 rn_val = RN;
+        if (inst_cream->Rn == 15)
+            rn_val += 2 * cpu->GetInstructionSize();
+        bool carry;
+        bool overflow;
+        u32 result = AddWithCarry(rn_val, ~SHIFTER_OPERAND, 1, &carry, &overflow);
+        UPDATE_NFLAG(result);
+        UPDATE_ZFLAG(result);
+        cpu->CFlag = carry;
+        cpu->VFlag = overflow;
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(cmp_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+CPS_INST : {
+    cps_inst* inst_cream = (cps_inst*)inst_base->component;
+    u32 aif_val = 0;
+    u32 aif_mask = 0;
+    if (cpu->InAPrivilegedMode()) {
+        if (inst_cream->imod1) {
+            if (inst_cream->A) {
+                aif_val |= (inst_cream->imod0 << 8);
+                aif_mask |= 1 << 8;
+            }
+            if (inst_cream->I) {
+                aif_val |= (inst_cream->imod0 << 7);
+                aif_mask |= 1 << 7;
+            }
+            if (inst_cream->F) {
+                aif_val |= (inst_cream->imod0 << 6);
+                aif_mask |= 1 << 6;
+            }
+            aif_mask = ~aif_mask;
+            cpu->Cpsr = (cpu->Cpsr & aif_mask) | aif_val;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        if (inst_cream->mmod) {
-        INC_PC(sizeof(cdp_inst));
+            cpu->Cpsr = (cpu->Cpsr & 0xffffffe0) | inst_cream->mode;
-        FETCH_INST;
+            cpu->ChangePrivilegeMode(inst_cream->mode);
-        GOTO_NEXT_INST;
-    }
-    CLREX_INST:
-    {
-        cpu->UnsetExclusiveMemoryAddress();
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(clrex_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    CLZ_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            clz_inst* inst_cream = (clz_inst*)inst_base->component;
-            RD = clz(RM);
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+    }
-        INC_PC(sizeof(clz_inst));
+    cpu->Reg[15] += cpu->GetInstructionSize();
-        FETCH_INST;
+    INC_PC(sizeof(cps_inst));
-        GOTO_NEXT_INST;
+    FETCH_INST;
-    }
+    GOTO_NEXT_INST;
-    CMN_INST:
+}
-    {
+CPY_INST : {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            cmn_inst* const inst_cream = (cmn_inst*)inst_base->component;
+        mov_inst* inst_cream = (mov_inst*)inst_base->component;
-            u32 rn_val = RN;
+        RD = SHIFTER_OPERAND;
-            if (inst_cream->Rn == 15)
+        if (inst_cream->Rd == 15) {
-                rn_val += 2 * cpu->GetInstructionSize();
+            INC_PC(sizeof(mov_inst));
+            goto DISPATCH;
-            bool carry;
-            bool overflow;
-            u32 result = AddWithCarry(rn_val, SHIFTER_OPERAND, 0, &carry, &overflow);
-            UPDATE_NFLAG(result);
-            UPDATE_ZFLAG(result);
-            cpu->CFlag = carry;
-            cpu->VFlag = overflow;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+    }
-        INC_PC(sizeof(cmn_inst));
+    cpu->Reg[15] += cpu->GetInstructionSize();
-        FETCH_INST;
+    INC_PC(sizeof(mov_inst));
-        GOTO_NEXT_INST;
+    FETCH_INST;
-    }
+    GOTO_NEXT_INST;
-    CMP_INST:
+}
-    {
+EOR_INST : {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            cmp_inst* const inst_cream = (cmp_inst*)inst_base->component;
+        eor_inst* inst_cream = (eor_inst*)inst_base->component;
-            u32 rn_val = RN;
+        u32 lop = RN;
-            if (inst_cream->Rn == 15)
+        if (inst_cream->Rn == 15) {
-                rn_val += 2 * cpu->GetInstructionSize();
+            lop += 2 * cpu->GetInstructionSize();
-            bool carry;
-            bool overflow;
-            u32 result = AddWithCarry(rn_val, ~SHIFTER_OPERAND, 1, &carry, &overflow);
-            UPDATE_NFLAG(result);
-            UPDATE_ZFLAG(result);
-            cpu->CFlag = carry;
-            cpu->VFlag = overflow;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        u32 rop = SHIFTER_OPERAND;
-        INC_PC(sizeof(cmp_inst));
+        RD = lop ^ rop;
-        FETCH_INST;
+        if (inst_cream->S && (inst_cream->Rd == 15)) {
-        GOTO_NEXT_INST;
+            if (CurrentModeHasSPSR) {
-    }
+                cpu->Cpsr = cpu->Spsr_copy;
-    CPS_INST:
+                cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
-    {
+                LOAD_NZCVT;
-        cps_inst *inst_cream = (cps_inst *)inst_base->component;
-        u32 aif_val = 0;
-        u32 aif_mask = 0;
-        if (cpu->InAPrivilegedMode()) {
-            if (inst_cream->imod1) {
-                if (inst_cream->A) {
-                    aif_val |= (inst_cream->imod0 << 8);
-                    aif_mask |= 1 << 8;
-                }
-                if (inst_cream->I) {
-                    aif_val |= (inst_cream->imod0 << 7);
-                    aif_mask |= 1 << 7;
-                }
-                if (inst_cream->F) {
-                    aif_val |= (inst_cream->imod0 << 6);
-                    aif_mask |= 1 << 6;
-                }
-                aif_mask = ~aif_mask;
-                cpu->Cpsr = (cpu->Cpsr & aif_mask) | aif_val;
-            }
-            if (inst_cream->mmod) {
-                cpu->Cpsr = (cpu->Cpsr & 0xffffffe0) | inst_cream->mode;
-                cpu->ChangePrivilegeMode(inst_cream->mode);
            }
+        } else if (inst_cream->S) {
+            UPDATE_NFLAG(RD);
+            UPDATE_ZFLAG(RD);
+            UPDATE_CFLAG_WITH_SC;
+        }
+        if (inst_cream->Rd == 15) {
+            INC_PC(sizeof(eor_inst));
+            goto DISPATCH;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(cps_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    CPY_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(eor_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            mov_inst* inst_cream = (mov_inst*)inst_base->component;
+    GOTO_NEXT_INST;
+}
+LDC_INST : {
+    // Instruction not implemented
+    // LOG_CRITICAL(Core_ARM11, "unimplemented instruction");
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(ldc_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+LDM_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+        inst_cream->get_addr(cpu, inst_cream->inst, addr);
-            RD = SHIFTER_OPERAND;
+        unsigned int inst = inst_cream->inst;
-            if (inst_cream->Rd == 15) {
+        if (BIT(inst, 22) && !BIT(inst, 15)) {
-                INC_PC(sizeof(mov_inst));
+            for (int i = 0; i < 13; i++) {
-                goto DISPATCH;
+                if (BIT(inst, i)) {
-            }
+                    cpu->Reg[i] = cpu->ReadMemory32(addr);
-        }
+                    addr += 4;
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(mov_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    EOR_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            eor_inst* inst_cream = (eor_inst*)inst_base->component;
-            u32 lop = RN;
-            if (inst_cream->Rn == 15) {
-                lop += 2 * cpu->GetInstructionSize();
-            }
-            u32 rop = SHIFTER_OPERAND;
-            RD = lop ^ rop;
-            if (inst_cream->S && (inst_cream->Rd == 15)) {
-                if (CurrentModeHasSPSR) {
-                    cpu->Cpsr = cpu->Spsr_copy;
-                    cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
-                    LOAD_NZCVT;
                }
-            } else if (inst_cream->S) {
-                UPDATE_NFLAG(RD);
-                UPDATE_ZFLAG(RD);
-                UPDATE_CFLAG_WITH_SC;
            }
-            if (inst_cream->Rd == 15) {
+            if (BIT(inst, 13)) {
-                INC_PC(sizeof(eor_inst));
+                if (cpu->Mode == USER32MODE)
-                goto DISPATCH;
+                    cpu->Reg[13] = cpu->ReadMemory32(addr);
+                else
+                    cpu->Reg_usr[0] = cpu->ReadMemory32(addr);
+                addr += 4;
            }
-        }
+            if (BIT(inst, 14)) {
-        cpu->Reg[15] += cpu->GetInstructionSize();
+                if (cpu->Mode == USER32MODE)
-        INC_PC(sizeof(eor_inst));
+                    cpu->Reg[14] = cpu->ReadMemory32(addr);
-        FETCH_INST;
+                else
-        GOTO_NEXT_INST;
+                    cpu->Reg_usr[1] = cpu->ReadMemory32(addr);
-    }
-    LDC_INST:
+                addr += 4;
-    {
+            }
-        // Instruction not implemented
+        } else if (!BIT(inst, 22)) {
-        //LOG_CRITICAL(Core_ARM11, "unimplemented instruction");
+            for (int i = 0; i < 16; i++) {
-        cpu->Reg[15] += cpu->GetInstructionSize();
+                if (BIT(inst, i)) {
-        INC_PC(sizeof(ldc_inst));
+                    unsigned int ret = cpu->ReadMemory32(addr);
-        FETCH_INST;
-        GOTO_NEXT_INST;
+                    // For armv5t, should enter thumb when bits[0] is non-zero.
-    }
+                    if (i == 15) {
-    LDM_INST:
+                        cpu->TFlag = ret & 0x1;
-    {
+                        ret &= 0xFFFFFFFE;
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-            inst_cream->get_addr(cpu, inst_cream->inst, addr);
-            unsigned int inst = inst_cream->inst;
-            if (BIT(inst, 22) && !BIT(inst, 15)) {
-                for (int i = 0; i < 13; i++) {
-                    if(BIT(inst, i)) {
-                        cpu->Reg[i] = cpu->ReadMemory32(addr);
-                        addr += 4;
                    }
-                }
-                if (BIT(inst, 13)) {
-                    if (cpu->Mode == USER32MODE)
-                        cpu->Reg[13] = cpu->ReadMemory32(addr);
-                    else
-                        cpu->Reg_usr[0] = cpu->ReadMemory32(addr);
+                    cpu->Reg[i] = ret;
                    addr += 4;
                }
-                if (BIT(inst, 14)) {
+            }
-                    if (cpu->Mode == USER32MODE)
+        } else if (BIT(inst, 22) && BIT(inst, 15)) {
-                        cpu->Reg[14] = cpu->ReadMemory32(addr);
+            for (int i = 0; i < 15; i++) {
-                    else
+                if (BIT(inst, i)) {
-                        cpu->Reg_usr[1] = cpu->ReadMemory32(addr);
+                    cpu->Reg[i] = cpu->ReadMemory32(addr);
                    addr += 4;
                }
-            } else if (!BIT(inst, 22)) {
-                for(int i = 0; i < 16; i++ ){
-                    if(BIT(inst, i)){
-                        unsigned int ret = cpu->ReadMemory32(addr);
-                        // For armv5t, should enter thumb when bits[0] is non-zero.
-                        if(i == 15){
-                            cpu->TFlag = ret & 0x1;
-                            ret &= 0xFFFFFFFE;
-                        }
-                        cpu->Reg[i] = ret;
-                        addr += 4;
-                    }
-                }
-            } else if (BIT(inst, 22) && BIT(inst, 15)) {
-                for(int i = 0; i < 15; i++ ){
-                    if(BIT(inst, i)){
-                        cpu->Reg[i] = cpu->ReadMemory32(addr);
-                        addr += 4;
-                     }
-                 }
-                if (CurrentModeHasSPSR) {
-                    cpu->Cpsr = cpu->Spsr_copy;
-                    cpu->ChangePrivilegeMode(cpu->Cpsr & 0x1F);
-                    LOAD_NZCVT;
-                }
-                cpu->Reg[15] = cpu->ReadMemory32(addr);
            }
-            if (BIT(inst, 15)) {
+            if (CurrentModeHasSPSR) {
-                INC_PC(sizeof(ldst_inst));
+                cpu->Cpsr = cpu->Spsr_copy;
-                goto DISPATCH;
+                cpu->ChangePrivilegeMode(cpu->Cpsr & 0x1F);
+                LOAD_NZCVT;
            }
+            cpu->Reg[15] = cpu->ReadMemory32(addr);
+        }
+        if (BIT(inst, 15)) {
+            INC_PC(sizeof(ldst_inst));
+            goto DISPATCH;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    SXTH_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(ldst_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            sxth_inst* inst_cream = (sxth_inst*)inst_base->component;
+    GOTO_NEXT_INST;
+}
+SXTH_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        sxth_inst* inst_cream = (sxth_inst*)inst_base->component;
-            unsigned int operand2 = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate);
+        unsigned int operand2 = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate);
-            if (BIT(operand2, 15)) {
+        if (BIT(operand2, 15)) {
-                operand2 |= 0xffff0000;
+            operand2 |= 0xffff0000;
-            } else {
+        } else {
-                operand2 &= 0xffff;
+            operand2 &= 0xffff;
-            }
-            RD = operand2;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        RD = operand2;
-        INC_PC(sizeof(sxth_inst));
+    }
-        FETCH_INST;
+    cpu->Reg[15] += cpu->GetInstructionSize();
-        GOTO_NEXT_INST;
+    INC_PC(sizeof(sxth_inst));
-    }
+    FETCH_INST;
-    LDR_INST:
+    GOTO_NEXT_INST;
-    {
+}
-        ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
+LDR_INST : {
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+    inst_cream->get_addr(cpu, inst_cream->inst, addr);
+    unsigned int value = cpu->ReadMemory32(addr);
+    cpu->Reg[BITS(inst_cream->inst, 12, 15)] = value;
+    if (BITS(inst_cream->inst, 12, 15) == 15) {
+        // For armv5t, should enter thumb when bits[0] is non-zero.
+        cpu->TFlag = value & 0x1;
+        cpu->Reg[15] &= 0xFFFFFFFE;
+        INC_PC(sizeof(ldst_inst));
+        goto DISPATCH;
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(ldst_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+LDRCOND_INST : {
+    if (CondPassed(cpu, inst_base->cond)) {
+        ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
        inst_cream->get_addr(cpu, inst_cream->inst, addr);
        unsigned int value = cpu->ReadMemory32(addr);
@@ -1726,2546 +2150,2433 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) {
            INC_PC(sizeof(ldst_inst));
            goto DISPATCH;
        }
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(ldst_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+UXTH_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        uxth_inst* inst_cream = (uxth_inst*)inst_base->component;
+        RD = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate) & 0xffff;
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(uxth_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+UXTAH_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        uxtah_inst* inst_cream = (uxtah_inst*)inst_base->component;
+        unsigned int operand2 = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate) & 0xffff;
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        RD = RN + operand2;
-        INC_PC(sizeof(ldst_inst));
+    }
-        FETCH_INST;
+    cpu->Reg[15] += cpu->GetInstructionSize();
-        GOTO_NEXT_INST;
+    INC_PC(sizeof(uxtah_inst));
-    }
+    FETCH_INST;
-    LDRCOND_INST:
+    GOTO_NEXT_INST;
-    {
+}
-        if (CondPassed(cpu, inst_base->cond)) {
+LDRB_INST : {
-            ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            inst_cream->get_addr(cpu, inst_cream->inst, addr);
+        ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+        inst_cream->get_addr(cpu, inst_cream->inst, addr);
-            unsigned int value = cpu->ReadMemory32(addr);
-            cpu->Reg[BITS(inst_cream->inst, 12, 15)] = value;
+        cpu->Reg[BITS(inst_cream->inst, 12, 15)] = cpu->ReadMemory8(addr);
-            if (BITS(inst_cream->inst, 12, 15) == 15) {
-                // For armv5t, should enter thumb when bits[0] is non-zero.
-                cpu->TFlag = value & 0x1;
-                cpu->Reg[15] &= 0xFFFFFFFE;
-                INC_PC(sizeof(ldst_inst));
-                goto DISPATCH;
-            }
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    UXTH_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            uxth_inst* inst_cream = (uxth_inst*)inst_base->component;
-            RD = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate) & 0xffff;
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(uxth_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    UXTAH_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            uxtah_inst* inst_cream = (uxtah_inst*)inst_base->component;
-            unsigned int operand2 = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate) & 0xffff;
-            RD = RN + operand2;
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(uxtah_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    LDRB_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-            inst_cream->get_addr(cpu, inst_cream->inst, addr);
-            cpu->Reg[BITS(inst_cream->inst, 12, 15)] = cpu->ReadMemory8(addr);
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    LDRBT_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(ldst_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+    GOTO_NEXT_INST;
-            inst_cream->get_addr(cpu, inst_cream->inst, addr);
+}
+LDRBT_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+        inst_cream->get_addr(cpu, inst_cream->inst, addr);
-            const u32 dest_index = BITS(inst_cream->inst, 12, 15);
+        const u32 dest_index = BITS(inst_cream->inst, 12, 15);
-            const u32 previous_mode = cpu->Mode;
+        const u32 previous_mode = cpu->Mode;
-            cpu->ChangePrivilegeMode(USER32MODE);
+        cpu->ChangePrivilegeMode(USER32MODE);
-            const u8 value = cpu->ReadMemory8(addr);
+        const u8 value = cpu->ReadMemory8(addr);
-            cpu->ChangePrivilegeMode(previous_mode);
+        cpu->ChangePrivilegeMode(previous_mode);
-            cpu->Reg[dest_index] = value;
+        cpu->Reg[dest_index] = value;
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    LDRD_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-            // Should check if RD is even-numbered, Rd != 14, addr[0:1] == 0, (CP15_reg1_U == 1 || addr[2] == 0)
-            inst_cream->get_addr(cpu, inst_cream->inst, addr);
-            // The 3DS doesn't have LPAE (Large Physical Access Extension), so it
-            // wouldn't do this as a single read.
-            cpu->Reg[BITS(inst_cream->inst, 12, 15) + 0] = cpu->ReadMemory32(addr);
-            cpu->Reg[BITS(inst_cream->inst, 12, 15) + 1] = cpu->ReadMemory32(addr + 4);
-            // No dispatch since this operation should not modify R15
-        }
-        cpu->Reg[15] += 4;
-        INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(ldst_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+LDRD_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+        // Should check if RD is even-numbered, Rd != 14, addr[0:1] == 0, (CP15_reg1_U == 1 ||
+        // addr[2] == 0)
+        inst_cream->get_addr(cpu, inst_cream->inst, addr);
-    LDREX_INST:
+        // The 3DS doesn't have LPAE (Large Physical Access Extension), so it
-    {
+        // wouldn't do this as a single read.
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        cpu->Reg[BITS(inst_cream->inst, 12, 15) + 0] = cpu->ReadMemory32(addr);
-            generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
+        cpu->Reg[BITS(inst_cream->inst, 12, 15) + 1] = cpu->ReadMemory32(addr + 4);
-            unsigned int read_addr = RN;
-            cpu->SetExclusiveMemoryAddress(read_addr);
-            RD = cpu->ReadMemory32(read_addr);
+        // No dispatch since this operation should not modify R15
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    LDREXB_INST:
+    cpu->Reg[15] += 4;
-    {
+    INC_PC(sizeof(ldst_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
+    GOTO_NEXT_INST;
-            unsigned int read_addr = RN;
+}
-            cpu->SetExclusiveMemoryAddress(read_addr);
+LDREX_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
+        unsigned int read_addr = RN;
-            RD = cpu->ReadMemory8(read_addr);
+        cpu->SetExclusiveMemoryAddress(read_addr);
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        RD = cpu->ReadMemory32(read_addr);
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    LDREXH_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(generic_arm_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
+    GOTO_NEXT_INST;
-            unsigned int read_addr = RN;
+}
+LDREXB_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
+        unsigned int read_addr = RN;
-            cpu->SetExclusiveMemoryAddress(read_addr);
+        cpu->SetExclusiveMemoryAddress(read_addr);
-            RD = cpu->ReadMemory16(read_addr);
+        RD = cpu->ReadMemory8(read_addr);
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    LDREXD_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(generic_arm_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
+    GOTO_NEXT_INST;
-            unsigned int read_addr = RN;
+}
+LDREXH_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
+        unsigned int read_addr = RN;
-            cpu->SetExclusiveMemoryAddress(read_addr);
+        cpu->SetExclusiveMemoryAddress(read_addr);
-            RD  = cpu->ReadMemory32(read_addr);
+        RD = cpu->ReadMemory16(read_addr);
-            RD2 = cpu->ReadMemory32(read_addr + 4);
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    LDRH_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-            inst_cream->get_addr(cpu, inst_cream->inst, addr);
-            cpu->Reg[BITS(inst_cream->inst, 12, 15)] = cpu->ReadMemory16(addr);
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    LDRSB_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-            inst_cream->get_addr(cpu, inst_cream->inst, addr);
-            unsigned int value = cpu->ReadMemory8(addr);
-            if (BIT(value, 7)) {
-                value |= 0xffffff00;
-            }
-            cpu->Reg[BITS(inst_cream->inst, 12, 15)] = value;
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    LDRSH_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-            inst_cream->get_addr(cpu, inst_cream->inst, addr);
-            unsigned int value = cpu->ReadMemory16(addr);
-            if (BIT(value, 15)) {
-                value |= 0xffff0000;
-            }
-            cpu->Reg[BITS(inst_cream->inst, 12, 15)] = value;
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    LDRT_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(generic_arm_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+    GOTO_NEXT_INST;
-            inst_cream->get_addr(cpu, inst_cream->inst, addr);
+}
+LDREXD_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
+        unsigned int read_addr = RN;
-            const u32 dest_index = BITS(inst_cream->inst, 12, 15);
+        cpu->SetExclusiveMemoryAddress(read_addr);
-            const u32 previous_mode = cpu->Mode;
-            cpu->ChangePrivilegeMode(USER32MODE);
+        RD = cpu->ReadMemory32(read_addr);
-            const u32 value = cpu->ReadMemory32(addr);
+        RD2 = cpu->ReadMemory32(read_addr + 4);
-            cpu->ChangePrivilegeMode(previous_mode);
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(generic_arm_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+LDRH_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+        inst_cream->get_addr(cpu, inst_cream->inst, addr);
-            cpu->Reg[dest_index] = value;
+        cpu->Reg[BITS(inst_cream->inst, 12, 15)] = cpu->ReadMemory16(addr);
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(ldst_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+LDRSB_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+        inst_cream->get_addr(cpu, inst_cream->inst, addr);
+        unsigned int value = cpu->ReadMemory8(addr);
+        if (BIT(value, 7)) {
+            value |= 0xffffff00;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        cpu->Reg[BITS(inst_cream->inst, 12, 15)] = value;
-        INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    MCR_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(ldst_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            mcr_inst* inst_cream = (mcr_inst*)inst_base->component;
+    GOTO_NEXT_INST;
+}
+LDRSH_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+        inst_cream->get_addr(cpu, inst_cream->inst, addr);
-            unsigned int inst = inst_cream->inst;
+        unsigned int value = cpu->ReadMemory16(addr);
-            if (inst_cream->Rd == 15) {
+        if (BIT(value, 15)) {
-                DEBUG_MSG;
+            value |= 0xffff0000;
-            } else {
-                if (inst_cream->cp_num == 15)
-                    cpu->WriteCP15Register(RD, CRn, OPCODE_1, CRm, OPCODE_2);
-            }
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        cpu->Reg[BITS(inst_cream->inst, 12, 15)] = value;
-        INC_PC(sizeof(mcr_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(ldst_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+LDRT_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+        inst_cream->get_addr(cpu, inst_cream->inst, addr);
+        const u32 dest_index = BITS(inst_cream->inst, 12, 15);
+        const u32 previous_mode = cpu->Mode;
-    MCRR_INST:
+        cpu->ChangePrivilegeMode(USER32MODE);
-    {
+        const u32 value = cpu->ReadMemory32(addr);
-        // Stubbed, as the MPCore doesn't have any registers that are accessible
+        cpu->ChangePrivilegeMode(previous_mode);
-        // through this instruction.
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            mcrr_inst* const inst_cream = (mcrr_inst*)inst_base->component;
-            LOG_ERROR(Core_ARM11, "MCRR executed | Coprocessor: %u, CRm %u, opc1: %u, Rt: %u, Rt2: %u",
+        cpu->Reg[dest_index] = value;
-                      inst_cream->cp_num, inst_cream->crm, inst_cream->opcode_1, inst_cream->rt, inst_cream->rt2);
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(ldst_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+MCR_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        mcr_inst* inst_cream = (mcr_inst*)inst_base->component;
+        unsigned int inst = inst_cream->inst;
+        if (inst_cream->Rd == 15) {
+            DEBUG_MSG;
+        } else {
+            if (inst_cream->cp_num == 15)
+                cpu->WriteCP15Register(RD, CRn, OPCODE_1, CRm, OPCODE_2);
        }
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(mcr_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+MCRR_INST : {
+    // Stubbed, as the MPCore doesn't have any registers that are accessible
+    // through this instruction.
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        mcrr_inst* const inst_cream = (mcrr_inst*)inst_base->component;
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        LOG_ERROR(Core_ARM11, "MCRR executed | Coprocessor: %u, CRm %u, opc1: %u, Rt: %u, Rt2: %u",
-        INC_PC(sizeof(mcrr_inst));
+                  inst_cream->cp_num, inst_cream->crm, inst_cream->opcode_1, inst_cream->rt,
-        FETCH_INST;
+                  inst_cream->rt2);
-        GOTO_NEXT_INST;
    }
-    MLA_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(mcrr_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            mla_inst* inst_cream = (mla_inst*)inst_base->component;
+    GOTO_NEXT_INST;
+}
-            u64 rm = RM;
+MLA_INST : {
-            u64 rs = RS;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            u64 rn = RN;
+        mla_inst* inst_cream = (mla_inst*)inst_base->component;
-            RD = static_cast<u32>((rm * rs + rn) & 0xffffffff);
+        u64 rm = RM;
-            if (inst_cream->S) {
+        u64 rs = RS;
-                UPDATE_NFLAG(RD);
+        u64 rn = RN;
-                UPDATE_ZFLAG(RD);
-            }
+        RD = static_cast<u32>((rm * rs + rn) & 0xffffffff);
+        if (inst_cream->S) {
+            UPDATE_NFLAG(RD);
+            UPDATE_ZFLAG(RD);
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+    }
-        INC_PC(sizeof(mla_inst));
+    cpu->Reg[15] += cpu->GetInstructionSize();
-        FETCH_INST;
+    INC_PC(sizeof(mla_inst));
-        GOTO_NEXT_INST;
+    FETCH_INST;
-    }
+    GOTO_NEXT_INST;
-    MOV_INST:
+}
-    {
+MOV_INST : {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            mov_inst* inst_cream = (mov_inst*)inst_base->component;
+        mov_inst* inst_cream = (mov_inst*)inst_base->component;
-            RD = SHIFTER_OPERAND;
+        RD = SHIFTER_OPERAND;
-            if (inst_cream->S && (inst_cream->Rd == 15)) {
+        if (inst_cream->S && (inst_cream->Rd == 15)) {
-                if (CurrentModeHasSPSR) {
+            if (CurrentModeHasSPSR) {
-                    cpu->Cpsr = cpu->Spsr_copy;
+                cpu->Cpsr = cpu->Spsr_copy;
-                    cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
+                cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
-                    LOAD_NZCVT;
+                LOAD_NZCVT;
-                }
-            } else if (inst_cream->S) {
-                UPDATE_NFLAG(RD);
-                UPDATE_ZFLAG(RD);
-                UPDATE_CFLAG_WITH_SC;
-            }
-            if (inst_cream->Rd == 15) {
-                INC_PC(sizeof(mov_inst));
-                goto DISPATCH;
            }
+        } else if (inst_cream->S) {
+            UPDATE_NFLAG(RD);
+            UPDATE_ZFLAG(RD);
+            UPDATE_CFLAG_WITH_SC;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        if (inst_cream->Rd == 15) {
-        INC_PC(sizeof(mov_inst));
+            INC_PC(sizeof(mov_inst));
-        FETCH_INST;
+            goto DISPATCH;
-        GOTO_NEXT_INST;
-    }
-    MRC_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            mrc_inst* inst_cream = (mrc_inst*)inst_base->component;
-            if (inst_cream->cp_num == 15) {
-                const uint32_t value = cpu->ReadCP15Register(CRn, OPCODE_1, CRm, OPCODE_2);
-                if (inst_cream->Rd == 15) {
-                    cpu->Cpsr = (cpu->Cpsr & ~0xF0000000) | (value & 0xF0000000);
-                    LOAD_NZCVT;
-                } else {
-                    RD = value;
-                }
-            }
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(mrc_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(mov_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+MRC_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        mrc_inst* inst_cream = (mrc_inst*)inst_base->component;
-    MRRC_INST:
+        if (inst_cream->cp_num == 15) {
-    {
+            const uint32_t value = cpu->ReadCP15Register(CRn, OPCODE_1, CRm, OPCODE_2);
-        // Stubbed, as the MPCore doesn't have any registers that are accessible
-        // through this instruction.
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            mcrr_inst* const inst_cream = (mcrr_inst*)inst_base->component;
-            LOG_ERROR(Core_ARM11, "MRRC executed | Coprocessor: %u, CRm %u, opc1: %u, Rt: %u, Rt2: %u",
+            if (inst_cream->Rd == 15) {
-                      inst_cream->cp_num, inst_cream->crm, inst_cream->opcode_1, inst_cream->rt, inst_cream->rt2);
+                cpu->Cpsr = (cpu->Cpsr & ~0xF0000000) | (value & 0xF0000000);
+                LOAD_NZCVT;
+            } else {
+                RD = value;
+            }
        }
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(mrc_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+MRRC_INST : {
+    // Stubbed, as the MPCore doesn't have any registers that are accessible
+    // through this instruction.
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        mcrr_inst* const inst_cream = (mcrr_inst*)inst_base->component;
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        LOG_ERROR(Core_ARM11, "MRRC executed | Coprocessor: %u, CRm %u, opc1: %u, Rt: %u, Rt2: %u",
-        INC_PC(sizeof(mcrr_inst));
+                  inst_cream->cp_num, inst_cream->crm, inst_cream->opcode_1, inst_cream->rt,
-        FETCH_INST;
+                  inst_cream->rt2);
-        GOTO_NEXT_INST;
    }
-    MRS_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(mcrr_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            mrs_inst* inst_cream = (mrs_inst*)inst_base->component;
+    GOTO_NEXT_INST;
+}
+MRS_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        mrs_inst* inst_cream = (mrs_inst*)inst_base->component;
-            if (inst_cream->R) {
+        if (inst_cream->R) {
-                RD = cpu->Spsr_copy;
+            RD = cpu->Spsr_copy;
-            } else {
+        } else {
-                SAVE_NZCVT;
+            SAVE_NZCVT;
-                RD = cpu->Cpsr;
+            RD = cpu->Cpsr;
-            }
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+    }
-        INC_PC(sizeof(mrs_inst));
+    cpu->Reg[15] += cpu->GetInstructionSize();
-        FETCH_INST;
+    INC_PC(sizeof(mrs_inst));
-        GOTO_NEXT_INST;
+    FETCH_INST;
-    }
+    GOTO_NEXT_INST;
-    MSR_INST:
+}
-    {
+MSR_INST : {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            msr_inst* inst_cream = (msr_inst*)inst_base->component;
+        msr_inst* inst_cream = (msr_inst*)inst_base->component;
-            const u32 UserMask = 0xf80f0200, PrivMask = 0x000001df, StateMask = 0x01000020;
+        const u32 UserMask = 0xf80f0200, PrivMask = 0x000001df, StateMask = 0x01000020;
-            unsigned int inst = inst_cream->inst;
+        unsigned int inst = inst_cream->inst;
-            unsigned int operand;
+        unsigned int operand;
-            if (BIT(inst, 25)) {
+        if (BIT(inst, 25)) {
-                int rot_imm = BITS(inst, 8, 11) * 2;
+            int rot_imm = BITS(inst, 8, 11) * 2;
-                operand = ROTATE_RIGHT_32(BITS(inst, 0, 7), rot_imm);
+            operand = ROTATE_RIGHT_32(BITS(inst, 0, 7), rot_imm);
+        } else {
+            operand = cpu->Reg[BITS(inst, 0, 3)];
+        }
+        u32 byte_mask = (BIT(inst, 16) ? 0xff : 0) | (BIT(inst, 17) ? 0xff00 : 0) |
+                        (BIT(inst, 18) ? 0xff0000 : 0) | (BIT(inst, 19) ? 0xff000000 : 0);
+        u32 mask = 0;
+        if (!inst_cream->R) {
+            if (cpu->InAPrivilegedMode()) {
+                if ((operand & StateMask) != 0) {
+                    /// UNPREDICTABLE
+                    DEBUG_MSG;
+                } else
+                    mask = byte_mask & (UserMask | PrivMask);
            } else {
-                operand = cpu->Reg[BITS(inst, 0, 3)];
+                mask = byte_mask & UserMask;
            }
-            u32 byte_mask = (BIT(inst, 16) ? 0xff : 0) | (BIT(inst, 17) ? 0xff00 : 0)
+            SAVE_NZCVT;
-                        | (BIT(inst, 18) ? 0xff0000 : 0) | (BIT(inst, 19) ? 0xff000000 : 0);
-            u32 mask = 0;
-            if (!inst_cream->R) {
-                if (cpu->InAPrivilegedMode()) {
-                    if ((operand & StateMask) != 0) {
-                        /// UNPREDICTABLE
-                        DEBUG_MSG;
-                    } else
-                        mask = byte_mask & (UserMask | PrivMask);
-                } else {
-                    mask = byte_mask & UserMask;
-                }
-                SAVE_NZCVT;
-                cpu->Cpsr = (cpu->Cpsr & ~mask) | (operand & mask);
+            cpu->Cpsr = (cpu->Cpsr & ~mask) | (operand & mask);
-                cpu->ChangePrivilegeMode(cpu->Cpsr & 0x1F);
+            cpu->ChangePrivilegeMode(cpu->Cpsr & 0x1F);
-                LOAD_NZCVT;
+            LOAD_NZCVT;
-            } else {
+        } else {
-                if (CurrentModeHasSPSR) {
+            if (CurrentModeHasSPSR) {
-                    mask = byte_mask & (UserMask | PrivMask | StateMask);
+                mask = byte_mask & (UserMask | PrivMask | StateMask);
-                    cpu->Spsr_copy = (cpu->Spsr_copy & ~mask) | (operand & mask);
+                cpu->Spsr_copy = (cpu->Spsr_copy & ~mask) | (operand & mask);
-                }
            }
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+    }
-        INC_PC(sizeof(msr_inst));
+    cpu->Reg[15] += cpu->GetInstructionSize();
-        FETCH_INST;
+    INC_PC(sizeof(msr_inst));
-        GOTO_NEXT_INST;
+    FETCH_INST;
-    }
+    GOTO_NEXT_INST;
-    MUL_INST:
+}
-    {
+MUL_INST : {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            mul_inst* inst_cream = (mul_inst*)inst_base->component;
+        mul_inst* inst_cream = (mul_inst*)inst_base->component;
-            u64 rm = RM;
+        u64 rm = RM;
-            u64 rs = RS;
+        u64 rs = RS;
-            RD = static_cast<u32>((rm * rs) & 0xffffffff);
+        RD = static_cast<u32>((rm * rs) & 0xffffffff);
-            if (inst_cream->S) {
+        if (inst_cream->S) {
-                UPDATE_NFLAG(RD);
+            UPDATE_NFLAG(RD);
-                UPDATE_ZFLAG(RD);
+            UPDATE_ZFLAG(RD);
-            }
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+    }
-        INC_PC(sizeof(mul_inst));
+    cpu->Reg[15] += cpu->GetInstructionSize();
-        FETCH_INST;
+    INC_PC(sizeof(mul_inst));
-        GOTO_NEXT_INST;
+    FETCH_INST;
-    }
+    GOTO_NEXT_INST;
-    MVN_INST:
+}
-    {
+MVN_INST : {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            mvn_inst* const inst_cream = (mvn_inst*)inst_base->component;
+        mvn_inst* const inst_cream = (mvn_inst*)inst_base->component;
-            RD = ~SHIFTER_OPERAND;
+        RD = ~SHIFTER_OPERAND;
-            if (inst_cream->S && (inst_cream->Rd == 15)) {
+        if (inst_cream->S && (inst_cream->Rd == 15)) {
-                if (CurrentModeHasSPSR) {
+            if (CurrentModeHasSPSR) {
-                    cpu->Cpsr = cpu->Spsr_copy;
+                cpu->Cpsr = cpu->Spsr_copy;
-                    cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
+                cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
-                    LOAD_NZCVT;
+                LOAD_NZCVT;
-                }
-            } else if (inst_cream->S) {
-                UPDATE_NFLAG(RD);
-                UPDATE_ZFLAG(RD);
-                UPDATE_CFLAG_WITH_SC;
-            }
-            if (inst_cream->Rd == 15) {
-                INC_PC(sizeof(mvn_inst));
-                goto DISPATCH;
            }
+        } else if (inst_cream->S) {
+            UPDATE_NFLAG(RD);
+            UPDATE_ZFLAG(RD);
+            UPDATE_CFLAG_WITH_SC;
+        }
+        if (inst_cream->Rd == 15) {
+            INC_PC(sizeof(mvn_inst));
+            goto DISPATCH;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(mvn_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    ORR_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(mvn_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            orr_inst* const inst_cream = (orr_inst*)inst_base->component;
+    GOTO_NEXT_INST;
+}
+ORR_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        orr_inst* const inst_cream = (orr_inst*)inst_base->component;
-            u32 lop = RN;
+        u32 lop = RN;
-            u32 rop = SHIFTER_OPERAND;
+        u32 rop = SHIFTER_OPERAND;
-            if (inst_cream->Rn == 15)
+        if (inst_cream->Rn == 15)
-                lop += 2 * cpu->GetInstructionSize();
+            lop += 2 * cpu->GetInstructionSize();
-            RD = lop | rop;
+        RD = lop | rop;
-            if (inst_cream->S && (inst_cream->Rd == 15)) {
+        if (inst_cream->S && (inst_cream->Rd == 15)) {
-                if (CurrentModeHasSPSR) {
+            if (CurrentModeHasSPSR) {
-                    cpu->Cpsr = cpu->Spsr_copy;
+                cpu->Cpsr = cpu->Spsr_copy;
-                    cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
+                cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
-                    LOAD_NZCVT;
+                LOAD_NZCVT;
-                }
-            } else if (inst_cream->S) {
-                UPDATE_NFLAG(RD);
-                UPDATE_ZFLAG(RD);
-                UPDATE_CFLAG_WITH_SC;
-            }
-            if (inst_cream->Rd == 15) {
-                INC_PC(sizeof(orr_inst));
-                goto DISPATCH;
            }
+        } else if (inst_cream->S) {
+            UPDATE_NFLAG(RD);
+            UPDATE_ZFLAG(RD);
+            UPDATE_CFLAG_WITH_SC;
+        }
+        if (inst_cream->Rd == 15) {
+            INC_PC(sizeof(orr_inst));
+            goto DISPATCH;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(orr_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(orr_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+NOP_INST : {
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC_STUB;
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
-    NOP_INST:
+PKHBT_INST : {
-    {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        pkh_inst* inst_cream = (pkh_inst*)inst_base->component;
-        INC_PC_STUB;
+        RD = (RN & 0xFFFF) | ((RM << inst_cream->imm) & 0xFFFF0000);
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(pkh_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
-    PKHBT_INST:
+PKHTB_INST : {
-    {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        pkh_inst* inst_cream = (pkh_inst*)inst_base->component;
-            pkh_inst *inst_cream = (pkh_inst *)inst_base->component;
+        int shift_imm = inst_cream->imm ? inst_cream->imm : 31;
-            RD = (RN & 0xFFFF) | ((RM << inst_cream->imm) & 0xFFFF0000);
+        RD = ((static_cast<s32>(RM) >> shift_imm) & 0xFFFF) | (RN & 0xFFFF0000);
-        }
+    }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+    cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(pkh_inst));
+    INC_PC(sizeof(pkh_inst));
-        FETCH_INST;
+    FETCH_INST;
-        GOTO_NEXT_INST;
+    GOTO_NEXT_INST;
-    }
+}
-    PKHTB_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            pkh_inst *inst_cream = (pkh_inst *)inst_base->component;
-            int shift_imm = inst_cream->imm ? inst_cream->imm : 31;
-            RD = ((static_cast<s32>(RM) >> shift_imm) & 0xFFFF) | (RN & 0xFFFF0000);
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(pkh_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    PLD_INST:
-    {
-        // Not implemented. PLD is a hint instruction, so it's optional.
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(pld_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    QADD_INST:
-    QDADD_INST:
-    QDSUB_INST:
-    QSUB_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
-            const u8 op1 = inst_cream->op1;
-            const u32 rm_val = RM;
-            const u32 rn_val = RN;
-            u32 result = 0;
+PLD_INST : {
+    // Not implemented. PLD is a hint instruction, so it's optional.
-            // QADD
+    cpu->Reg[15] += cpu->GetInstructionSize();
-            if (op1 == 0x00) {
+    INC_PC(sizeof(pld_inst));
-                result = rm_val + rn_val;
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
-                if (AddOverflow(rm_val, rn_val, result)) {
+QADD_INST:
-                    result = POS(result) ? 0x80000000 : 0x7FFFFFFF;
+QDADD_INST:
-                    cpu->Cpsr |= (1 << 27);
+QDSUB_INST:
-                }
+QSUB_INST : {
-            }
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            // QSUB
+        generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
-            else if (op1 == 0x01) {
+        const u8 op1 = inst_cream->op1;
-                result = rm_val - rn_val;
+        const u32 rm_val = RM;
+        const u32 rn_val = RN;
-                if (SubOverflow(rm_val, rn_val, result)) {
+        u32 result = 0;
-                    result = POS(result) ? 0x80000000 : 0x7FFFFFFF;
-                    cpu->Cpsr |= (1 << 27);
-                }
-            }
-            // QDADD
-            else if (op1 == 0x02) {
-                u32 mul = (rn_val * 2);
-                if (AddOverflow(rn_val, rn_val, rn_val * 2)) {
+        // QADD
-                    mul = POS(mul) ? 0x80000000 : 0x7FFFFFFF;
+        if (op1 == 0x00) {
-                    cpu->Cpsr |= (1 << 27);
+            result = rm_val + rn_val;
-                }
-                result = mul + rm_val;
+            if (AddOverflow(rm_val, rn_val, result)) {
+                result = POS(result) ? 0x80000000 : 0x7FFFFFFF;
+                cpu->Cpsr |= (1 << 27);
+            }
+        }
+        // QSUB
+        else if (op1 == 0x01) {
+            result = rm_val - rn_val;
-                if (AddOverflow(rm_val, mul, result)) {
+            if (SubOverflow(rm_val, rn_val, result)) {
-                    result = POS(result) ? 0x80000000 : 0x7FFFFFFF;
+                result = POS(result) ? 0x80000000 : 0x7FFFFFFF;
-                    cpu->Cpsr |= (1 << 27);
+                cpu->Cpsr |= (1 << 27);
-                }
            }
-            // QDSUB
+        }
-            else if (op1 == 0x03) {
+        // QDADD
-                u32 mul = (rn_val * 2);
+        else if (op1 == 0x02) {
+            u32 mul = (rn_val * 2);
-                if (AddOverflow(rn_val, rn_val, mul)) {
+            if (AddOverflow(rn_val, rn_val, rn_val * 2)) {
-                    mul = POS(mul) ? 0x80000000 : 0x7FFFFFFF;
+                mul = POS(mul) ? 0x80000000 : 0x7FFFFFFF;
-                    cpu->Cpsr |= (1 << 27);
+                cpu->Cpsr |= (1 << 27);
-                }
+            }
-                result = rm_val - mul;
+            result = mul + rm_val;
-                if (SubOverflow(rm_val, mul, result)) {
+            if (AddOverflow(rm_val, mul, result)) {
-                    result = POS(result) ? 0x80000000 : 0x7FFFFFFF;
+                result = POS(result) ? 0x80000000 : 0x7FFFFFFF;
-                    cpu->Cpsr |= (1 << 27);
+                cpu->Cpsr |= (1 << 27);
-                }
            }
-            RD = result;
        }
+        // QDSUB
+        else if (op1 == 0x03) {
+            u32 mul = (rn_val * 2);
-        cpu->Reg[15] += cpu->GetInstructionSize();
+            if (AddOverflow(rn_val, rn_val, mul)) {
-        INC_PC(sizeof(generic_arm_inst));
+                mul = POS(mul) ? 0x80000000 : 0x7FFFFFFF;
-        FETCH_INST;
+                cpu->Cpsr |= (1 << 27);
-        GOTO_NEXT_INST;
-    }
-    QADD8_INST:
-    QADD16_INST:
-    QADDSUBX_INST:
-    QSUB8_INST:
-    QSUB16_INST:
-    QSUBADDX_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
-            const u16 rm_lo = (RM & 0xFFFF);
-            const u16 rm_hi = ((RM >> 16) & 0xFFFF);
-            const u16 rn_lo = (RN & 0xFFFF);
-            const u16 rn_hi = ((RN >> 16) & 0xFFFF);
-            const u8 op2    = inst_cream->op2;
-            u16 lo_result = 0;
-            u16 hi_result = 0;
-            // QADD16
-            if (op2 == 0x00) {
-                lo_result = ARMul_SignedSaturatedAdd16(rn_lo, rm_lo);
-                hi_result = ARMul_SignedSaturatedAdd16(rn_hi, rm_hi);
-            }
-            // QASX
-            else if (op2 == 0x01) {
-                lo_result = ARMul_SignedSaturatedSub16(rn_lo, rm_hi);
-                hi_result = ARMul_SignedSaturatedAdd16(rn_hi, rm_lo);
-            }
-            // QSAX
-            else if (op2 == 0x02) {
-                lo_result = ARMul_SignedSaturatedAdd16(rn_lo, rm_hi);
-                hi_result = ARMul_SignedSaturatedSub16(rn_hi, rm_lo);
-            }
-            // QSUB16
-            else if (op2 == 0x03) {
-                lo_result = ARMul_SignedSaturatedSub16(rn_lo, rm_lo);
-                hi_result = ARMul_SignedSaturatedSub16(rn_hi, rm_hi);
-            }
-            // QADD8
-            else if (op2 == 0x04) {
-                lo_result = ARMul_SignedSaturatedAdd8(rn_lo & 0xFF, rm_lo & 0xFF) |
-                            ARMul_SignedSaturatedAdd8(rn_lo >> 8, rm_lo >> 8) << 8;
-                hi_result = ARMul_SignedSaturatedAdd8(rn_hi & 0xFF, rm_hi & 0xFF) |
-                            ARMul_SignedSaturatedAdd8(rn_hi >> 8, rm_hi >> 8) << 8;
            }
-            // QSUB8
-            else if (op2 == 0x07) {
+            result = rm_val - mul;
-                lo_result = ARMul_SignedSaturatedSub8(rn_lo & 0xFF, rm_lo & 0xFF) |
-                            ARMul_SignedSaturatedSub8(rn_lo >> 8, rm_lo >> 8) << 8;
+            if (SubOverflow(rm_val, mul, result)) {
-                hi_result = ARMul_SignedSaturatedSub8(rn_hi & 0xFF, rm_hi & 0xFF) |
+                result = POS(result) ? 0x80000000 : 0x7FFFFFFF;
-                            ARMul_SignedSaturatedSub8(rn_hi >> 8, rm_hi >> 8) << 8;
+                cpu->Cpsr |= (1 << 27);
            }
+        }
-            RD = (lo_result & 0xFFFF) | ((hi_result & 0xFFFF) << 16);
+        RD = result;
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(generic_arm_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+QADD8_INST:
+QADD16_INST:
+QADDSUBX_INST:
+QSUB8_INST:
+QSUB16_INST:
+QSUBADDX_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
+        const u16 rm_lo = (RM & 0xFFFF);
+        const u16 rm_hi = ((RM >> 16) & 0xFFFF);
+        const u16 rn_lo = (RN & 0xFFFF);
+        const u16 rn_hi = ((RN >> 16) & 0xFFFF);
+        const u8 op2 = inst_cream->op2;
+        u16 lo_result = 0;
+        u16 hi_result = 0;
+        // QADD16
+        if (op2 == 0x00) {
+            lo_result = ARMul_SignedSaturatedAdd16(rn_lo, rm_lo);
+            hi_result = ARMul_SignedSaturatedAdd16(rn_hi, rm_hi);
+        }
+        // QASX
+        else if (op2 == 0x01) {
+            lo_result = ARMul_SignedSaturatedSub16(rn_lo, rm_hi);
+            hi_result = ARMul_SignedSaturatedAdd16(rn_hi, rm_lo);
+        }
+        // QSAX
+        else if (op2 == 0x02) {
+            lo_result = ARMul_SignedSaturatedAdd16(rn_lo, rm_hi);
+            hi_result = ARMul_SignedSaturatedSub16(rn_hi, rm_lo);
+        }
+        // QSUB16
+        else if (op2 == 0x03) {
+            lo_result = ARMul_SignedSaturatedSub16(rn_lo, rm_lo);
+            hi_result = ARMul_SignedSaturatedSub16(rn_hi, rm_hi);
+        }
+        // QADD8
+        else if (op2 == 0x04) {
+            lo_result = ARMul_SignedSaturatedAdd8(rn_lo & 0xFF, rm_lo & 0xFF) |
+                        ARMul_SignedSaturatedAdd8(rn_lo >> 8, rm_lo >> 8) << 8;
+            hi_result = ARMul_SignedSaturatedAdd8(rn_hi & 0xFF, rm_hi & 0xFF) |
+                        ARMul_SignedSaturatedAdd8(rn_hi >> 8, rm_hi >> 8) << 8;
+        }
+        // QSUB8
+        else if (op2 == 0x07) {
+            lo_result = ARMul_SignedSaturatedSub8(rn_lo & 0xFF, rm_lo & 0xFF) |
+                        ARMul_SignedSaturatedSub8(rn_lo >> 8, rm_lo >> 8) << 8;
+            hi_result = ARMul_SignedSaturatedSub8(rn_hi & 0xFF, rm_hi & 0xFF) |
+                        ARMul_SignedSaturatedSub8(rn_hi >> 8, rm_hi >> 8) << 8;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        RD = (lo_result & 0xFFFF) | ((hi_result & 0xFFFF) << 16);
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    REV_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    REV16_INST:
+    INC_PC(sizeof(generic_arm_inst));
-    REVSH_INST:
+    FETCH_INST;
-    {
+    GOTO_NEXT_INST;
+}
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+REV_INST:
-            rev_inst* const inst_cream = (rev_inst*)inst_base->component;
+REV16_INST:
+REVSH_INST : {
-            const u8 op1 = inst_cream->op1;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            const u8 op2 = inst_cream->op2;
+        rev_inst* const inst_cream = (rev_inst*)inst_base->component;
-            // REV
+        const u8 op1 = inst_cream->op1;
-            if (op1 == 0x03 && op2 == 0x01) {
+        const u8 op2 = inst_cream->op2;
-                RD = ((RM & 0xFF) << 24) | (((RM >> 8) & 0xFF) << 16) | (((RM >> 16) & 0xFF) << 8) | ((RM >> 24) & 0xFF);
-            }
-            // REV16
-            else if (op1 == 0x03 && op2 == 0x05) {
-                RD = ((RM & 0xFF) << 8) | ((RM & 0xFF00) >> 8) | ((RM & 0xFF0000) << 8) | ((RM & 0xFF000000) >> 8);
-            }
-            // REVSH
-            else if (op1 == 0x07 && op2 == 0x05) {
-                RD = ((RM & 0xFF) << 8) | ((RM & 0xFF00) >> 8);
-                if (RD & 0x8000)
-                    RD |= 0xffff0000;
-            }
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        // REV
-        INC_PC(sizeof(rev_inst));
+        if (op1 == 0x03 && op2 == 0x01) {
-        FETCH_INST;
+            RD = ((RM & 0xFF) << 24) | (((RM >> 8) & 0xFF) << 16) | (((RM >> 16) & 0xFF) << 8) |
-        GOTO_NEXT_INST;
+                 ((RM >> 24) & 0xFF);
+        }
+        // REV16
+        else if (op1 == 0x03 && op2 == 0x05) {
+            RD = ((RM & 0xFF) << 8) | ((RM & 0xFF00) >> 8) | ((RM & 0xFF0000) << 8) |
+                 ((RM & 0xFF000000) >> 8);
+        }
+        // REVSH
+        else if (op1 == 0x07 && op2 == 0x05) {
+            RD = ((RM & 0xFF) << 8) | ((RM & 0xFF00) >> 8);
+            if (RD & 0x8000)
+                RD |= 0xffff0000;
+        }
    }
-    RFE_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(rev_inst));
-        // RFE is unconditional
+    FETCH_INST;
-        ldst_inst* const inst_cream = (ldst_inst*)inst_base->component;
+    GOTO_NEXT_INST;
+}
-        u32 address = 0;
+RFE_INST : {
-        inst_cream->get_addr(cpu, inst_cream->inst, address);
+    // RFE is unconditional
+    ldst_inst* const inst_cream = (ldst_inst*)inst_base->component;
-        cpu->Cpsr    = cpu->ReadMemory32(address);
+    u32 address = 0;
-        cpu->Reg[15] = cpu->ReadMemory32(address + 4);
+    inst_cream->get_addr(cpu, inst_cream->inst, address);
-        INC_PC(sizeof(ldst_inst));
+    cpu->Cpsr = cpu->ReadMemory32(address);
-        goto DISPATCH;
+    cpu->Reg[15] = cpu->ReadMemory32(address + 4);
-    }
-    RSB_INST:
+    INC_PC(sizeof(ldst_inst));
-    {
+    goto DISPATCH;
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+}
-            rsb_inst* const inst_cream = (rsb_inst*)inst_base->component;
-            u32 rn_val = RN;
+RSB_INST : {
-            if (inst_cream->Rn == 15)
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-                rn_val += 2 * cpu->GetInstructionSize();
+        rsb_inst* const inst_cream = (rsb_inst*)inst_base->component;
-            bool carry;
+        u32 rn_val = RN;
-            bool overflow;
+        if (inst_cream->Rn == 15)
-            RD = AddWithCarry(~rn_val, SHIFTER_OPERAND, 1, &carry, &overflow);
+            rn_val += 2 * cpu->GetInstructionSize();
-            if (inst_cream->S && (inst_cream->Rd == 15)) {
+        bool carry;
-                if (CurrentModeHasSPSR) {
+        bool overflow;
-                    cpu->Cpsr = cpu->Spsr_copy;
+        RD = AddWithCarry(~rn_val, SHIFTER_OPERAND, 1, &carry, &overflow);
-                    cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
-                    LOAD_NZCVT;
+        if (inst_cream->S && (inst_cream->Rd == 15)) {
-                }
+            if (CurrentModeHasSPSR) {
-            } else if (inst_cream->S) {
+                cpu->Cpsr = cpu->Spsr_copy;
-                UPDATE_NFLAG(RD);
+                cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
-                UPDATE_ZFLAG(RD);
+                LOAD_NZCVT;
-                cpu->CFlag = carry;
-                cpu->VFlag = overflow;
            }
-            if (inst_cream->Rd == 15) {
+        } else if (inst_cream->S) {
-                INC_PC(sizeof(rsb_inst));
+            UPDATE_NFLAG(RD);
-                goto DISPATCH;
+            UPDATE_ZFLAG(RD);
+            cpu->CFlag = carry;
+            cpu->VFlag = overflow;
+        }
+        if (inst_cream->Rd == 15) {
+            INC_PC(sizeof(rsb_inst));
+            goto DISPATCH;
+        }
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(rsb_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+RSC_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        rsc_inst* const inst_cream = (rsc_inst*)inst_base->component;
+        u32 rn_val = RN;
+        if (inst_cream->Rn == 15)
+            rn_val += 2 * cpu->GetInstructionSize();
+        bool carry;
+        bool overflow;
+        RD = AddWithCarry(~rn_val, SHIFTER_OPERAND, cpu->CFlag, &carry, &overflow);
+        if (inst_cream->S && (inst_cream->Rd == 15)) {
+            if (CurrentModeHasSPSR) {
+                cpu->Cpsr = cpu->Spsr_copy;
+                cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
+                LOAD_NZCVT;
            }
+        } else if (inst_cream->S) {
+            UPDATE_NFLAG(RD);
+            UPDATE_ZFLAG(RD);
+            cpu->CFlag = carry;
+            cpu->VFlag = overflow;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        if (inst_cream->Rd == 15) {
-        INC_PC(sizeof(rsb_inst));
+            INC_PC(sizeof(rsc_inst));
-        FETCH_INST;
+            goto DISPATCH;
-        GOTO_NEXT_INST;
+        }
-    }
+    }
-    RSC_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(rsc_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            rsc_inst* const inst_cream = (rsc_inst*)inst_base->component;
+    GOTO_NEXT_INST;
+}
-            u32 rn_val = RN;
-            if (inst_cream->Rn == 15)
+SADD8_INST:
-                rn_val += 2 * cpu->GetInstructionSize();
+SSUB8_INST:
+SADD16_INST:
-            bool carry;
+SADDSUBX_INST:
-            bool overflow;
+SSUBADDX_INST:
-            RD = AddWithCarry(~rn_val, SHIFTER_OPERAND, cpu->CFlag, &carry, &overflow);
+SSUB16_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            if (inst_cream->S && (inst_cream->Rd == 15)) {
+        generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
-                if (CurrentModeHasSPSR) {
+        const u8 op2 = inst_cream->op2;
-                    cpu->Cpsr = cpu->Spsr_copy;
-                    cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
+        if (op2 == 0x00 || op2 == 0x01 || op2 == 0x02 || op2 == 0x03) {
-                    LOAD_NZCVT;
+            const s16 rn_lo = (RN & 0xFFFF);
-                }
+            const s16 rn_hi = ((RN >> 16) & 0xFFFF);
-            } else if (inst_cream->S) {
+            const s16 rm_lo = (RM & 0xFFFF);
-                UPDATE_NFLAG(RD);
+            const s16 rm_hi = ((RM >> 16) & 0xFFFF);
-                UPDATE_ZFLAG(RD);
-                cpu->CFlag = carry;
+            s32 lo_result = 0;
-                cpu->VFlag = overflow;
+            s32 hi_result = 0;
+            // SADD16
+            if (inst_cream->op2 == 0x00) {
+                lo_result = (rn_lo + rm_lo);
+                hi_result = (rn_hi + rm_hi);
            }
-            if (inst_cream->Rd == 15) {
+            // SASX
-                INC_PC(sizeof(rsc_inst));
+            else if (op2 == 0x01) {
-                goto DISPATCH;
+                lo_result = (rn_lo - rm_hi);
+                hi_result = (rn_hi + rm_lo);
+            }
+            // SSAX
+            else if (op2 == 0x02) {
+                lo_result = (rn_lo + rm_hi);
+                hi_result = (rn_hi - rm_lo);
+            }
+            // SSUB16
+            else if (op2 == 0x03) {
+                lo_result = (rn_lo - rm_lo);
+                hi_result = (rn_hi - rm_hi);
            }
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(rsc_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    SADD8_INST:
-    SSUB8_INST:
-    SADD16_INST:
-    SADDSUBX_INST:
-    SSUBADDX_INST:
-    SSUB16_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
-            const u8 op2 = inst_cream->op2;
-            if (op2 == 0x00 || op2 == 0x01 || op2 == 0x02 || op2 == 0x03) {
-                const s16 rn_lo = (RN & 0xFFFF);
-                const s16 rn_hi = ((RN >> 16) & 0xFFFF);
-                const s16 rm_lo = (RM & 0xFFFF);
-                const s16 rm_hi = ((RM >> 16) & 0xFFFF);
-                s32 lo_result = 0;
-                s32 hi_result = 0;
-                // SADD16
-                if (inst_cream->op2 == 0x00) {
-                    lo_result = (rn_lo + rm_lo);
-                    hi_result = (rn_hi + rm_hi);
-                }
-                // SASX
-                else if (op2 == 0x01) {
-                    lo_result = (rn_lo - rm_hi);
-                    hi_result = (rn_hi + rm_lo);
-                }
-                // SSAX
-                else if (op2 == 0x02) {
-                    lo_result = (rn_lo + rm_hi);
-                    hi_result = (rn_hi - rm_lo);
-                }
-                // SSUB16
-                else if (op2 == 0x03) {
-                    lo_result = (rn_lo - rm_lo);
-                    hi_result = (rn_hi - rm_hi);
-                }
-                RD = (lo_result & 0xFFFF) | ((hi_result & 0xFFFF) << 16);
+            RD = (lo_result & 0xFFFF) | ((hi_result & 0xFFFF) << 16);
-                if (lo_result >= 0) {
+            if (lo_result >= 0) {
-                    cpu->Cpsr |= (1 << 16);
+                cpu->Cpsr |= (1 << 16);
-                    cpu->Cpsr |= (1 << 17);
+                cpu->Cpsr |= (1 << 17);
-                } else {
+            } else {
-                    cpu->Cpsr &= ~(1 << 16);
+                cpu->Cpsr &= ~(1 << 16);
-                    cpu->Cpsr &= ~(1 << 17);
+                cpu->Cpsr &= ~(1 << 17);
-                }
+            }
-                if (hi_result >= 0) {
+            if (hi_result >= 0) {
-                    cpu->Cpsr |= (1 << 18);
+                cpu->Cpsr |= (1 << 18);
-                    cpu->Cpsr |= (1 << 19);
+                cpu->Cpsr |= (1 << 19);
-                } else {
+            } else {
-                    cpu->Cpsr &= ~(1 << 18);
+                cpu->Cpsr &= ~(1 << 18);
-                    cpu->Cpsr &= ~(1 << 19);
+                cpu->Cpsr &= ~(1 << 19);
-                }
+            }
+        } else if (op2 == 0x04 || op2 == 0x07) {
+            s32 lo_val1, lo_val2;
+            s32 hi_val1, hi_val2;
+            // SADD8
+            if (op2 == 0x04) {
+                lo_val1 = (s32)(s8)(RN & 0xFF) + (s32)(s8)(RM & 0xFF);
+                lo_val2 = (s32)(s8)((RN >> 8) & 0xFF) + (s32)(s8)((RM >> 8) & 0xFF);
+                hi_val1 = (s32)(s8)((RN >> 16) & 0xFF) + (s32)(s8)((RM >> 16) & 0xFF);
+                hi_val2 = (s32)(s8)((RN >> 24) & 0xFF) + (s32)(s8)((RM >> 24) & 0xFF);
+            }
+            // SSUB8
+            else {
+                lo_val1 = (s32)(s8)(RN & 0xFF) - (s32)(s8)(RM & 0xFF);
+                lo_val2 = (s32)(s8)((RN >> 8) & 0xFF) - (s32)(s8)((RM >> 8) & 0xFF);
+                hi_val1 = (s32)(s8)((RN >> 16) & 0xFF) - (s32)(s8)((RM >> 16) & 0xFF);
+                hi_val2 = (s32)(s8)((RN >> 24) & 0xFF) - (s32)(s8)((RM >> 24) & 0xFF);
            }
-            else if (op2 == 0x04 || op2 == 0x07) {
-                s32 lo_val1, lo_val2;
-                s32 hi_val1, hi_val2;
-                // SADD8
-                if (op2 == 0x04) {
-                    lo_val1 = (s32)(s8)(RN & 0xFF) + (s32)(s8)(RM & 0xFF);
-                    lo_val2 = (s32)(s8)((RN >> 8) & 0xFF)  + (s32)(s8)((RM >> 8) & 0xFF);
-                    hi_val1 = (s32)(s8)((RN >> 16) & 0xFF) + (s32)(s8)((RM >> 16) & 0xFF);
-                    hi_val2 = (s32)(s8)((RN >> 24) & 0xFF) + (s32)(s8)((RM >> 24) & 0xFF);
-                }
-                // SSUB8
-                else {
-                    lo_val1 = (s32)(s8)(RN & 0xFF) - (s32)(s8)(RM & 0xFF);
-                    lo_val2 = (s32)(s8)((RN >> 8) & 0xFF) - (s32)(s8)((RM >> 8) & 0xFF);
-                    hi_val1 = (s32)(s8)((RN >> 16) & 0xFF) - (s32)(s8)((RM >> 16) & 0xFF);
-                    hi_val2 = (s32)(s8)((RN >> 24) & 0xFF) - (s32)(s8)((RM >> 24) & 0xFF);
-                }
-                RD =  ((lo_val1 & 0xFF) | ((lo_val2 & 0xFF) << 8) | ((hi_val1 & 0xFF) << 16) | ((hi_val2 & 0xFF) << 24));
+            RD = ((lo_val1 & 0xFF) | ((lo_val2 & 0xFF) << 8) | ((hi_val1 & 0xFF) << 16) |
+                  ((hi_val2 & 0xFF) << 24));
-                if (lo_val1 >= 0)
+            if (lo_val1 >= 0)
-                    cpu->Cpsr |= (1 << 16);
+                cpu->Cpsr |= (1 << 16);
-                else
+            else
-                    cpu->Cpsr &= ~(1 << 16);
+                cpu->Cpsr &= ~(1 << 16);
-                if (lo_val2 >= 0)
+            if (lo_val2 >= 0)
-                    cpu->Cpsr |= (1 << 17);
+                cpu->Cpsr |= (1 << 17);
-                else
+            else
-                    cpu->Cpsr &= ~(1 << 17);
+                cpu->Cpsr &= ~(1 << 17);
-                if (hi_val1 >= 0)
+            if (hi_val1 >= 0)
-                    cpu->Cpsr |= (1 << 18);
+                cpu->Cpsr |= (1 << 18);
-                else
+            else
-                    cpu->Cpsr &= ~(1 << 18);
+                cpu->Cpsr &= ~(1 << 18);
-                if (hi_val2 >= 0)
+            if (hi_val2 >= 0)
-                    cpu->Cpsr |= (1 << 19);
+                cpu->Cpsr |= (1 << 19);
-                else
+            else
-                    cpu->Cpsr &= ~(1 << 19);
+                cpu->Cpsr &= ~(1 << 19);
-            }
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    SBC_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(generic_arm_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            sbc_inst* const inst_cream = (sbc_inst*)inst_base->component;
+    GOTO_NEXT_INST;
+}
-            u32 rn_val = RN;
+SBC_INST : {
-            if (inst_cream->Rn == 15)
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-                rn_val += 2 * cpu->GetInstructionSize();
+        sbc_inst* const inst_cream = (sbc_inst*)inst_base->component;
-            bool carry;
+        u32 rn_val = RN;
-            bool overflow;
+        if (inst_cream->Rn == 15)
-            RD = AddWithCarry(rn_val, ~SHIFTER_OPERAND, cpu->CFlag, &carry, &overflow);
+            rn_val += 2 * cpu->GetInstructionSize();
-            if (inst_cream->S && (inst_cream->Rd == 15)) {
+        bool carry;
-                if (CurrentModeHasSPSR) {
+        bool overflow;
-                    cpu->Cpsr = cpu->Spsr_copy;
+        RD = AddWithCarry(rn_val, ~SHIFTER_OPERAND, cpu->CFlag, &carry, &overflow);
-                    cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
-                    LOAD_NZCVT;
+        if (inst_cream->S && (inst_cream->Rd == 15)) {
-                }
+            if (CurrentModeHasSPSR) {
-            } else if (inst_cream->S) {
+                cpu->Cpsr = cpu->Spsr_copy;
-                UPDATE_NFLAG(RD);
+                cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
-                UPDATE_ZFLAG(RD);
+                LOAD_NZCVT;
-                cpu->CFlag = carry;
-                cpu->VFlag = overflow;
-            }
-            if (inst_cream->Rd == 15) {
-                INC_PC(sizeof(sbc_inst));
-                goto DISPATCH;
            }
+        } else if (inst_cream->S) {
+            UPDATE_NFLAG(RD);
+            UPDATE_ZFLAG(RD);
+            cpu->CFlag = carry;
+            cpu->VFlag = overflow;
+        }
+        if (inst_cream->Rd == 15) {
+            INC_PC(sizeof(sbc_inst));
+            goto DISPATCH;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(sbc_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(sbc_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
-    SEL_INST:
+SEL_INST : {
-    {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
-            generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
-            const u32 to = RM;
-            const u32 from = RN;
-            const u32 cpsr = cpu->Cpsr;
-            u32 result;
+        const u32 to = RM;
-            if (cpsr & (1 << 16))
+        const u32 from = RN;
-                result = from & 0xff;
+        const u32 cpsr = cpu->Cpsr;
-            else
-                result = to & 0xff;
-            if (cpsr & (1 << 17))
+        u32 result;
-                result |= from & 0x0000ff00;
+        if (cpsr & (1 << 16))
-            else
+            result = from & 0xff;
-                result |= to & 0x0000ff00;
+        else
+            result = to & 0xff;
-            if (cpsr & (1 << 18))
+        if (cpsr & (1 << 17))
-                result |= from & 0x00ff0000;
+            result |= from & 0x0000ff00;
-            else
+        else
-                result |= to & 0x00ff0000;
+            result |= to & 0x0000ff00;
-            if (cpsr & (1 << 19))
+        if (cpsr & (1 << 18))
-                result |= from & 0xff000000;
+            result |= from & 0x00ff0000;
-            else
+        else
-                result |= to & 0xff000000;
+            result |= to & 0x00ff0000;
-            RD = result;
+        if (cpsr & (1 << 19))
-        }
+            result |= from & 0xff000000;
+        else
+            result |= to & 0xff000000;
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        RD = result;
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    SETEND_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(generic_arm_inst));
-        // SETEND is unconditional
+    FETCH_INST;
-        setend_inst* const inst_cream = (setend_inst*)inst_base->component;
+    GOTO_NEXT_INST;
-        const bool big_endian = (inst_cream->set_bigend == 1);
+}
-        if (big_endian)
+SETEND_INST : {
-            cpu->Cpsr |= (1 << 9);
+    // SETEND is unconditional
-        else
+    setend_inst* const inst_cream = (setend_inst*)inst_base->component;
-            cpu->Cpsr &= ~(1 << 9);
+    const bool big_endian = (inst_cream->set_bigend == 1);
-        LOG_WARNING(Core_ARM11, "SETEND %s executed", big_endian ? "BE" : "LE");
+    if (big_endian)
+        cpu->Cpsr |= (1 << 9);
+    else
+        cpu->Cpsr &= ~(1 << 9);
-        cpu->Reg[15] += cpu->GetInstructionSize();
+    LOG_WARNING(Core_ARM11, "SETEND %s executed", big_endian ? "BE" : "LE");
-        INC_PC(sizeof(setend_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    SEV_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(setend_inst));
-        // Stubbed, as SEV is a hint instruction.
+    FETCH_INST;
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    GOTO_NEXT_INST;
-            LOG_TRACE(Core_ARM11, "SEV executed.");
+}
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+SEV_INST : {
-        INC_PC_STUB;
+    // Stubbed, as SEV is a hint instruction.
-        FETCH_INST;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-        GOTO_NEXT_INST;
+        LOG_TRACE(Core_ARM11, "SEV executed.");
    }
-    SHADD8_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    SHADD16_INST:
+    INC_PC_STUB;
-    SHADDSUBX_INST:
+    FETCH_INST;
-    SHSUB8_INST:
+    GOTO_NEXT_INST;
-    SHSUB16_INST:
+}
-    SHSUBADDX_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
-            const u8 op2 = inst_cream->op2;
+SHADD8_INST:
-            const u32 rm_val = RM;
+SHADD16_INST:
-            const u32 rn_val = RN;
+SHADDSUBX_INST:
+SHSUB8_INST:
+SHSUB16_INST:
+SHSUBADDX_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
-            if (op2 == 0x00 || op2 == 0x01 || op2 == 0x02 || op2 == 0x03) {
+        const u8 op2 = inst_cream->op2;
-                s32 lo_result = 0;
+        const u32 rm_val = RM;
-                s32 hi_result = 0;
+        const u32 rn_val = RN;
-                // SHADD16
+        if (op2 == 0x00 || op2 == 0x01 || op2 == 0x02 || op2 == 0x03) {
-                if (op2 == 0x00) {
+            s32 lo_result = 0;
-                    lo_result = ((s16)(rn_val & 0xFFFF) + (s16)(rm_val & 0xFFFF)) >> 1;
+            s32 hi_result = 0;
-                    hi_result = ((s16)((rn_val >> 16) & 0xFFFF) + (s16)((rm_val >> 16) & 0xFFFF)) >> 1;
-                }
-                // SHASX
-                else if (op2 == 0x01) {
-                    lo_result = ((s16)(rn_val & 0xFFFF) - (s16)((rm_val >> 16) & 0xFFFF)) >> 1;
-                    hi_result = ((s16)((rn_val >> 16) & 0xFFFF) + (s16)(rm_val & 0xFFFF)) >> 1;
-                }
-                // SHSAX
-                else if (op2 == 0x02) {
-                    lo_result = ((s16)(rn_val & 0xFFFF) + (s16)((rm_val >> 16) & 0xFFFF)) >> 1;
-                    hi_result = ((s16)((rn_val >> 16) & 0xFFFF) - (s16)(rm_val & 0xFFFF)) >> 1;
-                }
-                // SHSUB16
-                else if (op2 == 0x03) {
-                    lo_result = ((s16)(rn_val & 0xFFFF) - (s16)(rm_val & 0xFFFF)) >> 1;
-                    hi_result = ((s16)((rn_val >> 16) & 0xFFFF) - (s16)((rm_val >> 16) & 0xFFFF)) >> 1;
-                }
-                RD = ((lo_result & 0xFFFF) | ((hi_result & 0xFFFF) << 16));
+            // SHADD16
+            if (op2 == 0x00) {
+                lo_result = ((s16)(rn_val & 0xFFFF) + (s16)(rm_val & 0xFFFF)) >> 1;
+                hi_result = ((s16)((rn_val >> 16) & 0xFFFF) + (s16)((rm_val >> 16) & 0xFFFF)) >> 1;
+            }
+            // SHASX
+            else if (op2 == 0x01) {
+                lo_result = ((s16)(rn_val & 0xFFFF) - (s16)((rm_val >> 16) & 0xFFFF)) >> 1;
+                hi_result = ((s16)((rn_val >> 16) & 0xFFFF) + (s16)(rm_val & 0xFFFF)) >> 1;
+            }
+            // SHSAX
+            else if (op2 == 0x02) {
+                lo_result = ((s16)(rn_val & 0xFFFF) + (s16)((rm_val >> 16) & 0xFFFF)) >> 1;
+                hi_result = ((s16)((rn_val >> 16) & 0xFFFF) - (s16)(rm_val & 0xFFFF)) >> 1;
+            }
+            // SHSUB16
+            else if (op2 == 0x03) {
+                lo_result = ((s16)(rn_val & 0xFFFF) - (s16)(rm_val & 0xFFFF)) >> 1;
+                hi_result = ((s16)((rn_val >> 16) & 0xFFFF) - (s16)((rm_val >> 16) & 0xFFFF)) >> 1;
            }
-            else if (op2 == 0x04 || op2 == 0x07) {
-                s16 lo_val1, lo_val2;
-                s16 hi_val1, hi_val2;
-                // SHADD8
+            RD = ((lo_result & 0xFFFF) | ((hi_result & 0xFFFF) << 16));
-                if (op2 == 0x04) {
+        } else if (op2 == 0x04 || op2 == 0x07) {
-                    lo_val1 = ((s8)(rn_val & 0xFF) + (s8)(rm_val & 0xFF)) >> 1;
+            s16 lo_val1, lo_val2;
-                    lo_val2 = ((s8)((rn_val >> 8) & 0xFF) + (s8)((rm_val >> 8) & 0xFF)) >> 1;
+            s16 hi_val1, hi_val2;
-                    hi_val1 = ((s8)((rn_val >> 16) & 0xFF) + (s8)((rm_val >> 16) & 0xFF)) >> 1;
+            // SHADD8
-                    hi_val2 = ((s8)((rn_val >> 24) & 0xFF) + (s8)((rm_val >> 24) & 0xFF)) >> 1;
+            if (op2 == 0x04) {
-                }
+                lo_val1 = ((s8)(rn_val & 0xFF) + (s8)(rm_val & 0xFF)) >> 1;
-                // SHSUB8
+                lo_val2 = ((s8)((rn_val >> 8) & 0xFF) + (s8)((rm_val >> 8) & 0xFF)) >> 1;
-                else {
-                    lo_val1 = ((s8)(rn_val & 0xFF) - (s8)(rm_val & 0xFF)) >> 1;
-                    lo_val2 = ((s8)((rn_val >> 8) & 0xFF) - (s8)((rm_val >> 8) & 0xFF)) >> 1;
-                    hi_val1 = ((s8)((rn_val >> 16) & 0xFF) - (s8)((rm_val >> 16) & 0xFF)) >> 1;
+                hi_val1 = ((s8)((rn_val >> 16) & 0xFF) + (s8)((rm_val >> 16) & 0xFF)) >> 1;
-                    hi_val2 = ((s8)((rn_val >> 24) & 0xFF) - (s8)((rm_val >> 24) & 0xFF)) >> 1;
+                hi_val2 = ((s8)((rn_val >> 24) & 0xFF) + (s8)((rm_val >> 24) & 0xFF)) >> 1;
-                }
-                RD = (lo_val1 & 0xFF) | ((lo_val2 & 0xFF) << 8) | ((hi_val1 & 0xFF) << 16) | ((hi_val2 & 0xFF) << 24);
            }
-        }
+            // SHSUB8
+            else {
-        cpu->Reg[15] += cpu->GetInstructionSize();
+                lo_val1 = ((s8)(rn_val & 0xFF) - (s8)(rm_val & 0xFF)) >> 1;
-        INC_PC(sizeof(generic_arm_inst));
+                lo_val2 = ((s8)((rn_val >> 8) & 0xFF) - (s8)((rm_val >> 8) & 0xFF)) >> 1;
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    SMLA_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            smla_inst* inst_cream = (smla_inst*)inst_base->component;
-            s32 operand1, operand2;
-            if (inst_cream->x == 0)
-                operand1 = (BIT(RM, 15)) ? (BITS(RM, 0, 15) | 0xffff0000) : BITS(RM, 0, 15);
-            else
-                operand1 = (BIT(RM, 31)) ? (BITS(RM, 16, 31) | 0xffff0000) : BITS(RM, 16, 31);
-            if (inst_cream->y == 0)
+                hi_val1 = ((s8)((rn_val >> 16) & 0xFF) - (s8)((rm_val >> 16) & 0xFF)) >> 1;
-                operand2 = (BIT(RS, 15)) ? (BITS(RS, 0, 15) | 0xffff0000) : BITS(RS, 0, 15);
+                hi_val2 = ((s8)((rn_val >> 24) & 0xFF) - (s8)((rm_val >> 24) & 0xFF)) >> 1;
-            else
+            }
-                operand2 = (BIT(RS, 31)) ? (BITS(RS, 16, 31) | 0xffff0000) : BITS(RS, 16, 31);
-            u32 product = operand1 * operand2;
+            RD = (lo_val1 & 0xFF) | ((lo_val2 & 0xFF) << 8) | ((hi_val1 & 0xFF) << 16) |
-            u32 result = product + RN;
+                 ((hi_val2 & 0xFF) << 24);
-            if (AddOverflow(product, RN, result))
-                cpu->Cpsr |= (1 << 27);
-            RD = result;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(smla_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    SMLAD_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    SMLSD_INST:
+    INC_PC(sizeof(generic_arm_inst));
-    SMUAD_INST:
+    FETCH_INST;
-    SMUSD_INST:
+    GOTO_NEXT_INST;
-    {
+}
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            smlad_inst* const inst_cream = (smlad_inst*)inst_base->component;
-            const u8 op2 = inst_cream->op2;
-            u32 rm_val = cpu->Reg[inst_cream->Rm];
+SMLA_INST : {
-            const u32 rn_val = cpu->Reg[inst_cream->Rn];
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        smla_inst* inst_cream = (smla_inst*)inst_base->component;
+        s32 operand1, operand2;
+        if (inst_cream->x == 0)
+            operand1 = (BIT(RM, 15)) ? (BITS(RM, 0, 15) | 0xffff0000) : BITS(RM, 0, 15);
+        else
+            operand1 = (BIT(RM, 31)) ? (BITS(RM, 16, 31) | 0xffff0000) : BITS(RM, 16, 31);
-            if (inst_cream->m)
+        if (inst_cream->y == 0)
-                rm_val = (((rm_val & 0xFFFF) << 16) | (rm_val >> 16));
+            operand2 = (BIT(RS, 15)) ? (BITS(RS, 0, 15) | 0xffff0000) : BITS(RS, 0, 15);
+        else
+            operand2 = (BIT(RS, 31)) ? (BITS(RS, 16, 31) | 0xffff0000) : BITS(RS, 16, 31);
+        u32 product = operand1 * operand2;
+        u32 result = product + RN;
+        if (AddOverflow(product, RN, result))
+            cpu->Cpsr |= (1 << 27);
+        RD = result;
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(smla_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
-            const s16 rm_lo = (rm_val & 0xFFFF);
+SMLAD_INST:
-            const s16 rm_hi = ((rm_val >> 16) & 0xFFFF);
+SMLSD_INST:
-            const s16 rn_lo = (rn_val & 0xFFFF);
+SMUAD_INST:
-            const s16 rn_hi = ((rn_val >> 16) & 0xFFFF);
+SMUSD_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        smlad_inst* const inst_cream = (smlad_inst*)inst_base->component;
+        const u8 op2 = inst_cream->op2;
-            const u32 product1 = (rn_lo * rm_lo);
+        u32 rm_val = cpu->Reg[inst_cream->Rm];
-            const u32 product2 = (rn_hi * rm_hi);
+        const u32 rn_val = cpu->Reg[inst_cream->Rn];
-            // SMUAD and SMLAD
+        if (inst_cream->m)
-            if (BIT(op2, 1) == 0) {
+            rm_val = (((rm_val & 0xFFFF) << 16) | (rm_val >> 16));
-                u32 rd_val = (product1 + product2);
-                if (inst_cream->Ra != 15) {
+        const s16 rm_lo = (rm_val & 0xFFFF);
-                    rd_val += cpu->Reg[inst_cream->Ra];
+        const s16 rm_hi = ((rm_val >> 16) & 0xFFFF);
+        const s16 rn_lo = (rn_val & 0xFFFF);
+        const s16 rn_hi = ((rn_val >> 16) & 0xFFFF);
-                    if (ARMul_AddOverflowQ(product1 + product2, cpu->Reg[inst_cream->Ra]))
+        const u32 product1 = (rn_lo * rm_lo);
-                        cpu->Cpsr |= (1 << 27);
+        const u32 product2 = (rn_hi * rm_hi);
-                }
+        // SMUAD and SMLAD
+        if (BIT(op2, 1) == 0) {
+            u32 rd_val = (product1 + product2);
-                RD = rd_val;
+            if (inst_cream->Ra != 15) {
+                rd_val += cpu->Reg[inst_cream->Ra];
-                if (ARMul_AddOverflowQ(product1, product2))
+                if (ARMul_AddOverflowQ(product1 + product2, cpu->Reg[inst_cream->Ra]))
                    cpu->Cpsr |= (1 << 27);
            }
-            // SMUSD and SMLSD
-            else {
-                u32 rd_val = (product1 - product2);
-                if (inst_cream->Ra != 15) {
+            RD = rd_val;
-                    rd_val += cpu->Reg[inst_cream->Ra];
-                    if (ARMul_AddOverflowQ(product1 - product2, cpu->Reg[inst_cream->Ra]))
+            if (ARMul_AddOverflowQ(product1, product2))
-                        cpu->Cpsr |= (1 << 27);
+                cpu->Cpsr |= (1 << 27);
-                }
+        }
+        // SMUSD and SMLSD
+        else {
+            u32 rd_val = (product1 - product2);
+            if (inst_cream->Ra != 15) {
+                rd_val += cpu->Reg[inst_cream->Ra];
-                RD = rd_val;
+                if (ARMul_AddOverflowQ(product1 - product2, cpu->Reg[inst_cream->Ra]))
+                    cpu->Cpsr |= (1 << 27);
            }
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+            RD = rd_val;
-        INC_PC(sizeof(smlad_inst));
+        }
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    SMLAL_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(smlad_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            umlal_inst* inst_cream = (umlal_inst*)inst_base->component;
+    GOTO_NEXT_INST;
-            long long int rm = RM;
+}
-            long long int rs = RS;
-            if (BIT(rm, 31)) {
+SMLAL_INST : {
-                rm |= 0xffffffff00000000LL;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            }
+        umlal_inst* inst_cream = (umlal_inst*)inst_base->component;
-            if (BIT(rs, 31)) {
+        long long int rm = RM;
-                rs |= 0xffffffff00000000LL;
+        long long int rs = RS;
-            }
+        if (BIT(rm, 31)) {
-            long long int rst = rm * rs;
+            rm |= 0xffffffff00000000LL;
-            long long int rdhi32 = RDHI;
-            long long int hilo = (rdhi32 << 32) + RDLO;
-            rst += hilo;
-            RDLO = BITS(rst,  0, 31);
-            RDHI = BITS(rst, 32, 63);
-            if (inst_cream->S) {
-                cpu->NFlag = BIT(RDHI, 31);
-                cpu->ZFlag = (RDHI == 0 && RDLO == 0);
-            }
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        if (BIT(rs, 31)) {
-        INC_PC(sizeof(umlal_inst));
+            rs |= 0xffffffff00000000LL;
-        FETCH_INST;
+        }
-        GOTO_NEXT_INST;
+        long long int rst = rm * rs;
-    }
+        long long int rdhi32 = RDHI;
+        long long int hilo = (rdhi32 << 32) + RDLO;
-    SMLALXY_INST:
+        rst += hilo;
-    {
+        RDLO = BITS(rst, 0, 31);
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        RDHI = BITS(rst, 32, 63);
-            smlalxy_inst* const inst_cream = (smlalxy_inst*)inst_base->component;
+        if (inst_cream->S) {
+            cpu->NFlag = BIT(RDHI, 31);
-            u64 operand1 = RN;
+            cpu->ZFlag = (RDHI == 0 && RDLO == 0);
-            u64 operand2 = RM;
-            if (inst_cream->x != 0)
-                operand1 >>= 16;
-            if (inst_cream->y != 0)
-                operand2 >>= 16;
-            operand1 &= 0xFFFF;
-            if (operand1 & 0x8000)
-                operand1 -= 65536;
-            operand2 &= 0xFFFF;
-            if (operand2 & 0x8000)
-                operand2 -= 65536;
-            u64 dest = ((u64)RDHI << 32 | RDLO) + (operand1 * operand2);
-            RDLO = (dest & 0xFFFFFFFF);
-            RDHI = ((dest >> 32) & 0xFFFFFFFF);
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(smlalxy_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(umlal_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
-    SMLAW_INST:
+SMLALXY_INST : {
-    {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        smlalxy_inst* const inst_cream = (smlalxy_inst*)inst_base->component;
-            smlad_inst* const inst_cream = (smlad_inst*)inst_base->component;
+        u64 operand1 = RN;
+        u64 operand2 = RM;
+        if (inst_cream->x != 0)
+            operand1 >>= 16;
+        if (inst_cream->y != 0)
+            operand2 >>= 16;
+        operand1 &= 0xFFFF;
+        if (operand1 & 0x8000)
+            operand1 -= 65536;
+        operand2 &= 0xFFFF;
+        if (operand2 & 0x8000)
+            operand2 -= 65536;
+        u64 dest = ((u64)RDHI << 32 | RDLO) + (operand1 * operand2);
+        RDLO = (dest & 0xFFFFFFFF);
+        RDHI = ((dest >> 32) & 0xFFFFFFFF);
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(smlalxy_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
-            const u32 rm_val = RM;
+SMLAW_INST : {
-            const u32 rn_val = RN;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            const u32 ra_val = cpu->Reg[inst_cream->Ra];
+        smlad_inst* const inst_cream = (smlad_inst*)inst_base->component;
-            const bool high = (inst_cream->m == 1);
-            const s16 operand2 = (high) ? ((rm_val >> 16) & 0xFFFF) : (rm_val & 0xFFFF);
+        const u32 rm_val = RM;
-            const s64 result = (s64)(s32)rn_val * (s64)(s32)operand2 + ((s64)(s32)ra_val << 16);
+        const u32 rn_val = RN;
+        const u32 ra_val = cpu->Reg[inst_cream->Ra];
+        const bool high = (inst_cream->m == 1);
-            RD = BITS(result, 16, 47);
+        const s16 operand2 = (high) ? ((rm_val >> 16) & 0xFFFF) : (rm_val & 0xFFFF);
+        const s64 result = (s64)(s32)rn_val * (s64)(s32)operand2 + ((s64)(s32)ra_val << 16);
-            if ((result >> 16) != (s32)RD)
+        RD = BITS(result, 16, 47);
-                cpu->Cpsr |= (1 << 27);
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        if ((result >> 16) != (s32)RD)
-        INC_PC(sizeof(smlad_inst));
+            cpu->Cpsr |= (1 << 27);
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    SMLALD_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    SMLSLD_INST:
+    INC_PC(sizeof(smlad_inst));
-    {
+    FETCH_INST;
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    GOTO_NEXT_INST;
-            smlald_inst* const inst_cream = (smlald_inst*)inst_base->component;
+}
-            const bool do_swap = (inst_cream->swap == 1);
+SMLALD_INST:
-            const u32 rdlo_val = RDLO;
+SMLSLD_INST : {
-            const u32 rdhi_val = RDHI;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            const u32 rn_val   = RN;
+        smlald_inst* const inst_cream = (smlald_inst*)inst_base->component;
-            u32 rm_val         = RM;
-            if (do_swap)
+        const bool do_swap = (inst_cream->swap == 1);
-                rm_val = (((rm_val & 0xFFFF) << 16) | (rm_val >> 16));
+        const u32 rdlo_val = RDLO;
+        const u32 rdhi_val = RDHI;
+        const u32 rn_val = RN;
+        u32 rm_val = RM;
-            const s32 product1 = (s16)(rn_val & 0xFFFF) * (s16)(rm_val & 0xFFFF);
+        if (do_swap)
-            const s32 product2 = (s16)((rn_val >> 16) & 0xFFFF) * (s16)((rm_val >> 16) & 0xFFFF);
+            rm_val = (((rm_val & 0xFFFF) << 16) | (rm_val >> 16));
-            s64 result;
-            // SMLALD
+        const s32 product1 = (s16)(rn_val & 0xFFFF) * (s16)(rm_val & 0xFFFF);
-            if (BIT(inst_cream->op2, 1) == 0) {
+        const s32 product2 = (s16)((rn_val >> 16) & 0xFFFF) * (s16)((rm_val >> 16) & 0xFFFF);
-                result = (product1 + product2) + (s64)(rdlo_val | ((s64)rdhi_val << 32));
+        s64 result;
-            }
-            // SMLSLD
-            else {
-                result = (product1 - product2) + (s64)(rdlo_val | ((s64)rdhi_val << 32));
-            }
-            RDLO = (result & 0xFFFFFFFF);
+        // SMLALD
-            RDHI = ((result >> 32) & 0xFFFFFFFF);
+        if (BIT(inst_cream->op2, 1) == 0) {
+            result = (product1 + product2) + (s64)(rdlo_val | ((s64)rdhi_val << 32));
+        }
+        // SMLSLD
+        else {
+            result = (product1 - product2) + (s64)(rdlo_val | ((s64)rdhi_val << 32));
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        RDLO = (result & 0xFFFFFFFF);
-        INC_PC(sizeof(smlald_inst));
+        RDHI = ((result >> 32) & 0xFFFFFFFF);
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    SMMLA_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    SMMLS_INST:
+    INC_PC(sizeof(smlald_inst));
-    SMMUL_INST:
+    FETCH_INST;
-    {
+    GOTO_NEXT_INST;
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+}
-            smlad_inst* const inst_cream = (smlad_inst*)inst_base->component;
-            const u32 rm_val = RM;
-            const u32 rn_val = RN;
-            const bool do_round = (inst_cream->m == 1);
-            // Assume SMMUL by default.
+SMMLA_INST:
-            s64 result = (s64)(s32)rn_val * (s64)(s32)rm_val;
+SMMLS_INST:
+SMMUL_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        smlad_inst* const inst_cream = (smlad_inst*)inst_base->component;
-            if (inst_cream->Ra != 15) {
+        const u32 rm_val = RM;
-                const u32 ra_val = cpu->Reg[inst_cream->Ra];
+        const u32 rn_val = RN;
+        const bool do_round = (inst_cream->m == 1);
-                // SMMLA, otherwise SMMLS
+        // Assume SMMUL by default.
-                if (BIT(inst_cream->op2, 1) == 0)
+        s64 result = (s64)(s32)rn_val * (s64)(s32)rm_val;
-                    result += ((s64)ra_val << 32);
-                else
-                    result = ((s64)ra_val << 32) - result;
-            }
-            if (do_round)
+        if (inst_cream->Ra != 15) {
-                result += 0x80000000;
+            const u32 ra_val = cpu->Reg[inst_cream->Ra];
-            RD = ((result >> 32) & 0xFFFFFFFF);
+            // SMMLA, otherwise SMMLS
+            if (BIT(inst_cream->op2, 1) == 0)
+                result += ((s64)ra_val << 32);
+            else
+                result = ((s64)ra_val << 32) - result;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        if (do_round)
-        INC_PC(sizeof(smlad_inst));
+            result += 0x80000000;
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        RD = ((result >> 32) & 0xFFFFFFFF);
    }
-    SMUL_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(smlad_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            smul_inst* inst_cream = (smul_inst*)inst_base->component;
+    GOTO_NEXT_INST;
-            u32 operand1, operand2;
+}
-            if (inst_cream->x == 0)
-                operand1 = (BIT(RM, 15)) ? (BITS(RM, 0, 15) | 0xffff0000) : BITS(RM, 0, 15);
-            else
-                operand1 = (BIT(RM, 31)) ? (BITS(RM, 16, 31) | 0xffff0000) : BITS(RM, 16, 31);
-            if (inst_cream->y == 0)
+SMUL_INST : {
-                operand2 = (BIT(RS, 15)) ? (BITS(RS, 0, 15) | 0xffff0000) : BITS(RS, 0, 15);
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            else
+        smul_inst* inst_cream = (smul_inst*)inst_base->component;
-                operand2 = (BIT(RS, 31)) ? (BITS(RS, 16, 31) | 0xffff0000) : BITS(RS, 16, 31);
+        u32 operand1, operand2;
-            RD = operand1 * operand2;
+        if (inst_cream->x == 0)
+            operand1 = (BIT(RM, 15)) ? (BITS(RM, 0, 15) | 0xffff0000) : BITS(RM, 0, 15);
+        else
+            operand1 = (BIT(RM, 31)) ? (BITS(RM, 16, 31) | 0xffff0000) : BITS(RM, 16, 31);
+        if (inst_cream->y == 0)
+            operand2 = (BIT(RS, 15)) ? (BITS(RS, 0, 15) | 0xffff0000) : BITS(RS, 0, 15);
+        else
+            operand2 = (BIT(RS, 31)) ? (BITS(RS, 16, 31) | 0xffff0000) : BITS(RS, 16, 31);
+        RD = operand1 * operand2;
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(smul_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+SMULL_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        umull_inst* inst_cream = (umull_inst*)inst_base->component;
+        s64 rm = RM;
+        s64 rs = RS;
+        if (BIT(rm, 31)) {
+            rm |= 0xffffffff00000000LL;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        if (BIT(rs, 31)) {
-        INC_PC(sizeof(smul_inst));
+            rs |= 0xffffffff00000000LL;
-        FETCH_INST;
+        }
-        GOTO_NEXT_INST;
+        s64 rst = rm * rs;
-    }
+        RDHI = BITS(rst, 32, 63);
-    SMULL_INST:
+        RDLO = BITS(rst, 0, 31);
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            umull_inst* inst_cream = (umull_inst*)inst_base->component;
-            s64 rm = RM;
-            s64 rs = RS;
-            if (BIT(rm, 31)) {
-                rm |= 0xffffffff00000000LL;
-            }
-            if (BIT(rs, 31)) {
-                rs |= 0xffffffff00000000LL;
-            }
-            s64 rst = rm * rs;
-            RDHI = BITS(rst, 32, 63);
-            RDLO = BITS(rst,  0, 31);
-            if (inst_cream->S) {
+        if (inst_cream->S) {
-                cpu->NFlag = BIT(RDHI, 31);
+            cpu->NFlag = BIT(RDHI, 31);
-                cpu->ZFlag = (RDHI == 0 && RDLO == 0);
+            cpu->ZFlag = (RDHI == 0 && RDLO == 0);
-            }
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(umull_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(umull_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
-    SMULW_INST:
+SMULW_INST : {
-    {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        smlad_inst* const inst_cream = (smlad_inst*)inst_base->component;
-            smlad_inst* const inst_cream = (smlad_inst*)inst_base->component;
-            s16 rm = (inst_cream->m == 1) ? ((RM >> 16) & 0xFFFF) : (RM & 0xFFFF);
+        s16 rm = (inst_cream->m == 1) ? ((RM >> 16) & 0xFFFF) : (RM & 0xFFFF);
-            s64 result = (s64)rm * (s64)(s32)RN;
+        s64 result = (s64)rm * (s64)(s32)RN;
-            RD = BITS(result, 16, 47);
+        RD = BITS(result, 16, 47);
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(smlad_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(smlad_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
-    SRS_INST:
+SRS_INST : {
-    {
+    // SRS is unconditional
-        // SRS is unconditional
+    ldst_inst* const inst_cream = (ldst_inst*)inst_base->component;
-        ldst_inst* const inst_cream = (ldst_inst*)inst_base->component;
-        u32 address = 0;
+    u32 address = 0;
-        inst_cream->get_addr(cpu, inst_cream->inst, address);
+    inst_cream->get_addr(cpu, inst_cream->inst, address);
-        cpu->WriteMemory32(address + 0, cpu->Reg[14]);
+    cpu->WriteMemory32(address + 0, cpu->Reg[14]);
-        cpu->WriteMemory32(address + 4, cpu->Spsr_copy);
+    cpu->WriteMemory32(address + 4, cpu->Spsr_copy);
-        cpu->Reg[15] += cpu->GetInstructionSize();
+    cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(ldst_inst));
+    INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
+    FETCH_INST;
-        GOTO_NEXT_INST;
+    GOTO_NEXT_INST;
-    }
+}
-    SSAT_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            ssat_inst* const inst_cream = (ssat_inst*)inst_base->component;
-            u8 shift_type = inst_cream->shift_type;
+SSAT_INST : {
-            u8 shift_amount = inst_cream->imm5;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            u32 rn_val = RN;
+        ssat_inst* const inst_cream = (ssat_inst*)inst_base->component;
-            // 32-bit ASR is encoded as an amount of 0.
+        u8 shift_type = inst_cream->shift_type;
-            if (shift_type == 1 && shift_amount == 0)
+        u8 shift_amount = inst_cream->imm5;
-                shift_amount = 31;
+        u32 rn_val = RN;
-            if (shift_type == 0)
+        // 32-bit ASR is encoded as an amount of 0.
-                rn_val <<= shift_amount;
+        if (shift_type == 1 && shift_amount == 0)
-            else if (shift_type == 1)
+            shift_amount = 31;
-                rn_val = ((s32)rn_val >> shift_amount);
-            bool saturated = false;
+        if (shift_type == 0)
-            rn_val = ARMul_SignedSatQ(rn_val, inst_cream->sat_imm, &saturated);
+            rn_val <<= shift_amount;
+        else if (shift_type == 1)
+            rn_val = ((s32)rn_val >> shift_amount);
-            if (saturated)
+        bool saturated = false;
-                cpu->Cpsr |= (1 << 27);
+        rn_val = ARMul_SignedSatQ(rn_val, inst_cream->sat_imm, &saturated);
-            RD = rn_val;
+        if (saturated)
-        }
+            cpu->Cpsr |= (1 << 27);
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        RD = rn_val;
-        INC_PC(sizeof(ssat_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    SSAT16_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(ssat_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            ssat_inst* const inst_cream = (ssat_inst*)inst_base->component;
+    GOTO_NEXT_INST;
-            const u8 saturate_to = inst_cream->sat_imm;
+}
-            bool sat1 = false;
+SSAT16_INST : {
-            bool sat2 = false;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        ssat_inst* const inst_cream = (ssat_inst*)inst_base->component;
+        const u8 saturate_to = inst_cream->sat_imm;
-            RD = (ARMul_SignedSatQ((s16)RN, saturate_to, &sat1) & 0xFFFF) |
+        bool sat1 = false;
-                 ARMul_SignedSatQ((s32)RN >> 16, saturate_to, &sat2) << 16;
+        bool sat2 = false;
-            if (sat1 || sat2)
+        RD = (ARMul_SignedSatQ((s16)RN, saturate_to, &sat1) & 0xFFFF) |
-                cpu->Cpsr |= (1 << 27);
+             ARMul_SignedSatQ((s32)RN >> 16, saturate_to, &sat2) << 16;
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        if (sat1 || sat2)
-        INC_PC(sizeof(ssat_inst));
+            cpu->Cpsr |= (1 << 27);
-        FETCH_INST;
+    }
-        GOTO_NEXT_INST;
-    }
-    STC_INST:
-    {
-        // Instruction not implemented
-        //LOG_CRITICAL(Core_ARM11, "unimplemented instruction");
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(stc_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    STM_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-            unsigned int inst = inst_cream->inst;
-            unsigned int Rn = BITS(inst, 16, 19);
-            unsigned int old_RN = cpu->Reg[Rn];
-            inst_cream->get_addr(cpu, inst_cream->inst, addr);
-            if (BIT(inst_cream->inst, 22) == 1) {
-                for (int i = 0; i < 13; i++) {
-                    if (BIT(inst_cream->inst, i)) {
-                        cpu->WriteMemory32(addr, cpu->Reg[i]);
-                        addr += 4;
-                    }
-                }
-                if (BIT(inst_cream->inst, 13)) {
-                    if (cpu->Mode == USER32MODE)
-                        cpu->WriteMemory32(addr, cpu->Reg[13]);
-                    else
-                        cpu->WriteMemory32(addr, cpu->Reg_usr[0]);
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(ssat_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+STC_INST : {
+    // Instruction not implemented
+    // LOG_CRITICAL(Core_ARM11, "unimplemented instruction");
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(stc_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+STM_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+        unsigned int inst = inst_cream->inst;
+        unsigned int Rn = BITS(inst, 16, 19);
+        unsigned int old_RN = cpu->Reg[Rn];
+        inst_cream->get_addr(cpu, inst_cream->inst, addr);
+        if (BIT(inst_cream->inst, 22) == 1) {
+            for (int i = 0; i < 13; i++) {
+                if (BIT(inst_cream->inst, i)) {
+                    cpu->WriteMemory32(addr, cpu->Reg[i]);
                    addr += 4;
                }
-                if (BIT(inst_cream->inst, 14)) {
+            }
-                    if (cpu->Mode == USER32MODE)
+            if (BIT(inst_cream->inst, 13)) {
-                        cpu->WriteMemory32(addr, cpu->Reg[14]);
+                if (cpu->Mode == USER32MODE)
+                    cpu->WriteMemory32(addr, cpu->Reg[13]);
+                else
+                    cpu->WriteMemory32(addr, cpu->Reg_usr[0]);
+                addr += 4;
+            }
+            if (BIT(inst_cream->inst, 14)) {
+                if (cpu->Mode == USER32MODE)
+                    cpu->WriteMemory32(addr, cpu->Reg[14]);
+                else
+                    cpu->WriteMemory32(addr, cpu->Reg_usr[1]);
+                addr += 4;
+            }
+            if (BIT(inst_cream->inst, 15)) {
+                cpu->WriteMemory32(addr, cpu->Reg[15] + 8);
+            }
+        } else {
+            for (int i = 0; i < 15; i++) {
+                if (BIT(inst_cream->inst, i)) {
+                    if (i == Rn)
+                        cpu->WriteMemory32(addr, old_RN);
                    else
-                        cpu->WriteMemory32(addr, cpu->Reg_usr[1]);
+                        cpu->WriteMemory32(addr, cpu->Reg[i]);
                    addr += 4;
                }
-                if (BIT(inst_cream->inst, 15)) {
+            }
-                    cpu->WriteMemory32(addr, cpu->Reg[15] + 8);
-                }
-            } else {
-                for (int i = 0; i < 15; i++) {
-                    if (BIT(inst_cream->inst, i)) {
-                        if (i == Rn)
-                            cpu->WriteMemory32(addr, old_RN);
-                        else
-                            cpu->WriteMemory32(addr, cpu->Reg[i]);
-                        addr += 4;
-                    }
-                }
-                // Check PC reg
+            // Check PC reg
-                if (BIT(inst_cream->inst, 15)) {
+            if (BIT(inst_cream->inst, 15)) {
-                    cpu->WriteMemory32(addr, cpu->Reg[15] + 8);
+                cpu->WriteMemory32(addr, cpu->Reg[15] + 8);
-                }
            }
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    SXTB_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(ldst_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            sxtb_inst* inst_cream = (sxtb_inst*)inst_base->component;
+    GOTO_NEXT_INST;
+}
+SXTB_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        sxtb_inst* inst_cream = (sxtb_inst*)inst_base->component;
-            unsigned int operand2 = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate);
+        unsigned int operand2 = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate);
-            if (BIT(operand2, 7)) {
+        if (BIT(operand2, 7)) {
-                operand2 |= 0xffffff00;
+            operand2 |= 0xffffff00;
-            } else {
+        } else {
-                operand2 &= 0xff;
+            operand2 &= 0xff;
-            }
-            RD = operand2;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        RD = operand2;
-        INC_PC(sizeof(sxtb_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    STR_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(sxtb_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+    GOTO_NEXT_INST;
-            inst_cream->get_addr(cpu, inst_cream->inst, addr);
+}
+STR_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+        inst_cream->get_addr(cpu, inst_cream->inst, addr);
-            unsigned int reg = BITS(inst_cream->inst, 12, 15);
+        unsigned int reg = BITS(inst_cream->inst, 12, 15);
-            unsigned int value = cpu->Reg[reg];
+        unsigned int value = cpu->Reg[reg];
-            if (reg == 15)
+        if (reg == 15)
-                value += 2 * cpu->GetInstructionSize();
+            value += 2 * cpu->GetInstructionSize();
-            cpu->WriteMemory32(addr, value);
+        cpu->WriteMemory32(addr, value);
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    UXTB_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            uxtb_inst* inst_cream = (uxtb_inst*)inst_base->component;
-            RD = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate) & 0xff;
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(uxtb_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    UXTAB_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            uxtab_inst* inst_cream = (uxtab_inst*)inst_base->component;
-            unsigned int operand2 = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate) & 0xff;
-            RD = RN + operand2;
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(uxtab_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    STRB_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-            inst_cream->get_addr(cpu, inst_cream->inst, addr);
-            unsigned int value = cpu->Reg[BITS(inst_cream->inst, 12, 15)] & 0xff;
-            cpu->WriteMemory8(addr, value);
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    STRBT_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(ldst_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+    GOTO_NEXT_INST;
-            inst_cream->get_addr(cpu, inst_cream->inst, addr);
+}
+UXTB_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        uxtb_inst* inst_cream = (uxtb_inst*)inst_base->component;
+        RD = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate) & 0xff;
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(uxtb_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+UXTAB_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        uxtab_inst* inst_cream = (uxtab_inst*)inst_base->component;
-            const u32 previous_mode = cpu->Mode;
+        unsigned int operand2 = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate) & 0xff;
-            const u32 value = cpu->Reg[BITS(inst_cream->inst, 12, 15)] & 0xff;
+        RD = RN + operand2;
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(uxtab_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+STRB_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+        inst_cream->get_addr(cpu, inst_cream->inst, addr);
+        unsigned int value = cpu->Reg[BITS(inst_cream->inst, 12, 15)] & 0xff;
+        cpu->WriteMemory8(addr, value);
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(ldst_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+STRBT_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+        inst_cream->get_addr(cpu, inst_cream->inst, addr);
-            cpu->ChangePrivilegeMode(USER32MODE);
+        const u32 previous_mode = cpu->Mode;
-            cpu->WriteMemory8(addr, value);
+        const u32 value = cpu->Reg[BITS(inst_cream->inst, 12, 15)] & 0xff;
-            cpu->ChangePrivilegeMode(previous_mode);
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    STRD_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-            inst_cream->get_addr(cpu, inst_cream->inst, addr);
-            // The 3DS doesn't have the Large Physical Access Extension (LPAE)
-            // so STRD wouldn't store these as a single write.
-            cpu->WriteMemory32(addr + 0, cpu->Reg[BITS(inst_cream->inst, 12, 15)]);
-            cpu->WriteMemory32(addr + 4, cpu->Reg[BITS(inst_cream->inst, 12, 15) + 1]);
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    STREX_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
-            unsigned int write_addr = cpu->Reg[inst_cream->Rn];
-            if (cpu->IsExclusiveMemoryAccess(write_addr)) {
-                cpu->UnsetExclusiveMemoryAddress();
-                cpu->WriteMemory32(write_addr, RM);
-                RD = 0;
-            } else {
-                // Failed to write due to mutex access
-                RD = 1;
-            }
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    STREXB_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
-            unsigned int write_addr = cpu->Reg[inst_cream->Rn];
-            if (cpu->IsExclusiveMemoryAccess(write_addr)) {
-                cpu->UnsetExclusiveMemoryAddress();
-                cpu->WriteMemory8(write_addr, cpu->Reg[inst_cream->Rm]);
-                RD = 0;
-            } else {
-                // Failed to write due to mutex access
-                RD = 1;
-            }
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    STREXD_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
-            unsigned int write_addr = cpu->Reg[inst_cream->Rn];
-            if (cpu->IsExclusiveMemoryAccess(write_addr)) {
-                cpu->UnsetExclusiveMemoryAddress();
-                const u32 rt  = cpu->Reg[inst_cream->Rm + 0];
-                const u32 rt2 = cpu->Reg[inst_cream->Rm + 1];
-                u64 value;
-                if (cpu->InBigEndianMode())
-                    value = (((u64)rt << 32) | rt2);
-                else
-                    value = (((u64)rt2 << 32) | rt);
-                cpu->WriteMemory64(write_addr, value);
+        cpu->ChangePrivilegeMode(USER32MODE);
-                RD = 0;
+        cpu->WriteMemory8(addr, value);
-            }
+        cpu->ChangePrivilegeMode(previous_mode);
-            else {
+    }
-                // Failed to write due to mutex access
+    cpu->Reg[15] += cpu->GetInstructionSize();
-                RD = 1;
+    INC_PC(sizeof(ldst_inst));
-            }
+    FETCH_INST;
-        }
+    GOTO_NEXT_INST;
-        cpu->Reg[15] += cpu->GetInstructionSize();
+}
-        INC_PC(sizeof(generic_arm_inst));
+STRD_INST : {
-        FETCH_INST;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-        GOTO_NEXT_INST;
+        ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-    }
+        inst_cream->get_addr(cpu, inst_cream->inst, addr);
-    STREXH_INST:
-    {
+        // The 3DS doesn't have the Large Physical Access Extension (LPAE)
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        // so STRD wouldn't store these as a single write.
-            generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
+        cpu->WriteMemory32(addr + 0, cpu->Reg[BITS(inst_cream->inst, 12, 15)]);
-            unsigned int write_addr = cpu->Reg[inst_cream->Rn];
+        cpu->WriteMemory32(addr + 4, cpu->Reg[BITS(inst_cream->inst, 12, 15) + 1]);
+    }
-            if (cpu->IsExclusiveMemoryAccess(write_addr)) {
+    cpu->Reg[15] += cpu->GetInstructionSize();
-                cpu->UnsetExclusiveMemoryAddress();
+    INC_PC(sizeof(ldst_inst));
-                cpu->WriteMemory16(write_addr, RM);
+    FETCH_INST;
-                RD = 0;
+    GOTO_NEXT_INST;
-            } else {
+}
-                // Failed to write due to mutex access
+STREX_INST : {
-                RD = 1;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            }
+        generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
+        unsigned int write_addr = cpu->Reg[inst_cream->Rn];
+        if (cpu->IsExclusiveMemoryAccess(write_addr)) {
+            cpu->UnsetExclusiveMemoryAddress();
+            cpu->WriteMemory32(write_addr, RM);
+            RD = 0;
+        } else {
+            // Failed to write due to mutex access
+            RD = 1;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+    }
-        INC_PC(sizeof(generic_arm_inst));
+    cpu->Reg[15] += cpu->GetInstructionSize();
-        FETCH_INST;
+    INC_PC(sizeof(generic_arm_inst));
-        GOTO_NEXT_INST;
+    FETCH_INST;
-    }
+    GOTO_NEXT_INST;
-    STRH_INST:
+}
-    {
+STREXB_INST : {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+        generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
-            inst_cream->get_addr(cpu, inst_cream->inst, addr);
+        unsigned int write_addr = cpu->Reg[inst_cream->Rn];
-            unsigned int value = cpu->Reg[BITS(inst_cream->inst, 12, 15)] & 0xffff;
+        if (cpu->IsExclusiveMemoryAccess(write_addr)) {
-            cpu->WriteMemory16(addr, value);
+            cpu->UnsetExclusiveMemoryAddress();
+            cpu->WriteMemory8(write_addr, cpu->Reg[inst_cream->Rm]);
+            RD = 0;
+        } else {
+            // Failed to write due to mutex access
+            RD = 1;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    STRT_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(generic_arm_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+    GOTO_NEXT_INST;
-            inst_cream->get_addr(cpu, inst_cream->inst, addr);
+}
+STREXD_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
+        unsigned int write_addr = cpu->Reg[inst_cream->Rn];
-            const u32 previous_mode = cpu->Mode;
+        if (cpu->IsExclusiveMemoryAccess(write_addr)) {
-            const u32 rt_index = BITS(inst_cream->inst, 12, 15);
+            cpu->UnsetExclusiveMemoryAddress();
-            u32 value = cpu->Reg[rt_index];
+            const u32 rt = cpu->Reg[inst_cream->Rm + 0];
-            if (rt_index == 15)
+            const u32 rt2 = cpu->Reg[inst_cream->Rm + 1];
-                value += 2 * cpu->GetInstructionSize();
+            u64 value;
-            cpu->ChangePrivilegeMode(USER32MODE);
+            if (cpu->InBigEndianMode())
-            cpu->WriteMemory32(addr, value);
+                value = (((u64)rt << 32) | rt2);
-            cpu->ChangePrivilegeMode(previous_mode);
+            else
+                value = (((u64)rt2 << 32) | rt);
+            cpu->WriteMemory64(write_addr, value);
+            RD = 0;
+        } else {
+            // Failed to write due to mutex access
+            RD = 1;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    SUB_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(generic_arm_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            sub_inst* const inst_cream = (sub_inst*)inst_base->component;
+    GOTO_NEXT_INST;
+}
+STREXH_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
+        unsigned int write_addr = cpu->Reg[inst_cream->Rn];
+        if (cpu->IsExclusiveMemoryAccess(write_addr)) {
+            cpu->UnsetExclusiveMemoryAddress();
+            cpu->WriteMemory16(write_addr, RM);
+            RD = 0;
+        } else {
+            // Failed to write due to mutex access
+            RD = 1;
+        }
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(generic_arm_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+STRH_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+        inst_cream->get_addr(cpu, inst_cream->inst, addr);
-            u32 rn_val = CHECK_READ_REG15_WA(cpu, inst_cream->Rn);
+        unsigned int value = cpu->Reg[BITS(inst_cream->inst, 12, 15)] & 0xffff;
+        cpu->WriteMemory16(addr, value);
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(ldst_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+STRT_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
+        inst_cream->get_addr(cpu, inst_cream->inst, addr);
-            bool carry;
+        const u32 previous_mode = cpu->Mode;
-            bool overflow;
+        const u32 rt_index = BITS(inst_cream->inst, 12, 15);
-            RD = AddWithCarry(rn_val, ~SHIFTER_OPERAND, 1, &carry, &overflow);
-            if (inst_cream->S && (inst_cream->Rd == 15)) {
+        u32 value = cpu->Reg[rt_index];
-                if (CurrentModeHasSPSR) {
+        if (rt_index == 15)
-                    cpu->Cpsr = cpu->Spsr_copy;
+            value += 2 * cpu->GetInstructionSize();
-                    cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
-                    LOAD_NZCVT;
-                }
-            } else if (inst_cream->S) {
-                UPDATE_NFLAG(RD);
-                UPDATE_ZFLAG(RD);
-                cpu->CFlag = carry;
-                cpu->VFlag = overflow;
-            }
-            if (inst_cream->Rd == 15) {
-                INC_PC(sizeof(sub_inst));
-                goto DISPATCH;
-            }
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(sub_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    SWI_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            swi_inst* const inst_cream = (swi_inst*)inst_base->component;
-            SVC::CallSVC(inst_cream->num & 0xFFFF);
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        cpu->ChangePrivilegeMode(USER32MODE);
-        INC_PC(sizeof(swi_inst));
+        cpu->WriteMemory32(addr, value);
-        FETCH_INST;
+        cpu->ChangePrivilegeMode(previous_mode);
-        GOTO_NEXT_INST;
    }
-    SWP_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(ldst_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            swp_inst* inst_cream = (swp_inst*)inst_base->component;
+    GOTO_NEXT_INST;
+}
+SUB_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        sub_inst* const inst_cream = (sub_inst*)inst_base->component;
-            addr = RN;
+        u32 rn_val = CHECK_READ_REG15_WA(cpu, inst_cream->Rn);
-            unsigned int value = cpu->ReadMemory32(addr);
-            cpu->WriteMemory32(addr, RM);
-            RD = value;
+        bool carry;
+        bool overflow;
+        RD = AddWithCarry(rn_val, ~SHIFTER_OPERAND, 1, &carry, &overflow);
+        if (inst_cream->S && (inst_cream->Rd == 15)) {
+            if (CurrentModeHasSPSR) {
+                cpu->Cpsr = cpu->Spsr_copy;
+                cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
+                LOAD_NZCVT;
+            }
+        } else if (inst_cream->S) {
+            UPDATE_NFLAG(RD);
+            UPDATE_ZFLAG(RD);
+            cpu->CFlag = carry;
+            cpu->VFlag = overflow;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        if (inst_cream->Rd == 15) {
-        INC_PC(sizeof(swp_inst));
+            INC_PC(sizeof(sub_inst));
-        FETCH_INST;
+            goto DISPATCH;
-        GOTO_NEXT_INST;
-    }
-    SWPB_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            swp_inst* inst_cream = (swp_inst*)inst_base->component;
-            addr = RN;
-            unsigned int value = cpu->ReadMemory8(addr);
-            cpu->WriteMemory8(addr, (RM & 0xFF));
-            RD = value;
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(swp_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    SXTAB_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(sub_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            sxtab_inst* inst_cream = (sxtab_inst*)inst_base->component;
+    GOTO_NEXT_INST;
+}
+SWI_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        swi_inst* const inst_cream = (swi_inst*)inst_base->component;
+        SVC::CallSVC(inst_cream->num & 0xFFFF);
+    }
-            unsigned int operand2 = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate) & 0xff;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(swi_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+SWP_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        swp_inst* inst_cream = (swp_inst*)inst_base->component;
-            // Sign extend for byte
+        addr = RN;
-            operand2 = (0x80 & operand2)? (0xFFFFFF00 | operand2):operand2;
+        unsigned int value = cpu->ReadMemory32(addr);
-            RD = RN + operand2;
+        cpu->WriteMemory32(addr, RM);
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(uxtab_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    SXTAB16_INST:
-    SXTB16_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            sxtab_inst* const inst_cream = (sxtab_inst*)inst_base->component;
-            const u8 rotation = inst_cream->rotate * 8;
-            u32 rm_val = RM;
-            u32 rn_val = RN;
-            if (rotation)
-                rm_val = ((rm_val << (32 - rotation)) | (rm_val >> rotation));
-            // SXTB16
-            if (inst_cream->Rn == 15) {
-                u32 lo = (u32)(s8)rm_val;
-                u32 hi = (u32)(s8)(rm_val >> 16);
-                RD = (lo | (hi << 16));
-            }
-            // SXTAB16
-            else {
-                u32 lo = (rn_val & 0xFFFF) + (u32)(s8)(rm_val & 0xFF);
-                u32 hi = ((rn_val >> 16) & 0xFFFF) + (u32)(s8)((rm_val >> 16) & 0xFF);
-                RD = (lo | (hi << 16));
-            }
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        RD = value;
-        INC_PC(sizeof(sxtab_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(swp_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+SWPB_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        swp_inst* inst_cream = (swp_inst*)inst_base->component;
+        addr = RN;
+        unsigned int value = cpu->ReadMemory8(addr);
+        cpu->WriteMemory8(addr, (RM & 0xFF));
+        RD = value;
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(swp_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+SXTAB_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        sxtab_inst* inst_cream = (sxtab_inst*)inst_base->component;
-    SXTAH_INST:
+        unsigned int operand2 = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate) & 0xff;
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            sxtah_inst* inst_cream = (sxtah_inst*)inst_base->component;
-            unsigned int operand2 = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate) & 0xffff;
+        // Sign extend for byte
-            // Sign extend for half
+        operand2 = (0x80 & operand2) ? (0xFFFFFF00 | operand2) : operand2;
-            operand2 = (0x8000 & operand2) ? (0xFFFF0000 | operand2) : operand2;
+        RD = RN + operand2;
-            RD = RN + operand2;
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(sxtah_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(uxtab_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
-    TEQ_INST:
+SXTAB16_INST:
-    {
+SXTB16_INST : {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            teq_inst* const inst_cream = (teq_inst*)inst_base->component;
+        sxtab_inst* const inst_cream = (sxtab_inst*)inst_base->component;
-            u32 lop = RN;
-            u32 rop = SHIFTER_OPERAND;
-            if (inst_cream->Rn == 15)
+        const u8 rotation = inst_cream->rotate * 8;
-                lop += cpu->GetInstructionSize() * 2;
+        u32 rm_val = RM;
+        u32 rn_val = RN;
-            u32 result = lop ^ rop;
+        if (rotation)
+            rm_val = ((rm_val << (32 - rotation)) | (rm_val >> rotation));
-            UPDATE_NFLAG(result);
+        // SXTB16
-            UPDATE_ZFLAG(result);
+        if (inst_cream->Rn == 15) {
-            UPDATE_CFLAG_WITH_SC;
+            u32 lo = (u32)(s8)rm_val;
+            u32 hi = (u32)(s8)(rm_val >> 16);
+            RD = (lo | (hi << 16));
+        }
+        // SXTAB16
+        else {
+            u32 lo = (rn_val & 0xFFFF) + (u32)(s8)(rm_val & 0xFF);
+            u32 hi = ((rn_val >> 16) & 0xFFFF) + (u32)(s8)((rm_val >> 16) & 0xFF);
+            RD = (lo | (hi << 16));
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(teq_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    TST_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            tst_inst* const inst_cream = (tst_inst*)inst_base->component;
-            u32 lop = RN;
+    cpu->Reg[15] += cpu->GetInstructionSize();
-            u32 rop = SHIFTER_OPERAND;
+    INC_PC(sizeof(sxtab_inst));
+    FETCH_INST;
-            if (inst_cream->Rn == 15)
+    GOTO_NEXT_INST;
-                lop += cpu->GetInstructionSize() * 2;
+}
-            u32 result = lop & rop;
+SXTAH_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        sxtah_inst* inst_cream = (sxtah_inst*)inst_base->component;
-            UPDATE_NFLAG(result);
+        unsigned int operand2 = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate) & 0xffff;
-            UPDATE_ZFLAG(result);
+        // Sign extend for half
-            UPDATE_CFLAG_WITH_SC;
+        operand2 = (0x8000 & operand2) ? (0xFFFF0000 | operand2) : operand2;
-        }
+        RD = RN + operand2;
-        cpu->Reg[15] += cpu->GetInstructionSize();
+    }
-        INC_PC(sizeof(tst_inst));
+    cpu->Reg[15] += cpu->GetInstructionSize();
-        FETCH_INST;
+    INC_PC(sizeof(sxtah_inst));
-        GOTO_NEXT_INST;
+    FETCH_INST;
-    }
+    GOTO_NEXT_INST;
+}
-    UADD8_INST:
-    UADD16_INST:
-    UADDSUBX_INST:
-    USUB8_INST:
-    USUB16_INST:
-    USUBADDX_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
-            const u8 op2 = inst_cream->op2;
-            const u32 rm_val = RM;
-            const u32 rn_val = RN;
-            s32 lo_result = 0;
+TEQ_INST : {
-            s32 hi_result = 0;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        teq_inst* const inst_cream = (teq_inst*)inst_base->component;
-            // UADD16
+        u32 lop = RN;
-            if (op2 == 0x00) {
+        u32 rop = SHIFTER_OPERAND;
-                lo_result = (rn_val & 0xFFFF) + (rm_val & 0xFFFF);
-                hi_result = ((rn_val >> 16) & 0xFFFF) + ((rm_val >> 16) & 0xFFFF);
-                if (lo_result & 0xFFFF0000) {
-                    cpu->Cpsr |= (1 << 16);
-                    cpu->Cpsr |= (1 << 17);
-                } else {
-                    cpu->Cpsr &= ~(1 << 16);
-                    cpu->Cpsr &= ~(1 << 17);
-                }
-                if (hi_result & 0xFFFF0000) {
+        if (inst_cream->Rn == 15)
-                    cpu->Cpsr |= (1 << 18);
+            lop += cpu->GetInstructionSize() * 2;
-                    cpu->Cpsr |= (1 << 19);
-                } else {
-                    cpu->Cpsr &= ~(1 << 18);
-                    cpu->Cpsr &= ~(1 << 19);
-                }
-            }
-            // UASX
-            else if (op2 == 0x01) {
-                lo_result = (rn_val & 0xFFFF) - ((rm_val >> 16) & 0xFFFF);
-                hi_result = ((rn_val >> 16) & 0xFFFF) + (rm_val & 0xFFFF);
-                if (lo_result >= 0) {
-                    cpu->Cpsr |= (1 << 16);
-                    cpu->Cpsr |= (1 << 17);
-                } else {
-                    cpu->Cpsr &= ~(1 << 16);
-                    cpu->Cpsr &= ~(1 << 17);
-                }
-                if (hi_result >= 0x10000) {
+        u32 result = lop ^ rop;
-                    cpu->Cpsr |= (1 << 18);
-                    cpu->Cpsr |= (1 << 19);
-                } else {
-                    cpu->Cpsr &= ~(1 << 18);
-                    cpu->Cpsr &= ~(1 << 19);
-                }
-            }
-            // USAX
-            else if (op2 == 0x02) {
-                lo_result = (rn_val & 0xFFFF) + ((rm_val >> 16) & 0xFFFF);
-                hi_result = ((rn_val >> 16) & 0xFFFF) - (rm_val & 0xFFFF);
-                if (lo_result >= 0x10000) {
-                    cpu->Cpsr |= (1 << 16);
-                    cpu->Cpsr |= (1 << 17);
-                } else {
-                    cpu->Cpsr &= ~(1 << 16);
-                    cpu->Cpsr &= ~(1 << 17);
-                }
-                if (hi_result >= 0) {
+        UPDATE_NFLAG(result);
-                    cpu->Cpsr |= (1 << 18);
+        UPDATE_ZFLAG(result);
-                    cpu->Cpsr |= (1 << 19);
+        UPDATE_CFLAG_WITH_SC;
-                } else {
+    }
-                    cpu->Cpsr &= ~(1 << 18);
+    cpu->Reg[15] += cpu->GetInstructionSize();
-                    cpu->Cpsr &= ~(1 << 19);
+    INC_PC(sizeof(teq_inst));
-                }
+    FETCH_INST;
-            }
+    GOTO_NEXT_INST;
-            // USUB16
+}
-            else if (op2 == 0x03) {
+TST_INST : {
-                lo_result = (rn_val & 0xFFFF) - (rm_val & 0xFFFF);
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-                hi_result = ((rn_val >> 16) & 0xFFFF) - ((rm_val >> 16) & 0xFFFF);
+        tst_inst* const inst_cream = (tst_inst*)inst_base->component;
-                if ((lo_result & 0xFFFF0000) == 0) {
-                    cpu->Cpsr |= (1 << 16);
-                    cpu->Cpsr |= (1 << 17);
-                } else {
-                    cpu->Cpsr &= ~(1 << 16);
-                    cpu->Cpsr &= ~(1 << 17);
-                }
-                if ((hi_result & 0xFFFF0000) == 0) {
+        u32 lop = RN;
-                    cpu->Cpsr |= (1 << 18);
+        u32 rop = SHIFTER_OPERAND;
-                    cpu->Cpsr |= (1 << 19);
-                } else {
-                    cpu->Cpsr &= ~(1 << 18);
-                    cpu->Cpsr &= ~(1 << 19);
-                }
-            }
-            // UADD8
-            else if (op2 == 0x04) {
-                s16 sum1 = (rn_val & 0xFF) + (rm_val & 0xFF);
-                s16 sum2 = ((rn_val >> 8) & 0xFF) + ((rm_val >> 8) & 0xFF);
-                s16 sum3 = ((rn_val >> 16) & 0xFF) + ((rm_val >> 16) & 0xFF);
-                s16 sum4 = ((rn_val >> 24) & 0xFF) + ((rm_val >> 24) & 0xFF);
-                if (sum1 >= 0x100)
-                    cpu->Cpsr |= (1 << 16);
-                else
-                    cpu->Cpsr &= ~(1 << 16);
-                if (sum2 >= 0x100)
+        if (inst_cream->Rn == 15)
-                    cpu->Cpsr |= (1 << 17);
+            lop += cpu->GetInstructionSize() * 2;
-                else
-                    cpu->Cpsr &= ~(1 << 17);
-                if (sum3 >= 0x100)
+        u32 result = lop & rop;
-                    cpu->Cpsr |= (1 << 18);
-                else
-                    cpu->Cpsr &= ~(1 << 18);
-                if (sum4 >= 0x100)
+        UPDATE_NFLAG(result);
-                    cpu->Cpsr |= (1 << 19);
+        UPDATE_ZFLAG(result);
-                else
+        UPDATE_CFLAG_WITH_SC;
-                    cpu->Cpsr &= ~(1 << 19);
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(tst_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
-                lo_result = ((sum1 & 0xFF) | (sum2 & 0xFF) << 8);
+UADD8_INST:
-                hi_result = ((sum3 & 0xFF) | (sum4 & 0xFF) << 8);
+UADD16_INST:
+UADDSUBX_INST:
+USUB8_INST:
+USUB16_INST:
+USUBADDX_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
+        const u8 op2 = inst_cream->op2;
+        const u32 rm_val = RM;
+        const u32 rn_val = RN;
+        s32 lo_result = 0;
+        s32 hi_result = 0;
+        // UADD16
+        if (op2 == 0x00) {
+            lo_result = (rn_val & 0xFFFF) + (rm_val & 0xFFFF);
+            hi_result = ((rn_val >> 16) & 0xFFFF) + ((rm_val >> 16) & 0xFFFF);
+            if (lo_result & 0xFFFF0000) {
+                cpu->Cpsr |= (1 << 16);
+                cpu->Cpsr |= (1 << 17);
+            } else {
+                cpu->Cpsr &= ~(1 << 16);
+                cpu->Cpsr &= ~(1 << 17);
            }
-            // USUB8
-            else if (op2 == 0x07) {
-                s16 diff1 = (rn_val & 0xFF) - (rm_val & 0xFF);
-                s16 diff2 = ((rn_val >> 8) & 0xFF) - ((rm_val >> 8) & 0xFF);
-                s16 diff3 = ((rn_val >> 16) & 0xFF) - ((rm_val >> 16) & 0xFF);
-                s16 diff4 = ((rn_val >> 24) & 0xFF) - ((rm_val >> 24) & 0xFF);
-                if (diff1 >= 0)
-                    cpu->Cpsr |= (1 << 16);
-                else
-                    cpu->Cpsr &= ~(1 << 16);
-                if (diff2 >= 0)
+            if (hi_result & 0xFFFF0000) {
-                    cpu->Cpsr |= (1 << 17);
+                cpu->Cpsr |= (1 << 18);
-                else
+                cpu->Cpsr |= (1 << 19);
-                    cpu->Cpsr &= ~(1 << 17);
+            } else {
+                cpu->Cpsr &= ~(1 << 18);
-                if (diff3 >= 0)
+                cpu->Cpsr &= ~(1 << 19);
-                    cpu->Cpsr |= (1 << 18);
-                else
-                    cpu->Cpsr &= ~(1 << 18);
-                if (diff4 >= 0)
-                    cpu->Cpsr |= (1 << 19);
-                else
-                    cpu->Cpsr &= ~(1 << 19);
-                lo_result = (diff1 & 0xFF) | ((diff2 & 0xFF) << 8);
-                hi_result = (diff3 & 0xFF) | ((diff4 & 0xFF) << 8);
            }
-            RD = (lo_result & 0xFFFF) | ((hi_result & 0xFFFF) << 16);
        }
+        // UASX
+        else if (op2 == 0x01) {
+            lo_result = (rn_val & 0xFFFF) - ((rm_val >> 16) & 0xFFFF);
+            hi_result = ((rn_val >> 16) & 0xFFFF) + (rm_val & 0xFFFF);
+            if (lo_result >= 0) {
+                cpu->Cpsr |= (1 << 16);
+                cpu->Cpsr |= (1 << 17);
+            } else {
+                cpu->Cpsr &= ~(1 << 16);
+                cpu->Cpsr &= ~(1 << 17);
+            }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+            if (hi_result >= 0x10000) {
-        INC_PC(sizeof(generic_arm_inst));
+                cpu->Cpsr |= (1 << 18);
-        FETCH_INST;
+                cpu->Cpsr |= (1 << 19);
-        GOTO_NEXT_INST;
+            } else {
-    }
+                cpu->Cpsr &= ~(1 << 18);
+                cpu->Cpsr &= ~(1 << 19);
-    UHADD8_INST:
+            }
-    UHADD16_INST:
+        }
-    UHADDSUBX_INST:
+        // USAX
-    UHSUBADDX_INST:
+        else if (op2 == 0x02) {
-    UHSUB8_INST:
+            lo_result = (rn_val & 0xFFFF) + ((rm_val >> 16) & 0xFFFF);
-    UHSUB16_INST:
+            hi_result = ((rn_val >> 16) & 0xFFFF) - (rm_val & 0xFFFF);
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+            if (lo_result >= 0x10000) {
-            generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
+                cpu->Cpsr |= (1 << 16);
-            const u32 rm_val = RM;
+                cpu->Cpsr |= (1 << 17);
-            const u32 rn_val = RN;
+            } else {
-            const u8 op2 = inst_cream->op2;
+                cpu->Cpsr &= ~(1 << 16);
+                cpu->Cpsr &= ~(1 << 17);
-            if (op2 == 0x00 || op2 == 0x01 || op2 == 0x02 || op2 == 0x03)
-            {
-                u32 lo_val = 0;
-                u32 hi_val = 0;
-                // UHADD16
-                if (op2 == 0x00) {
-                    lo_val = (rn_val & 0xFFFF) + (rm_val & 0xFFFF);
-                    hi_val = ((rn_val >> 16) & 0xFFFF) + ((rm_val >> 16) & 0xFFFF);
-                }
-                // UHASX
-                else if (op2 == 0x01) {
-                    lo_val = (rn_val & 0xFFFF) - ((rm_val >> 16) & 0xFFFF);
-                    hi_val = ((rn_val >> 16) & 0xFFFF) + (rm_val & 0xFFFF);
-                }
-                // UHSAX
-                else if (op2 == 0x02) {
-                    lo_val = (rn_val & 0xFFFF) + ((rm_val >> 16) & 0xFFFF);
-                    hi_val = ((rn_val >> 16) & 0xFFFF) - (rm_val & 0xFFFF);
-                }
-                // UHSUB16
-                else if (op2 == 0x03) {
-                    lo_val = (rn_val & 0xFFFF) - (rm_val & 0xFFFF);
-                    hi_val = ((rn_val >> 16) & 0xFFFF) - ((rm_val >> 16) & 0xFFFF);
-                }
-                lo_val >>= 1;
-                hi_val >>= 1;
-                RD = (lo_val & 0xFFFF) | ((hi_val & 0xFFFF) << 16);
            }
-            else if (op2 == 0x04 || op2 == 0x07) {
-                u32 sum1;
-                u32 sum2;
-                u32 sum3;
-                u32 sum4;
-                // UHADD8
-                if (op2 == 0x04) {
-                    sum1 = (rn_val & 0xFF) + (rm_val & 0xFF);
-                    sum2 = ((rn_val >> 8) & 0xFF) + ((rm_val >> 8) & 0xFF);
-                    sum3 = ((rn_val >> 16) & 0xFF) + ((rm_val >> 16) & 0xFF);
-                    sum4 = ((rn_val >> 24) & 0xFF) + ((rm_val >> 24) & 0xFF);
-                }
-                // UHSUB8
-                else {
-                    sum1 = (rn_val & 0xFF) - (rm_val & 0xFF);
-                    sum2 = ((rn_val >> 8) & 0xFF) - ((rm_val >> 8) & 0xFF);
-                    sum3 = ((rn_val >> 16) & 0xFF) - ((rm_val >> 16) & 0xFF);
-                    sum4 = ((rn_val >> 24) & 0xFF) - ((rm_val >> 24) & 0xFF);
-                }
-                sum1 >>= 1;
+            if (hi_result >= 0) {
-                sum2 >>= 1;
+                cpu->Cpsr |= (1 << 18);
-                sum3 >>= 1;
+                cpu->Cpsr |= (1 << 19);
-                sum4 >>= 1;
+            } else {
+                cpu->Cpsr &= ~(1 << 18);
+                cpu->Cpsr &= ~(1 << 19);
+            }
+        }
+        // USUB16
+        else if (op2 == 0x03) {
+            lo_result = (rn_val & 0xFFFF) - (rm_val & 0xFFFF);
+            hi_result = ((rn_val >> 16) & 0xFFFF) - ((rm_val >> 16) & 0xFFFF);
+            if ((lo_result & 0xFFFF0000) == 0) {
+                cpu->Cpsr |= (1 << 16);
+                cpu->Cpsr |= (1 << 17);
+            } else {
+                cpu->Cpsr &= ~(1 << 16);
+                cpu->Cpsr &= ~(1 << 17);
+            }
-                RD = (sum1 & 0xFF) | ((sum2 & 0xFF) << 8) | ((sum3 & 0xFF) << 16) | ((sum4 & 0xFF) << 24);
+            if ((hi_result & 0xFFFF0000) == 0) {
+                cpu->Cpsr |= (1 << 18);
+                cpu->Cpsr |= (1 << 19);
+            } else {
+                cpu->Cpsr &= ~(1 << 18);
+                cpu->Cpsr &= ~(1 << 19);
            }
        }
+        // UADD8
+        else if (op2 == 0x04) {
+            s16 sum1 = (rn_val & 0xFF) + (rm_val & 0xFF);
+            s16 sum2 = ((rn_val >> 8) & 0xFF) + ((rm_val >> 8) & 0xFF);
+            s16 sum3 = ((rn_val >> 16) & 0xFF) + ((rm_val >> 16) & 0xFF);
+            s16 sum4 = ((rn_val >> 24) & 0xFF) + ((rm_val >> 24) & 0xFF);
+            if (sum1 >= 0x100)
+                cpu->Cpsr |= (1 << 16);
+            else
+                cpu->Cpsr &= ~(1 << 16);
-        cpu->Reg[15] += cpu->GetInstructionSize();
+            if (sum2 >= 0x100)
-        INC_PC(sizeof(generic_arm_inst));
+                cpu->Cpsr |= (1 << 17);
-        FETCH_INST;
+            else
-        GOTO_NEXT_INST;
+                cpu->Cpsr &= ~(1 << 17);
-    }
-    UMAAL_INST:
+            if (sum3 >= 0x100)
-    {
+                cpu->Cpsr |= (1 << 18);
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+            else
-            umaal_inst* const inst_cream = (umaal_inst*)inst_base->component;
+                cpu->Cpsr &= ~(1 << 18);
-            const u64 rm = RM;
-            const u64 rn = RN;
-            const u64 rd_lo = RDLO;
-            const u64 rd_hi = RDHI;
-            const u64 result = (rm * rn) + rd_lo + rd_hi;
-            RDLO = (result & 0xFFFFFFFF);
+            if (sum4 >= 0x100)
-            RDHI = ((result >> 32) & 0xFFFFFFFF);
+                cpu->Cpsr |= (1 << 19);
-        }
+            else
-        cpu->Reg[15] += cpu->GetInstructionSize();
+                cpu->Cpsr &= ~(1 << 19);
-        INC_PC(sizeof(umaal_inst));
-        FETCH_INST;
+            lo_result = ((sum1 & 0xFF) | (sum2 & 0xFF) << 8);
-        GOTO_NEXT_INST;
+            hi_result = ((sum3 & 0xFF) | (sum4 & 0xFF) << 8);
-    }
-    UMLAL_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            umlal_inst* inst_cream = (umlal_inst*)inst_base->component;
-            unsigned long long int rm = RM;
-            unsigned long long int rs = RS;
-            unsigned long long int rst = rm * rs;
-            unsigned long long int add = ((unsigned long long) RDHI)<<32;
-            add += RDLO;
-            rst += add;
-            RDLO = BITS(rst,  0, 31);
-            RDHI = BITS(rst, 32, 63);
-            if (inst_cream->S) {
-                cpu->NFlag = BIT(RDHI, 31);
-                cpu->ZFlag = (RDHI == 0 && RDLO == 0);
-            }
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(umlal_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    UMULL_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            umull_inst* inst_cream = (umull_inst*)inst_base->component;
-            unsigned long long int rm = RM;
-            unsigned long long int rs = RS;
-            unsigned long long int rst = rm * rs;
-            RDHI = BITS(rst, 32, 63);
-            RDLO = BITS(rst,  0, 31);
-            if (inst_cream->S) {
-                cpu->NFlag = BIT(RDHI, 31);
-                cpu->ZFlag = (RDHI == 0 && RDLO == 0);
-            }
        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        // USUB8
-        INC_PC(sizeof(umull_inst));
+        else if (op2 == 0x07) {
-        FETCH_INST;
+            s16 diff1 = (rn_val & 0xFF) - (rm_val & 0xFF);
-        GOTO_NEXT_INST;
+            s16 diff2 = ((rn_val >> 8) & 0xFF) - ((rm_val >> 8) & 0xFF);
-    }
+            s16 diff3 = ((rn_val >> 16) & 0xFF) - ((rm_val >> 16) & 0xFF);
-    B_2_THUMB:
+            s16 diff4 = ((rn_val >> 24) & 0xFF) - ((rm_val >> 24) & 0xFF);
-    {
-        b_2_thumb* inst_cream = (b_2_thumb*)inst_base->component;
+            if (diff1 >= 0)
-        cpu->Reg[15] = cpu->Reg[15] + 4 + inst_cream->imm;
+                cpu->Cpsr |= (1 << 16);
-        INC_PC(sizeof(b_2_thumb));
+            else
-        goto DISPATCH;
+                cpu->Cpsr &= ~(1 << 16);
-    }
-    B_COND_THUMB:
-    {
-        b_cond_thumb* inst_cream = (b_cond_thumb*)inst_base->component;
-        if(CondPassed(cpu, inst_cream->cond))
+            if (diff2 >= 0)
-            cpu->Reg[15] = cpu->Reg[15] + 4 + inst_cream->imm;
+                cpu->Cpsr |= (1 << 17);
-        else
+            else
-            cpu->Reg[15] += 2;
+                cpu->Cpsr &= ~(1 << 17);
-        INC_PC(sizeof(b_cond_thumb));
+            if (diff3 >= 0)
-        goto DISPATCH;
+                cpu->Cpsr |= (1 << 18);
-    }
+            else
-    BL_1_THUMB:
+                cpu->Cpsr &= ~(1 << 18);
-    {
-        bl_1_thumb* inst_cream = (bl_1_thumb*)inst_base->component;
-        cpu->Reg[14] = cpu->Reg[15] + 4 + inst_cream->imm;
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(bl_1_thumb));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    BL_2_THUMB:
-    {
-        bl_2_thumb* inst_cream = (bl_2_thumb*)inst_base->component;
-        int tmp = ((cpu->Reg[15] + 2) | 1);
-        cpu->Reg[15] = (cpu->Reg[14] + inst_cream->imm);
-        cpu->Reg[14] = tmp;
-        INC_PC(sizeof(bl_2_thumb));
-        goto DISPATCH;
-    }
-    BLX_1_THUMB:
-    {
-        // BLX 1 for armv5t and above
-        u32 tmp = cpu->Reg[15];
-        blx_1_thumb* inst_cream = (blx_1_thumb*)inst_base->component;
-        cpu->Reg[15] = (cpu->Reg[14] + inst_cream->imm) & 0xFFFFFFFC;
-        cpu->Reg[14] = ((tmp + 2) | 1);
-        cpu->TFlag = 0;
-        INC_PC(sizeof(blx_1_thumb));
-        goto DISPATCH;
-    }
-    UQADD8_INST:
+            if (diff4 >= 0)
-    UQADD16_INST:
+                cpu->Cpsr |= (1 << 19);
-    UQADDSUBX_INST:
+            else
-    UQSUB8_INST:
+                cpu->Cpsr &= ~(1 << 19);
-    UQSUB16_INST:
-    UQSUBADDX_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
-            const u8 op2 = inst_cream->op2;
+            lo_result = (diff1 & 0xFF) | ((diff2 & 0xFF) << 8);
-            const u32 rm_val = RM;
+            hi_result = (diff3 & 0xFF) | ((diff4 & 0xFF) << 8);
-            const u32 rn_val = RN;
+        }
-            u16 lo_val = 0;
+        RD = (lo_result & 0xFFFF) | ((hi_result & 0xFFFF) << 16);
-            u16 hi_val = 0;
+    }
-            // UQADD16
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(generic_arm_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+UHADD8_INST:
+UHADD16_INST:
+UHADDSUBX_INST:
+UHSUBADDX_INST:
+UHSUB8_INST:
+UHSUB16_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
+        const u32 rm_val = RM;
+        const u32 rn_val = RN;
+        const u8 op2 = inst_cream->op2;
+        if (op2 == 0x00 || op2 == 0x01 || op2 == 0x02 || op2 == 0x03) {
+            u32 lo_val = 0;
+            u32 hi_val = 0;
+            // UHADD16
            if (op2 == 0x00) {
-                lo_val = ARMul_UnsignedSaturatedAdd16(rn_val & 0xFFFF, rm_val & 0xFFFF);
+                lo_val = (rn_val & 0xFFFF) + (rm_val & 0xFFFF);
-                hi_val = ARMul_UnsignedSaturatedAdd16((rn_val >> 16) & 0xFFFF, (rm_val >> 16) & 0xFFFF);
+                hi_val = ((rn_val >> 16) & 0xFFFF) + ((rm_val >> 16) & 0xFFFF);
            }
-            // UQASX
+            // UHASX
            else if (op2 == 0x01) {
-                lo_val = ARMul_UnsignedSaturatedSub16(rn_val & 0xFFFF, (rm_val >> 16) & 0xFFFF);
+                lo_val = (rn_val & 0xFFFF) - ((rm_val >> 16) & 0xFFFF);
-                hi_val = ARMul_UnsignedSaturatedAdd16((rn_val >> 16) & 0xFFFF, rm_val & 0xFFFF);
+                hi_val = ((rn_val >> 16) & 0xFFFF) + (rm_val & 0xFFFF);
            }
-            // UQSAX
+            // UHSAX
            else if (op2 == 0x02) {
-                lo_val = ARMul_UnsignedSaturatedAdd16(rn_val & 0xFFFF, (rm_val >> 16) & 0xFFFF);
+                lo_val = (rn_val & 0xFFFF) + ((rm_val >> 16) & 0xFFFF);
-                hi_val = ARMul_UnsignedSaturatedSub16((rn_val >> 16) & 0xFFFF, rm_val & 0xFFFF);
+                hi_val = ((rn_val >> 16) & 0xFFFF) - (rm_val & 0xFFFF);
            }
-            // UQSUB16
+            // UHSUB16
            else if (op2 == 0x03) {
-                lo_val = ARMul_UnsignedSaturatedSub16(rn_val & 0xFFFF, rm_val & 0xFFFF);
+                lo_val = (rn_val & 0xFFFF) - (rm_val & 0xFFFF);
-                hi_val = ARMul_UnsignedSaturatedSub16((rn_val >> 16) & 0xFFFF, (rm_val >> 16) & 0xFFFF);
+                hi_val = ((rn_val >> 16) & 0xFFFF) - ((rm_val >> 16) & 0xFFFF);
            }
-            // UQADD8
-            else if (op2 == 0x04) {
+            lo_val >>= 1;
-                lo_val = ARMul_UnsignedSaturatedAdd8(rn_val, rm_val) |
+            hi_val >>= 1;
-                         ARMul_UnsignedSaturatedAdd8(rn_val >> 8,  rm_val >> 8) << 8;
-                hi_val = ARMul_UnsignedSaturatedAdd8(rn_val >> 16, rm_val >> 16) |
+            RD = (lo_val & 0xFFFF) | ((hi_val & 0xFFFF) << 16);
-                         ARMul_UnsignedSaturatedAdd8(rn_val >> 24, rm_val >> 24) << 8;
+        } else if (op2 == 0x04 || op2 == 0x07) {
+            u32 sum1;
+            u32 sum2;
+            u32 sum3;
+            u32 sum4;
+            // UHADD8
+            if (op2 == 0x04) {
+                sum1 = (rn_val & 0xFF) + (rm_val & 0xFF);
+                sum2 = ((rn_val >> 8) & 0xFF) + ((rm_val >> 8) & 0xFF);
+                sum3 = ((rn_val >> 16) & 0xFF) + ((rm_val >> 16) & 0xFF);
+                sum4 = ((rn_val >> 24) & 0xFF) + ((rm_val >> 24) & 0xFF);
            }
-            // UQSUB8
+            // UHSUB8
            else {
-                lo_val = ARMul_UnsignedSaturatedSub8(rn_val, rm_val) |
+                sum1 = (rn_val & 0xFF) - (rm_val & 0xFF);
-                         ARMul_UnsignedSaturatedSub8(rn_val >> 8,  rm_val >> 8) << 8;
+                sum2 = ((rn_val >> 8) & 0xFF) - ((rm_val >> 8) & 0xFF);
-                hi_val = ARMul_UnsignedSaturatedSub8(rn_val >> 16, rm_val >> 16) |
+                sum3 = ((rn_val >> 16) & 0xFF) - ((rm_val >> 16) & 0xFF);
-                         ARMul_UnsignedSaturatedSub8(rn_val >> 24, rm_val >> 24) << 8;
+                sum4 = ((rn_val >> 24) & 0xFF) - ((rm_val >> 24) & 0xFF);
            }
-            RD = ((lo_val & 0xFFFF) | hi_val << 16);
+            sum1 >>= 1;
+            sum2 >>= 1;
+            sum3 >>= 1;
+            sum4 >>= 1;
+            RD = (sum1 & 0xFF) | ((sum2 & 0xFF) << 8) | ((sum3 & 0xFF) << 16) |
+                 ((sum4 & 0xFF) << 24);
        }
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(generic_arm_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
-        cpu->Reg[15] += cpu->GetInstructionSize();
+UMAAL_INST : {
-        INC_PC(sizeof(generic_arm_inst));
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-        FETCH_INST;
+        umaal_inst* const inst_cream = (umaal_inst*)inst_base->component;
-        GOTO_NEXT_INST;
+        const u64 rm = RM;
+        const u64 rn = RN;
+        const u64 rd_lo = RDLO;
+        const u64 rd_hi = RDHI;
+        const u64 result = (rm * rn) + rd_lo + rd_hi;
+        RDLO = (result & 0xFFFFFFFF);
+        RDHI = ((result >> 32) & 0xFFFFFFFF);
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(umaal_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+UMLAL_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        umlal_inst* inst_cream = (umlal_inst*)inst_base->component;
+        unsigned long long int rm = RM;
+        unsigned long long int rs = RS;
+        unsigned long long int rst = rm * rs;
+        unsigned long long int add = ((unsigned long long)RDHI) << 32;
+        add += RDLO;
+        rst += add;
+        RDLO = BITS(rst, 0, 31);
+        RDHI = BITS(rst, 32, 63);
+        if (inst_cream->S) {
+            cpu->NFlag = BIT(RDHI, 31);
+            cpu->ZFlag = (RDHI == 0 && RDLO == 0);
+        }
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(umlal_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+UMULL_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        umull_inst* inst_cream = (umull_inst*)inst_base->component;
+        unsigned long long int rm = RM;
+        unsigned long long int rs = RS;
+        unsigned long long int rst = rm * rs;
+        RDHI = BITS(rst, 32, 63);
+        RDLO = BITS(rst, 0, 31);
+        if (inst_cream->S) {
+            cpu->NFlag = BIT(RDHI, 31);
+            cpu->ZFlag = (RDHI == 0 && RDLO == 0);
+        }
    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(umull_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+B_2_THUMB : {
+    b_2_thumb* inst_cream = (b_2_thumb*)inst_base->component;
+    cpu->Reg[15] = cpu->Reg[15] + 4 + inst_cream->imm;
+    INC_PC(sizeof(b_2_thumb));
+    goto DISPATCH;
+}
+B_COND_THUMB : {
+    b_cond_thumb* inst_cream = (b_cond_thumb*)inst_base->component;
-    USAD8_INST:
+    if (CondPassed(cpu, inst_cream->cond))
-    USADA8_INST:
+        cpu->Reg[15] = cpu->Reg[15] + 4 + inst_cream->imm;
-    {
+    else
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        cpu->Reg[15] += 2;
-            generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
-            const u8 ra_idx = inst_cream->Ra;
+    INC_PC(sizeof(b_cond_thumb));
-            const u32 rm_val = RM;
+    goto DISPATCH;
-            const u32 rn_val = RN;
+}
+BL_1_THUMB : {
+    bl_1_thumb* inst_cream = (bl_1_thumb*)inst_base->component;
+    cpu->Reg[14] = cpu->Reg[15] + 4 + inst_cream->imm;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(bl_1_thumb));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+BL_2_THUMB : {
+    bl_2_thumb* inst_cream = (bl_2_thumb*)inst_base->component;
+    int tmp = ((cpu->Reg[15] + 2) | 1);
+    cpu->Reg[15] = (cpu->Reg[14] + inst_cream->imm);
+    cpu->Reg[14] = tmp;
+    INC_PC(sizeof(bl_2_thumb));
+    goto DISPATCH;
+}
+BLX_1_THUMB : {
+    // BLX 1 for armv5t and above
+    u32 tmp = cpu->Reg[15];
+    blx_1_thumb* inst_cream = (blx_1_thumb*)inst_base->component;
+    cpu->Reg[15] = (cpu->Reg[14] + inst_cream->imm) & 0xFFFFFFFC;
+    cpu->Reg[14] = ((tmp + 2) | 1);
+    cpu->TFlag = 0;
+    INC_PC(sizeof(blx_1_thumb));
+    goto DISPATCH;
+}
-            const u8 diff1 = ARMul_UnsignedAbsoluteDifference(rn_val & 0xFF, rm_val & 0xFF);
+UQADD8_INST:
-            const u8 diff2 = ARMul_UnsignedAbsoluteDifference((rn_val >> 8) & 0xFF, (rm_val >> 8) & 0xFF);
+UQADD16_INST:
-            const u8 diff3 = ARMul_UnsignedAbsoluteDifference((rn_val >> 16) & 0xFF, (rm_val >> 16) & 0xFF);
+UQADDSUBX_INST:
-            const u8 diff4 = ARMul_UnsignedAbsoluteDifference((rn_val >> 24) & 0xFF, (rm_val >> 24) & 0xFF);
+UQSUB8_INST:
+UQSUB16_INST:
+UQSUBADDX_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
+        const u8 op2 = inst_cream->op2;
+        const u32 rm_val = RM;
+        const u32 rn_val = RN;
+        u16 lo_val = 0;
+        u16 hi_val = 0;
+        // UQADD16
+        if (op2 == 0x00) {
+            lo_val = ARMul_UnsignedSaturatedAdd16(rn_val & 0xFFFF, rm_val & 0xFFFF);
+            hi_val = ARMul_UnsignedSaturatedAdd16((rn_val >> 16) & 0xFFFF, (rm_val >> 16) & 0xFFFF);
+        }
+        // UQASX
+        else if (op2 == 0x01) {
+            lo_val = ARMul_UnsignedSaturatedSub16(rn_val & 0xFFFF, (rm_val >> 16) & 0xFFFF);
+            hi_val = ARMul_UnsignedSaturatedAdd16((rn_val >> 16) & 0xFFFF, rm_val & 0xFFFF);
+        }
+        // UQSAX
+        else if (op2 == 0x02) {
+            lo_val = ARMul_UnsignedSaturatedAdd16(rn_val & 0xFFFF, (rm_val >> 16) & 0xFFFF);
+            hi_val = ARMul_UnsignedSaturatedSub16((rn_val >> 16) & 0xFFFF, rm_val & 0xFFFF);
+        }
+        // UQSUB16
+        else if (op2 == 0x03) {
+            lo_val = ARMul_UnsignedSaturatedSub16(rn_val & 0xFFFF, rm_val & 0xFFFF);
+            hi_val = ARMul_UnsignedSaturatedSub16((rn_val >> 16) & 0xFFFF, (rm_val >> 16) & 0xFFFF);
+        }
+        // UQADD8
+        else if (op2 == 0x04) {
+            lo_val = ARMul_UnsignedSaturatedAdd8(rn_val, rm_val) |
+                     ARMul_UnsignedSaturatedAdd8(rn_val >> 8, rm_val >> 8) << 8;
+            hi_val = ARMul_UnsignedSaturatedAdd8(rn_val >> 16, rm_val >> 16) |
+                     ARMul_UnsignedSaturatedAdd8(rn_val >> 24, rm_val >> 24) << 8;
+        }
+        // UQSUB8
+        else {
+            lo_val = ARMul_UnsignedSaturatedSub8(rn_val, rm_val) |
+                     ARMul_UnsignedSaturatedSub8(rn_val >> 8, rm_val >> 8) << 8;
+            hi_val = ARMul_UnsignedSaturatedSub8(rn_val >> 16, rm_val >> 16) |
+                     ARMul_UnsignedSaturatedSub8(rn_val >> 24, rm_val >> 24) << 8;
+        }
+        RD = ((lo_val & 0xFFFF) | hi_val << 16);
+    }
-            u32 finalDif = (diff1 + diff2 + diff3 + diff4);
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(generic_arm_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
-            // Op is USADA8 if true.
+USAD8_INST:
-            if (ra_idx != 15)
+USADA8_INST : {
-                finalDif += cpu->Reg[ra_idx];
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
-            RD = finalDif;
+        const u8 ra_idx = inst_cream->Ra;
-        }
+        const u32 rm_val = RM;
+        const u32 rn_val = RN;
+        const u8 diff1 = ARMul_UnsignedAbsoluteDifference(rn_val & 0xFF, rm_val & 0xFF);
+        const u8 diff2 =
+            ARMul_UnsignedAbsoluteDifference((rn_val >> 8) & 0xFF, (rm_val >> 8) & 0xFF);
+        const u8 diff3 =
+            ARMul_UnsignedAbsoluteDifference((rn_val >> 16) & 0xFF, (rm_val >> 16) & 0xFF);
+        const u8 diff4 =
+            ARMul_UnsignedAbsoluteDifference((rn_val >> 24) & 0xFF, (rm_val >> 24) & 0xFF);
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        u32 finalDif = (diff1 + diff2 + diff3 + diff4);
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
+        // Op is USADA8 if true.
-        GOTO_NEXT_INST;
+        if (ra_idx != 15)
+            finalDif += cpu->Reg[ra_idx];
+        RD = finalDif;
    }
-    USAT_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(generic_arm_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            ssat_inst* const inst_cream = (ssat_inst*)inst_base->component;
+    GOTO_NEXT_INST;
+}
-            u8 shift_type = inst_cream->shift_type;
+USAT_INST : {
-            u8 shift_amount = inst_cream->imm5;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            u32 rn_val = RN;
+        ssat_inst* const inst_cream = (ssat_inst*)inst_base->component;
-            // 32-bit ASR is encoded as an amount of 0.
+        u8 shift_type = inst_cream->shift_type;
-            if (shift_type == 1 && shift_amount == 0)
+        u8 shift_amount = inst_cream->imm5;
-                shift_amount = 31;
+        u32 rn_val = RN;
-            if (shift_type == 0)
+        // 32-bit ASR is encoded as an amount of 0.
-                rn_val <<= shift_amount;
+        if (shift_type == 1 && shift_amount == 0)
-            else if (shift_type == 1)
+            shift_amount = 31;
-                rn_val = ((s32)rn_val >> shift_amount);
-            bool saturated = false;
+        if (shift_type == 0)
-            rn_val = ARMul_UnsignedSatQ(rn_val, inst_cream->sat_imm, &saturated);
+            rn_val <<= shift_amount;
+        else if (shift_type == 1)
+            rn_val = ((s32)rn_val >> shift_amount);
-            if (saturated)
+        bool saturated = false;
-                cpu->Cpsr |= (1 << 27);
+        rn_val = ARMul_UnsignedSatQ(rn_val, inst_cream->sat_imm, &saturated);
-            RD = rn_val;
+        if (saturated)
-        }
+            cpu->Cpsr |= (1 << 27);
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        RD = rn_val;
-        INC_PC(sizeof(ssat_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    USAT16_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(ssat_inst));
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    FETCH_INST;
-            ssat_inst* const inst_cream = (ssat_inst*)inst_base->component;
+    GOTO_NEXT_INST;
-            const u8 saturate_to = inst_cream->sat_imm;
+}
-            bool sat1 = false;
+USAT16_INST : {
-            bool sat2 = false;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        ssat_inst* const inst_cream = (ssat_inst*)inst_base->component;
+        const u8 saturate_to = inst_cream->sat_imm;
-            RD = (ARMul_UnsignedSatQ((s16)RN, saturate_to, &sat1) & 0xFFFF) |
+        bool sat1 = false;
-                 ARMul_UnsignedSatQ((s32)RN >> 16, saturate_to, &sat2) << 16;
+        bool sat2 = false;
-            if (sat1 || sat2)
+        RD = (ARMul_UnsignedSatQ((s16)RN, saturate_to, &sat1) & 0xFFFF) |
-                cpu->Cpsr |= (1 << 27);
+             ARMul_UnsignedSatQ((s32)RN >> 16, saturate_to, &sat2) << 16;
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        if (sat1 || sat2)
-        INC_PC(sizeof(ssat_inst));
+            cpu->Cpsr |= (1 << 27);
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    UXTAB16_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    UXTB16_INST:
+    INC_PC(sizeof(ssat_inst));
-    {
+    FETCH_INST;
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    GOTO_NEXT_INST;
-            uxtab_inst* const inst_cream = (uxtab_inst*)inst_base->component;
+}
-            const u8 rn_idx = inst_cream->Rn;
+UXTAB16_INST:
-            const u32 rm_val = RM;
+UXTB16_INST : {
-            const u32 rotation = inst_cream->rotate * 8;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            const u32 rotated_rm = ((rm_val << (32 - rotation)) | (rm_val >> rotation));
+        uxtab_inst* const inst_cream = (uxtab_inst*)inst_base->component;
-            // UXTB16, otherwise UXTAB16
+        const u8 rn_idx = inst_cream->Rn;
-            if (rn_idx == 15) {
+        const u32 rm_val = RM;
-                RD = rotated_rm & 0x00FF00FF;
+        const u32 rotation = inst_cream->rotate * 8;
-            } else {
+        const u32 rotated_rm = ((rm_val << (32 - rotation)) | (rm_val >> rotation));
-                const u32 rn_val = RN;
-                const u8 lo_rotated = (rotated_rm & 0xFF);
-                const u16 lo_result = (rn_val & 0xFFFF) + (u16)lo_rotated;
-                const u8 hi_rotated = (rotated_rm >> 16) & 0xFF;
-                const u16 hi_result = (rn_val >> 16) + (u16)hi_rotated;
-                RD = ((hi_result << 16) | (lo_result & 0xFFFF));
+        // UXTB16, otherwise UXTAB16
-            }
+        if (rn_idx == 15) {
-        }
+            RD = rotated_rm & 0x00FF00FF;
+        } else {
+            const u32 rn_val = RN;
+            const u8 lo_rotated = (rotated_rm & 0xFF);
+            const u16 lo_result = (rn_val & 0xFFFF) + (u16)lo_rotated;
+            const u8 hi_rotated = (rotated_rm >> 16) & 0xFF;
+            const u16 hi_result = (rn_val >> 16) + (u16)hi_rotated;
-        cpu->Reg[15] += cpu->GetInstructionSize();
+            RD = ((hi_result << 16) | (lo_result & 0xFFFF));
-        INC_PC(sizeof(uxtab_inst));
+        }
-        FETCH_INST;
-        GOTO_NEXT_INST;
    }
-    WFE_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC(sizeof(uxtab_inst));
-        // Stubbed, as WFE is a hint instruction.
+    FETCH_INST;
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    GOTO_NEXT_INST;
-            LOG_TRACE(Core_ARM11, "WFE executed.");
+}
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+WFE_INST : {
-        INC_PC_STUB;
+    // Stubbed, as WFE is a hint instruction.
-        FETCH_INST;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-        GOTO_NEXT_INST;
+        LOG_TRACE(Core_ARM11, "WFE executed.");
    }
-    WFI_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC_STUB;
-        // Stubbed, as WFI is a hint instruction.
+    FETCH_INST;
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    GOTO_NEXT_INST;
-            LOG_TRACE(Core_ARM11, "WFI executed.");
+}
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+WFI_INST : {
-        INC_PC_STUB;
+    // Stubbed, as WFI is a hint instruction.
-        FETCH_INST;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-        GOTO_NEXT_INST;
+        LOG_TRACE(Core_ARM11, "WFI executed.");
    }
-    YIELD_INST:
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    {
+    INC_PC_STUB;
-        // Stubbed, as YIELD is a hint instruction.
+    FETCH_INST;
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+    GOTO_NEXT_INST;
-            LOG_TRACE(Core_ARM11, "YIELD executed.");
+}
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
+YIELD_INST : {
-        INC_PC_STUB;
+    // Stubbed, as YIELD is a hint instruction.
-        FETCH_INST;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-        GOTO_NEXT_INST;
+        LOG_TRACE(Core_ARM11, "YIELD executed.");
    }
-    #define VFP_INTERPRETER_IMPL
+    cpu->Reg[15] += cpu->GetInstructionSize();
-    #include "core/arm/skyeye_common/vfp/vfpinstr.cpp"
+    INC_PC_STUB;
-    #undef VFP_INTERPRETER_IMPL
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
-    END:
+#define VFP_INTERPRETER_IMPL
-    {
+#include "core/arm/skyeye_common/vfp/vfpinstr.cpp"
-        SAVE_NZCVT;
+#undef VFP_INTERPRETER_IMPL
-        cpu->NumInstrsToExecute = 0;
-        return num_instrs;
+END : {
-    }
+    SAVE_NZCVT;
-    INIT_INST_LENGTH:
+    cpu->NumInstrsToExecute = 0;
-    {
+    return num_instrs;
-        cpu->NumInstrsToExecute = 0;
+}
-        return num_instrs;
+INIT_INST_LENGTH : {
-    }
+    cpu->NumInstrsToExecute = 0;
+    return num_instrs;
+}
 }
diff --git a/src/core/arm/dyncom/arm_dyncom_thumb.cpp b/src/core/arm/dyncom/arm_dyncom_thumb.cpp
index 3576370d1..2a3dd0f53 100644
--- a/src/core/arm/dyncom/arm_dyncom_thumb.cpp
+++ b/src/core/arm/dyncom/arm_dyncom_thumb.cpp
@@ -21,50 +21,48 @@ ThumbDecodeStatus TranslateThumbInstruction(u32 addr, u32 instr, u32* ainstr, u3
    *ainstr = 0xDEADC0DE; // Debugging to catch non updates
    switch ((tinstr & 0xF800) >> 11) {
-    case 0: // LSL
+    case 0:                                         // LSL
-    case 1: // LSR
+    case 1:                                         // LSR
-    case 2: // ASR
+    case 2:                                         // ASR
-        *ainstr = 0xE1B00000                    // base opcode
+        *ainstr = 0xE1B00000                        // base opcode
-            | ((tinstr & 0x1800) >> (11 - 5))   // shift type
+                  | ((tinstr & 0x1800) >> (11 - 5)) // shift type
-            |((tinstr & 0x07C0) << (7 - 6))     // imm5
+                  | ((tinstr & 0x07C0) << (7 - 6))  // imm5
-            |((tinstr & 0x0038) >> 3)           // Rs
+                  | ((tinstr & 0x0038) >> 3)        // Rs
-            |((tinstr & 0x0007) << 12);         // Rd
+                  | ((tinstr & 0x0007) << 12);      // Rd
        break;
    case 3: // ADD/SUB
-        {
+    {
-            static const u32 subset[4] = {
+        static const u32 subset[4] = {
-                0xE0900000,     // ADDS Rd,Rs,Rn
+            0xE0900000, // ADDS Rd,Rs,Rn
-                0xE0500000,     // SUBS Rd,Rs,Rn
+            0xE0500000, // SUBS Rd,Rs,Rn
-                0xE2900000,     // ADDS Rd,Rs,#imm3
+            0xE2900000, // ADDS Rd,Rs,#imm3
-                0xE2500000      // SUBS Rd,Rs,#imm3
+            0xE2500000  // SUBS Rd,Rs,#imm3
-            };
+        };
-            // It is quicker indexing into a table, than performing switch or conditionals:
+        // It is quicker indexing into a table, than performing switch or conditionals:
-            *ainstr = subset[(tinstr & 0x0600) >> 9]    // base opcode
+        *ainstr = subset[(tinstr & 0x0600) >> 9]     // base opcode
-                |((tinstr & 0x01C0) >> 6)               // Rn or imm3
+                  | ((tinstr & 0x01C0) >> 6)         // Rn or imm3
-                |((tinstr & 0x0038) << (16 - 3))        // Rs
+                  | ((tinstr & 0x0038) << (16 - 3))  // Rs
-                |((tinstr & 0x0007) << (12 - 0));       // Rd
+                  | ((tinstr & 0x0007) << (12 - 0)); // Rd
-        }
+    } break;
-        break;
    case 4: // MOV
    case 5: // CMP
    case 6: // ADD
    case 7: // SUB
-        {
+    {
-            static const u32 subset[4] = {
+        static const u32 subset[4] = {
-                0xE3B00000,     // MOVS Rd,#imm8
+            0xE3B00000, // MOVS Rd,#imm8
-                0xE3500000,     // CMP  Rd,#imm8
+            0xE3500000, // CMP  Rd,#imm8
-                0xE2900000,     // ADDS Rd,Rd,#imm8
+            0xE2900000, // ADDS Rd,Rd,#imm8
-                0xE2500000,     // SUBS Rd,Rd,#imm8
+            0xE2500000, // SUBS Rd,Rd,#imm8
-            };
+        };
-            *ainstr = subset[(tinstr & 0x1800) >> 11]   // base opcode
+        *ainstr = subset[(tinstr & 0x1800) >> 11]    // base opcode
-                |((tinstr & 0x00FF) >> 0)               // imm8
+                  | ((tinstr & 0x00FF) >> 0)         // imm8
-                |((tinstr & 0x0700) << (16 - 8))        // Rn
+                  | ((tinstr & 0x0700) << (16 - 8))  // Rn
-                |((tinstr & 0x0700) << (12 - 8));       // Rd
+                  | ((tinstr & 0x0700) << (12 - 8)); // Rd
-        }
+    } break;
-        break;
    case 8: // Arithmetic and high register transfers
@@ -73,56 +71,51 @@ ThumbDecodeStatus TranslateThumbInstruction(u32 addr, u32 instr, u32* ainstr, u3
        // large subset
        if ((tinstr & (1 << 10)) == 0) {
-            enum otype {
+            enum otype { t_norm, t_shift, t_neg, t_mul };
-                t_norm,
-                t_shift,
-                t_neg,
-                t_mul
-            };
            static const struct {
                u32 opcode;
                otype type;
            } subset[16] = {
-                { 0xE0100000, t_norm },     // ANDS Rd,Rd,Rs
+                {0xE0100000, t_norm},  // ANDS Rd,Rd,Rs
-                { 0xE0300000, t_norm },     // EORS Rd,Rd,Rs
+                {0xE0300000, t_norm},  // EORS Rd,Rd,Rs
-                { 0xE1B00010, t_shift },    // MOVS Rd,Rd,LSL Rs
+                {0xE1B00010, t_shift}, // MOVS Rd,Rd,LSL Rs
-                { 0xE1B00030, t_shift },    // MOVS Rd,Rd,LSR Rs
+                {0xE1B00030, t_shift}, // MOVS Rd,Rd,LSR Rs
-                { 0xE1B00050, t_shift },    // MOVS Rd,Rd,ASR Rs
+                {0xE1B00050, t_shift}, // MOVS Rd,Rd,ASR Rs
-                { 0xE0B00000, t_norm },     // ADCS Rd,Rd,Rs
+                {0xE0B00000, t_norm},  // ADCS Rd,Rd,Rs
-                { 0xE0D00000, t_norm },     // SBCS Rd,Rd,Rs
+                {0xE0D00000, t_norm},  // SBCS Rd,Rd,Rs
-                { 0xE1B00070, t_shift },    // MOVS Rd,Rd,ROR Rs
+                {0xE1B00070, t_shift}, // MOVS Rd,Rd,ROR Rs
-                { 0xE1100000, t_norm },     // TST  Rd,Rs
+                {0xE1100000, t_norm},  // TST  Rd,Rs
-                { 0xE2700000, t_neg },      // RSBS Rd,Rs,#0
+                {0xE2700000, t_neg},   // RSBS Rd,Rs,#0
-                { 0xE1500000, t_norm },     // CMP  Rd,Rs
+                {0xE1500000, t_norm},  // CMP  Rd,Rs
-                { 0xE1700000, t_norm },     // CMN  Rd,Rs
+                {0xE1700000, t_norm},  // CMN  Rd,Rs
-                { 0xE1900000, t_norm },     // ORRS Rd,Rd,Rs
+                {0xE1900000, t_norm},  // ORRS Rd,Rd,Rs
-                { 0xE0100090, t_mul },      // MULS Rd,Rd,Rs
+                {0xE0100090, t_mul},   // MULS Rd,Rd,Rs
-                { 0xE1D00000, t_norm },     // BICS Rd,Rd,Rs
+                {0xE1D00000, t_norm},  // BICS Rd,Rd,Rs
-                { 0xE1F00000, t_norm }      // MVNS Rd,Rs
+                {0xE1F00000, t_norm}   // MVNS Rd,Rs
            };
            *ainstr = subset[(tinstr & 0x03C0) >> 6].opcode; // base
            switch (subset[(tinstr & 0x03C0) >> 6].type) {
            case t_norm:
-                *ainstr |= ((tinstr & 0x0007) << 16)    // Rn
+                *ainstr |= ((tinstr & 0x0007) << 16)   // Rn
-                    |((tinstr & 0x0007) << 12)          // Rd
+                           | ((tinstr & 0x0007) << 12) // Rd
-                    |((tinstr & 0x0038) >> 3);          // Rs
+                           | ((tinstr & 0x0038) >> 3); // Rs
                break;
            case t_shift:
-                *ainstr |= ((tinstr & 0x0007) << 12)    // Rd
+                *ainstr |= ((tinstr & 0x0007) << 12)         // Rd
-                    |((tinstr & 0x0007) >> 0)           // Rm
+                           | ((tinstr & 0x0007) >> 0)        // Rm
-                    |((tinstr & 0x0038) << (8 - 3));    // Rs
+                           | ((tinstr & 0x0038) << (8 - 3)); // Rs
                break;
            case t_neg:
-                *ainstr |= ((tinstr & 0x0007) << 12)    // Rd
+                *ainstr |= ((tinstr & 0x0007) << 12)          // Rd
-                    |((tinstr & 0x0038) << (16 - 3));   // Rn
+                           | ((tinstr & 0x0038) << (16 - 3)); // Rn
                break;
            case t_mul:
-                *ainstr |= ((tinstr & 0x0007) << 16)    // Rd
+                *ainstr |= ((tinstr & 0x0007) << 16)   // Rd
-                    |((tinstr & 0x0007) << 8)           // Rs
+                           | ((tinstr & 0x0007) << 8)  // Rs
-                    |((tinstr & 0x0038) >> 3);          // Rm
+                           | ((tinstr & 0x0038) >> 3); // Rm
                break;
            }
        } else {
@@ -133,109 +126,106 @@ ThumbDecodeStatus TranslateThumbInstruction(u32 addr, u32 instr, u32* ainstr, u3
                Rd += 8;
            switch ((tinstr & 0x03C0) >> 6) {
-            case 0x0:                           // ADD Rd,Rd,Rs
+            case 0x0:                  // ADD Rd,Rd,Rs
-            case 0x1:                           // ADD Rd,Rd,Hs
+            case 0x1:                  // ADD Rd,Rd,Hs
-            case 0x2:                           // ADD Hd,Hd,Rs
+            case 0x2:                  // ADD Hd,Hd,Rs
-            case 0x3:                           // ADD Hd,Hd,Hs
+            case 0x3:                  // ADD Hd,Hd,Hs
-                *ainstr = 0xE0800000            // base
+                *ainstr = 0xE0800000   // base
-                    | (Rd << 16)                // Rn
+                          | (Rd << 16) // Rn
-                    |(Rd << 12)                 // Rd
+                          | (Rd << 12) // Rd
-                    |(Rs << 0);                 // Rm
+                          | (Rs << 0); // Rm
                break;
-            case 0x4:                           // CMP Rd,Rs
+            case 0x4:                  // CMP Rd,Rs
-            case 0x5:                           // CMP Rd,Hs
+            case 0x5:                  // CMP Rd,Hs
-            case 0x6:                           // CMP Hd,Rs
+            case 0x6:                  // CMP Hd,Rs
-            case 0x7:                           // CMP Hd,Hs
+            case 0x7:                  // CMP Hd,Hs
-                *ainstr = 0xE1500000            // base
+                *ainstr = 0xE1500000   // base
-                    | (Rd << 16)                // Rn
+                          | (Rd << 16) // Rn
-                    |(Rs << 0);                 // Rm
+                          | (Rs << 0); // Rm
                break;
-            case 0x8:                           // MOV Rd,Rs
+            case 0x8:                  // MOV Rd,Rs
-            case 0x9:                           // MOV Rd,Hs
+            case 0x9:                  // MOV Rd,Hs
-            case 0xA:                           // MOV Hd,Rs
+            case 0xA:                  // MOV Hd,Rs
-            case 0xB:                           // MOV Hd,Hs
+            case 0xB:                  // MOV Hd,Hs
-                *ainstr = 0xE1A00000            // base
+                *ainstr = 0xE1A00000   // base
-                    |(Rd << 12)                 // Rd
+                          | (Rd << 12) // Rd
-                    |(Rs << 0);                 // Rm
+                          | (Rs << 0); // Rm
                break;
-            case 0xC:                           // BX Rs
+            case 0xC:                                 // BX Rs
-            case 0xD:                           // BX Hs
+            case 0xD:                                 // BX Hs
-                *ainstr = 0xE12FFF10            // base
+                *ainstr = 0xE12FFF10                  // base
-                    | ((tinstr & 0x0078) >> 3); // Rd
+                          | ((tinstr & 0x0078) >> 3); // Rd
                break;
-            case 0xE:                           // BLX
+            case 0xE:                  // BLX
-            case 0xF:                           // BLX
+            case 0xF:                  // BLX
-                *ainstr = 0xE1200030            // base
+                *ainstr = 0xE1200030   // base
-                    | (Rs << 0);                // Rm
+                          | (Rs << 0); // Rm
                break;
            }
        }
        break;
-    case 9: // LDR Rd,[PC,#imm8]
+    case 9:                                         // LDR Rd,[PC,#imm8]
-        *ainstr = 0xE59F0000                    // base
+        *ainstr = 0xE59F0000                        // base
-            | ((tinstr & 0x0700) << (12 - 8))   // Rd
+                  | ((tinstr & 0x0700) << (12 - 8)) // Rd
-            |((tinstr & 0x00FF) << (2 - 0));    // off8
+                  | ((tinstr & 0x00FF) << (2 - 0)); // off8
        break;
    case 10:
-    case 11:
+    case 11: {
-        {
+        static const u32 subset[8] = {
-            static const u32 subset[8] = {
+            0xE7800000, // STR   Rd,[Rb,Ro]
-                0xE7800000, // STR   Rd,[Rb,Ro]
+            0xE18000B0, // STRH  Rd,[Rb,Ro]
-                0xE18000B0, // STRH  Rd,[Rb,Ro]
+            0xE7C00000, // STRB  Rd,[Rb,Ro]
-                0xE7C00000, // STRB  Rd,[Rb,Ro]
+            0xE19000D0, // LDRSB Rd,[Rb,Ro]
-                0xE19000D0, // LDRSB Rd,[Rb,Ro]
+            0xE7900000, // LDR   Rd,[Rb,Ro]
-                0xE7900000, // LDR   Rd,[Rb,Ro]
+            0xE19000B0, // LDRH  Rd,[Rb,Ro]
-                0xE19000B0, // LDRH  Rd,[Rb,Ro]
+            0xE7D00000, // LDRB  Rd,[Rb,Ro]
-                0xE7D00000, // LDRB  Rd,[Rb,Ro]
+            0xE19000F0  // LDRSH Rd,[Rb,Ro]
-                0xE19000F0  // LDRSH Rd,[Rb,Ro]
+        };
-            };
+        *ainstr = subset[(tinstr & 0xE00) >> 9]     // base
-            *ainstr = subset[(tinstr & 0xE00) >> 9] // base
+                  | ((tinstr & 0x0007) << (12 - 0)) // Rd
-                |((tinstr & 0x0007) << (12 - 0))    // Rd
+                  | ((tinstr & 0x0038) << (16 - 3)) // Rb
-                |((tinstr & 0x0038) << (16 - 3))    // Rb
+                  | ((tinstr & 0x01C0) >> 6);       // Ro
-                |((tinstr & 0x01C0) >> 6);          // Ro
+    } break;
-        }
-        break;
    case 12: // STR Rd,[Rb,#imm5]
    case 13: // LDR Rd,[Rb,#imm5]
    case 14: // STRB Rd,[Rb,#imm5]
    case 15: // LDRB Rd,[Rb,#imm5]
-        {
+    {
-            static const u32 subset[4] = {
+        static const u32 subset[4] = {
-                0xE5800000,     // STR  Rd,[Rb,#imm5]
+            0xE5800000, // STR  Rd,[Rb,#imm5]
-                0xE5900000,     // LDR  Rd,[Rb,#imm5]
+            0xE5900000, // LDR  Rd,[Rb,#imm5]
-                0xE5C00000,     // STRB Rd,[Rb,#imm5]
+            0xE5C00000, // STRB Rd,[Rb,#imm5]
-                0xE5D00000      // LDRB Rd,[Rb,#imm5]
+            0xE5D00000  // LDRB Rd,[Rb,#imm5]
-            };
+        };
-            // The offset range defends on whether we are transferring a byte or word value:
+        // The offset range defends on whether we are transferring a byte or word value:
-            *ainstr = subset[(tinstr & 0x1800) >> 11]   // base
+        *ainstr = subset[(tinstr & 0x1800) >> 11]                                // base
-                |((tinstr & 0x0007) << (12 - 0))        // Rd
+                  | ((tinstr & 0x0007) << (12 - 0))                              // Rd
-                |((tinstr & 0x0038) << (16 - 3))        // Rb
+                  | ((tinstr & 0x0038) << (16 - 3))                              // Rb
-                |((tinstr & 0x07C0) >> (6 - ((tinstr & (1 << 12)) ? 0 : 2))); // off5
+                  | ((tinstr & 0x07C0) >> (6 - ((tinstr & (1 << 12)) ? 0 : 2))); // off5
-        }
+    } break;
+    case 16:                                        // STRH Rd,[Rb,#imm5]
+    case 17:                                        // LDRH Rd,[Rb,#imm5]
+        *ainstr = ((tinstr & (1 << 11))             // base
+                       ? 0xE1D000B0                 // LDRH
+                       : 0xE1C000B0)                // STRH
+                  | ((tinstr & 0x0007) << (12 - 0)) // Rd
+                  | ((tinstr & 0x0038) << (16 - 3)) // Rb
+                  | ((tinstr & 0x01C0) >> (6 - 1))  // off5, low nibble
+                  | ((tinstr & 0x0600) >> (9 - 8)); // off5, high nibble
        break;
-    case 16: // STRH Rd,[Rb,#imm5]
+    case 18:                                        // STR Rd,[SP,#imm8]
-    case 17: // LDRH Rd,[Rb,#imm5]
+    case 19:                                        // LDR Rd,[SP,#imm8]
-        *ainstr = ((tinstr & (1 << 11))         // base
+        *ainstr = ((tinstr & (1 << 11))             // base
-               ? 0xE1D000B0                     // LDRH
+                       ? 0xE59D0000                 // LDR
-               : 0xE1C000B0)                    // STRH
+                       : 0xE58D0000)                // STR
-            |((tinstr & 0x0007) << (12 - 0))    // Rd
+                  | ((tinstr & 0x0700) << (12 - 8)) // Rd
-            |((tinstr & 0x0038) << (16 - 3))    // Rb
+                  | ((tinstr & 0x00FF) << 2);       // off8
-            |((tinstr & 0x01C0) >> (6 - 1))     // off5, low nibble
-            |((tinstr & 0x0600) >> (9 - 8));    // off5, high nibble
-        break;
-    case 18: // STR Rd,[SP,#imm8]
-    case 19: // LDR Rd,[SP,#imm8]
-        *ainstr = ((tinstr & (1 << 11))         // base
-               ? 0xE59D0000                     // LDR
-               : 0xE58D0000)                    // STR
-            |((tinstr & 0x0700) << (12 - 8))    // Rd
-            |((tinstr & 0x00FF) << 2);          // off8
        break;
    case 20: // ADD Rd,PC,#imm8
@@ -246,14 +236,15 @@ ThumbDecodeStatus TranslateThumbInstruction(u32 addr, u32 instr, u32* ainstr, u3
            // NOTE: The PC value used here should by word aligned. We encode shift-left-by-2 in the
            // rotate immediate field, so no shift of off8 is needed.
-            *ainstr = 0xE28F0F00                    // base
+            *ainstr = 0xE28F0F00                        // base
-                | ((tinstr & 0x0700) << (12 - 8))   // Rd
+                      | ((tinstr & 0x0700) << (12 - 8)) // Rd
-                |(tinstr & 0x00FF);                 // off8
+                      | (tinstr & 0x00FF);              // off8
        } else {
-            // We encode shift-left-by-2 in the rotate immediate field, so no shift of off8 is needed.
+            // We encode shift-left-by-2 in the rotate immediate field, so no shift of off8 is
-            *ainstr = 0xE28D0F00                    // base
+            // needed.
-                | ((tinstr & 0x0700) << (12 - 8))   // Rd
+            *ainstr = 0xE28D0F00                        // base
-                |(tinstr & 0x00FF);                 // off8
+                      | ((tinstr & 0x0700) << (12 - 8)) // Rd
+                      | (tinstr & 0x00FF);              // off8
        }
        break;
@@ -261,15 +252,15 @@ ThumbDecodeStatus TranslateThumbInstruction(u32 addr, u32 instr, u32* ainstr, u3
    case 23:
        if ((tinstr & 0x0F00) == 0x0000) {
            // NOTE: The instruction contains a shift left of 2 equivalent (implemented as ROR #30):
-            *ainstr = ((tinstr & (1 << 7))  // base
+            *ainstr = ((tinstr & (1 << 7)) // base
-                   ? 0xE24DDF00             // SUB
+                           ? 0xE24DDF00    // SUB
-                   : 0xE28DDF00)            // ADD
+                           : 0xE28DDF00)   // ADD
-                |(tinstr & 0x007F);         // off7
+                      | (tinstr & 0x007F); // off7
        } else if ((tinstr & 0x0F00) == 0x0e00) {
            // BKPT
-            *ainstr = 0xEF000000              // base
+            *ainstr = 0xEF000000                   // base
-                | BITS(tinstr, 0, 3)          // imm4 field;
+                      | BITS(tinstr, 0, 3)         // imm4 field;
-                | (BITS(tinstr, 4, 7) << 8);  // beginning 4 bits of imm12
+                      | (BITS(tinstr, 4, 7) << 8); // beginning 4 bits of imm12
        } else if ((tinstr & 0x0F00) == 0x0200) {
            static const u32 subset[4] = {
                0xE6BF0070, // SXTH
@@ -278,21 +269,21 @@ ThumbDecodeStatus TranslateThumbInstruction(u32 addr, u32 instr, u32* ainstr, u3
                0xE6EF0070, // UXTB
            };
-            *ainstr = subset[BITS(tinstr, 6, 7)] // base
+            *ainstr = subset[BITS(tinstr, 6, 7)]   // base
-                | (BITS(tinstr, 0, 2) << 12)     // Rd
+                      | (BITS(tinstr, 0, 2) << 12) // Rd
-                | BITS(tinstr, 3, 5);            // Rm
+                      | BITS(tinstr, 3, 5);        // Rm
        } else if ((tinstr & 0x0F00) == 0x600) {
            if (BIT(tinstr, 5) == 0) {
                // SETEND
-                *ainstr = 0xF1010000         // base
+                *ainstr = 0xF1010000               // base
-                    | (BIT(tinstr, 3) << 9); // endian specifier
+                          | (BIT(tinstr, 3) << 9); // endian specifier
            } else {
                // CPS
-                *ainstr = 0xF1080000          // base
+                *ainstr = 0xF1080000                // base
-                    | (BIT(tinstr, 0) << 6)   // fiq bit
+                          | (BIT(tinstr, 0) << 6)   // fiq bit
-                    | (BIT(tinstr, 1) << 7)   // irq bit
+                          | (BIT(tinstr, 1) << 7)   // irq bit
-                    | (BIT(tinstr, 2) << 8)   // abort bit
+                          | (BIT(tinstr, 2) << 8)   // abort bit
-                    | (BIT(tinstr, 4) << 18); // enable bit
+                          | (BIT(tinstr, 4) << 18); // enable bit
            }
        } else if ((tinstr & 0x0F00) == 0x0a00) {
            static const u32 subset[4] = {
@@ -307,9 +298,9 @@ ThumbDecodeStatus TranslateThumbInstruction(u32 addr, u32 instr, u32* ainstr, u3
            if (subset_index == 2) {
                valid = ThumbDecodeStatus::UNDEFINED;
            } else {
-                *ainstr = subset[subset_index]       // base
+                *ainstr = subset[subset_index]         // base
-                    | (BITS(tinstr, 0, 2) << 12)     // Rd
+                          | (BITS(tinstr, 0, 2) << 12) // Rd
-                    | BITS(tinstr, 3, 5);            // Rm
+                          | BITS(tinstr, 3, 5);        // Rm
            }
        } else {
            static const u32 subset[4] = {
@@ -319,14 +310,13 @@ ThumbDecodeStatus TranslateThumbInstruction(u32 addr, u32 instr, u32* ainstr, u3
                0xE8BD8000  // LDMIA sp!,{rlist,pc}
            };
            *ainstr = subset[((tinstr & (1 << 11)) >> 10) | ((tinstr & (1 << 8)) >> 8)] // base
-                |(tinstr & 0x00FF); // mask8
+                      | (tinstr & 0x00FF);                                              // mask8
        }
        break;
    case 24: //  STMIA
    case 25: //  LDMIA
-        if (tinstr & (1 << 11))
+        if (tinstr & (1 << 11)) {
-        {
            unsigned int base = 0xE8900000;
            unsigned int rn = BITS(tinstr, 8, 10);
@@ -334,15 +324,13 @@ ThumbDecodeStatus TranslateThumbInstruction(u32 addr, u32 instr, u32* ainstr, u3
            if ((tinstr & (1 << rn)) == 0)
                base |= (1 << 21);
-            *ainstr = base           // base (LDMIA)
+            *ainstr = base                 // base (LDMIA)
-                | (rn << 16)         // Rn
+                      | (rn << 16)         // Rn
-                | (tinstr & 0x00FF); // Register list
+                      | (tinstr & 0x00FF); // Register list
-        }
+        } else {
-        else
+            *ainstr = 0xE8A00000                    // base (STMIA)
-        {
+                      | (BITS(tinstr, 8, 10) << 16) // Rn
-            *ainstr = 0xE8A00000              // base (STMIA)
+                      | (tinstr & 0x00FF);          // Register list
-                | (BITS(tinstr, 8, 10) << 16) // Rn
-                | (tinstr & 0x00FF);          // Register list
        }
        break;
diff --git a/src/core/arm/dyncom/arm_dyncom_thumb.h b/src/core/arm/dyncom/arm_dyncom_thumb.h
index c1be3c735..231e48aa4 100644
--- a/src/core/arm/dyncom/arm_dyncom_thumb.h
+++ b/src/core/arm/dyncom/arm_dyncom_thumb.h
@@ -29,9 +29,9 @@
 #include "common/common_types.h"
 enum class ThumbDecodeStatus {
-    UNDEFINED,    // Undefined Thumb instruction
+    UNDEFINED, // Undefined Thumb instruction
-    DECODED,      // Instruction decoded to ARM equivalent
+    DECODED,   // Instruction decoded to ARM equivalent
-    BRANCH,       // Thumb branch (already processed)
+    BRANCH,    // Thumb branch (already processed)
    UNINITIALIZED,
 };
diff --git a/src/core/arm/dyncom/arm_dyncom_trans.cpp b/src/core/arm/dyncom/arm_dyncom_trans.cpp
index 00b42c246..e056d890c 100644
--- a/src/core/arm/dyncom/arm_dyncom_trans.cpp
+++ b/src/core/arm/dyncom/arm_dyncom_trans.cpp
@@ -19,24 +19,23 @@ static void* AllocBuffer(size_t size) {
    return static_cast<void*>(&trans_cache_buf[start]);
 }
-#define glue(x, y) x ## y
+#define glue(x, y) x##y
 #define INTERPRETER_TRANSLATE(s) glue(InterpreterTranslate_, s)
 shtop_fp_t GetShifterOp(unsigned int inst);
 get_addr_fp_t GetAddressingOp(unsigned int inst);
 get_addr_fp_t GetAddressingOpLoadStoreT(unsigned int inst);
-static ARM_INST_PTR INTERPRETER_TRANSLATE(adc)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(adc)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(adc_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(adc_inst));
+    adc_inst* inst_cream = (adc_inst*)inst_base->component;
-    adc_inst *inst_cream = (adc_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->I  = BIT(inst, 25);
+    inst_cream->I = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
    inst_cream->Rn = BITS(inst, 16, 19);
    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->shifter_operand = BITS(inst, 0, 11);
@@ -47,17 +46,16 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(adc)(unsigned int inst, int index)
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(add)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(add)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(add_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(add_inst));
+    add_inst* inst_cream = (add_inst*)inst_base->component;
-    add_inst *inst_cream = (add_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->I  = BIT(inst, 25);
+    inst_cream->I = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
    inst_cream->Rn = BITS(inst, 16, 19);
    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->shifter_operand = BITS(inst, 0, 11);
@@ -68,17 +66,16 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(add)(unsigned int inst, int index)
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(and)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(and)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(and_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(and_inst));
+    and_inst* inst_cream = (and_inst*)inst_base->component;
-    and_inst *inst_cream = (and_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->I  = BIT(inst, 25);
+    inst_cream->I = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
    inst_cream->Rn = BITS(inst, 16, 19);
    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->shifter_operand = BITS(inst, 0, 11);
@@ -89,37 +86,35 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(and)(unsigned int inst, int index)
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(bbl)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(bbl)(unsigned int inst, int index) {
-{
+#define POSBRANCH ((inst & 0x7fffff) << 2)
-    #define POSBRANCH ((inst & 0x7fffff) << 2)
+#define NEGBRANCH ((0xff000000 | (inst & 0xffffff)) << 2)
-    #define NEGBRANCH ((0xff000000 |(inst & 0xffffff)) << 2)
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(bbl_inst));
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(bbl_inst));
-    bbl_inst *inst_cream = (bbl_inst *)inst_base->component;
+    bbl_inst* inst_cream = (bbl_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::DIRECT_BRANCH;
+    inst_base->br = TransExtData::DIRECT_BRANCH;
    if (BIT(inst, 24))
        inst_base->br = TransExtData::CALL;
-    inst_cream->L      = BIT(inst, 24);
+    inst_cream->L = BIT(inst, 24);
    inst_cream->signed_immed_24 = BIT(inst, 23) ? NEGBRANCH : POSBRANCH;
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(bic)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(bic)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(bic_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(bic_inst));
+    bic_inst* inst_cream = (bic_inst*)inst_base->component;
-    bic_inst *inst_cream = (bic_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->I  = BIT(inst, 25);
+    inst_cream->I = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
    inst_cream->Rn = BITS(inst, 16, 19);
    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->shifter_operand = BITS(inst, 0, 11);
@@ -130,28 +125,26 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(bic)(unsigned int inst, int index)
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(bkpt)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(bkpt)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(bkpt_inst));
    bkpt_inst* const inst_cream = (bkpt_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->imm = (BITS(inst, 8, 19) << 4) | BITS(inst, 0, 3);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(blx)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(blx)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(blx_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(blx_inst));
+    blx_inst* inst_cream = (blx_inst*)inst_base->component;
-    blx_inst *inst_cream = (blx_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::INDIRECT_BRANCH;
+    inst_base->br = TransExtData::INDIRECT_BRANCH;
    inst_cream->inst = inst;
    if (BITS(inst, 20, 27) == 0x12 && BITS(inst, 4, 7) == 0x3) {
@@ -162,36 +155,34 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(blx)(unsigned int inst, int index)
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(bx)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(bx)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(bx_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(bx_inst));
+    bx_inst* inst_cream = (bx_inst*)inst_base->component;
-    bx_inst *inst_cream = (bx_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::INDIRECT_BRANCH;
+    inst_base->br = TransExtData::INDIRECT_BRANCH;
-    inst_cream->Rm  = BITS(inst, 0, 3);
+    inst_cream->Rm = BITS(inst, 0, 3);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(bxj)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(bxj)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(bx)(inst, index);
 }
 static ARM_INST_PTR INTERPRETER_TRANSLATE(cdp)(unsigned int inst, int index) {
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(cdp_inst));
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(cdp_inst));
-    cdp_inst *inst_cream = (cdp_inst *)inst_base->component;
+    cdp_inst* inst_cream = (cdp_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->CRm      = BITS(inst,  0,  3);
+    inst_cream->CRm = BITS(inst, 0, 3);
-    inst_cream->CRd      = BITS(inst, 12, 15);
+    inst_cream->CRd = BITS(inst, 12, 15);
-    inst_cream->CRn      = BITS(inst, 16, 19);
+    inst_cream->CRn = BITS(inst, 16, 19);
-    inst_cream->cp_num   = BITS(inst, 8, 11);
+    inst_cream->cp_num = BITS(inst, 8, 11);
    inst_cream->opcode_2 = BITS(inst, 5, 7);
    inst_cream->opcode_1 = BITS(inst, 20, 23);
    inst_cream->inst = inst;
@@ -199,91 +190,85 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(cdp)(unsigned int inst, int index) {
    LOG_TRACE(Core_ARM11, "inst %x index %x", inst, index);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(clrex)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(clrex)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(clrex_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(clrex_inst));
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(clz)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(clz)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(clz_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(clz_inst));
+    clz_inst* inst_cream = (clz_inst*)inst_base->component;
-    clz_inst *inst_cream = (clz_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rm = BITS(inst,  0,  3);
+    inst_cream->Rm = BITS(inst, 0, 3);
    inst_cream->Rd = BITS(inst, 12, 15);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(cmn)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(cmn)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(cmn_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(cmn_inst));
+    cmn_inst* inst_cream = (cmn_inst*)inst_base->component;
-    cmn_inst *inst_cream = (cmn_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->I  = BIT(inst, 25);
+    inst_cream->I = BIT(inst, 25);
    inst_cream->Rn = BITS(inst, 16, 19);
    inst_cream->shifter_operand = BITS(inst, 0, 11);
    inst_cream->shtop_func = GetShifterOp(inst);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(cmp)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(cmp)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(cmp_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(cmp_inst));
+    cmp_inst* inst_cream = (cmp_inst*)inst_base->component;
-    cmp_inst *inst_cream = (cmp_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->I  = BIT(inst, 25);
+    inst_cream->I = BIT(inst, 25);
    inst_cream->Rn = BITS(inst, 16, 19);
    inst_cream->shifter_operand = BITS(inst, 0, 11);
    inst_cream->shtop_func = GetShifterOp(inst);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(cps)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(cps)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(cps_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(cps_inst));
+    cps_inst* inst_cream = (cps_inst*)inst_base->component;
-    cps_inst *inst_cream = (cps_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->imod0 = BIT(inst, 18);
    inst_cream->imod1 = BIT(inst, 19);
-    inst_cream->mmod  = BIT(inst, 17);
+    inst_cream->mmod = BIT(inst, 17);
-    inst_cream->A     = BIT(inst, 8);
+    inst_cream->A = BIT(inst, 8);
-    inst_cream->I     = BIT(inst, 7);
+    inst_cream->I = BIT(inst, 7);
-    inst_cream->F     = BIT(inst, 6);
+    inst_cream->F = BIT(inst, 6);
-    inst_cream->mode  = BITS(inst, 0, 4);
+    inst_cream->mode = BITS(inst, 0, 4);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(cpy)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(cpy)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(mov_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(mov_inst));
+    mov_inst* inst_cream = (mov_inst*)inst_base->component;
-    mov_inst *inst_cream = (mov_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->I  = BIT(inst, 25);
+    inst_cream->I = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->shifter_operand = BITS(inst, 0, 11);
    inst_cream->shtop_func = GetShifterOp(inst);
@@ -293,17 +278,16 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(cpy)(unsigned int inst, int index)
    }
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(eor)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(eor)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(eor_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(eor_inst));
+    eor_inst* inst_cream = (eor_inst*)inst_base->component;
-    eor_inst *inst_cream = (eor_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->I  = BIT(inst, 25);
+    inst_cream->I = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
    inst_cream->Rn = BITS(inst, 16, 19);
    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->shifter_operand = BITS(inst, 0, 11);
@@ -314,23 +298,21 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(eor)(unsigned int inst, int index)
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ldc)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ldc)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldc_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldc_inst));
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ldm)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ldm)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOp(inst);
@@ -340,29 +322,27 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(ldm)(unsigned int inst, int index)
    }
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(sxth)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(sxth)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(sxtb_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(sxtb_inst));
+    sxtb_inst* inst_cream = (sxtb_inst*)inst_base->component;
-    sxtb_inst *inst_cream = (sxtb_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rd     = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
-    inst_cream->Rm     = BITS(inst,  0,  3);
+    inst_cream->Rm = BITS(inst, 0, 3);
    inst_cream->rotate = BITS(inst, 10, 11);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ldr)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ldr)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOp(inst);
@@ -373,14 +353,13 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(ldr)(unsigned int inst, int index)
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrcond)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrcond)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOp(inst);
@@ -391,155 +370,143 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrcond)(unsigned int inst, int index)
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uxth)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uxth)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(uxth_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(uxth_inst));
+    uxth_inst* inst_cream = (uxth_inst*)inst_base->component;
-    uxth_inst *inst_cream = (uxth_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rd     = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->rotate = BITS(inst, 10, 11);
-    inst_cream->Rm     = BITS(inst,  0,  3);
+    inst_cream->Rm = BITS(inst, 0, 3);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uxtah)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uxtah)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(uxtah_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(uxtah_inst));
+    uxtah_inst* inst_cream = (uxtah_inst*)inst_base->component;
-    uxtah_inst *inst_cream = (uxtah_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rn     = BITS(inst, 16, 19);
+    inst_cream->Rn = BITS(inst, 16, 19);
-    inst_cream->Rd     = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->rotate = BITS(inst, 10, 11);
-    inst_cream->Rm     = BITS(inst,  0,  3);
+    inst_cream->Rm = BITS(inst, 0, 3);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrb)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrb)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOp(inst);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrbt)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrbt)(unsigned int inst, int index) {
-{
    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOpLoadStoreT(inst);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrd)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrd)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOp(inst);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrex)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrex)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(generic_arm_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(generic_arm_inst));
+    generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
-    generic_arm_inst *inst_cream = (generic_arm_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = (BITS(inst, 12, 15) == 15) ? TransExtData::INDIRECT_BRANCH : TransExtData::NON_BRANCH; // Branch if dest is R15
+    inst_base->br = (BITS(inst, 12, 15) == 15) ? TransExtData::INDIRECT_BRANCH
+                                               : TransExtData::NON_BRANCH; // Branch if dest is R15
    inst_cream->Rn = BITS(inst, 16, 19);
    inst_cream->Rd = BITS(inst, 12, 15);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrexb)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrexb)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(ldrex)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrexh)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrexh)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(ldrex)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrexd)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrexd)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(ldrex)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrh)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrh)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOp(inst);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrsb)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrsb)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOp(inst);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrsh)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrsh)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOp(inst);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrt)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrt)(unsigned int inst, int index) {
-{
    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOpLoadStoreT(inst);
@@ -549,70 +516,66 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(ldrt)(unsigned int inst, int index)
    }
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(mcr)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(mcr)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(mcr_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(mcr_inst));
+    mcr_inst* inst_cream = (mcr_inst*)inst_base->component;
-    mcr_inst *inst_cream = (mcr_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->crn      = BITS(inst, 16, 19);
+    inst_cream->crn = BITS(inst, 16, 19);
-    inst_cream->crm      = BITS(inst,  0,  3);
+    inst_cream->crm = BITS(inst, 0, 3);
    inst_cream->opcode_1 = BITS(inst, 21, 23);
-    inst_cream->opcode_2 = BITS(inst,  5,  7);
+    inst_cream->opcode_2 = BITS(inst, 5, 7);
-    inst_cream->Rd       = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
-    inst_cream->cp_num   = BITS(inst,  8, 11);
+    inst_cream->cp_num = BITS(inst, 8, 11);
-    inst_cream->inst     = inst;
+    inst_cream->inst = inst;
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(mcrr)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(mcrr)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(mcrr_inst));
    mcrr_inst* const inst_cream = (mcrr_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->crm      = BITS(inst, 0, 3);
+    inst_cream->crm = BITS(inst, 0, 3);
    inst_cream->opcode_1 = BITS(inst, 4, 7);
-    inst_cream->cp_num   = BITS(inst, 8, 11);
+    inst_cream->cp_num = BITS(inst, 8, 11);
-    inst_cream->rt       = BITS(inst, 12, 15);
+    inst_cream->rt = BITS(inst, 12, 15);
-    inst_cream->rt2      = BITS(inst, 16, 19);
+    inst_cream->rt2 = BITS(inst, 16, 19);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(mla)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(mla)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(mla_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(mla_inst));
+    mla_inst* inst_cream = (mla_inst*)inst_base->component;
-    mla_inst *inst_cream = (mla_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
    inst_cream->Rn = BITS(inst, 12, 15);
    inst_cream->Rd = BITS(inst, 16, 19);
-    inst_cream->Rs = BITS(inst,  8, 11);
+    inst_cream->Rs = BITS(inst, 8, 11);
-    inst_cream->Rm = BITS(inst,  0,  3);
+    inst_cream->Rm = BITS(inst, 0, 3);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(mov)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(mov)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(mov_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(mov_inst));
+    mov_inst* inst_cream = (mov_inst*)inst_base->component;
-    mov_inst *inst_cream = (mov_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->I  = BIT(inst, 25);
+    inst_cream->I = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->shifter_operand = BITS(inst, 0, 11);
    inst_cream->shtop_func = GetShifterOp(inst);
@@ -622,85 +585,79 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(mov)(unsigned int inst, int index)
    }
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(mrc)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(mrc)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(mrc_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(mrc_inst));
+    mrc_inst* inst_cream = (mrc_inst*)inst_base->component;
-    mrc_inst *inst_cream = (mrc_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->crn      = BITS(inst, 16, 19);
+    inst_cream->crn = BITS(inst, 16, 19);
-    inst_cream->crm      = BITS(inst,  0,  3);
+    inst_cream->crm = BITS(inst, 0, 3);
    inst_cream->opcode_1 = BITS(inst, 21, 23);
-    inst_cream->opcode_2 = BITS(inst,  5,  7);
+    inst_cream->opcode_2 = BITS(inst, 5, 7);
-    inst_cream->Rd       = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
-    inst_cream->cp_num   = BITS(inst,  8, 11);
+    inst_cream->cp_num = BITS(inst, 8, 11);
-    inst_cream->inst     = inst;
+    inst_cream->inst = inst;
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(mrrc)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(mrrc)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(mcrr)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(mrs)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(mrs)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(mrs_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(mrs_inst));
+    mrs_inst* inst_cream = (mrs_inst*)inst_base->component;
-    mrs_inst *inst_cream = (mrs_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->Rd = BITS(inst, 12, 15);
-    inst_cream->R  = BIT(inst, 22);
+    inst_cream->R = BIT(inst, 22);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(msr)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(msr)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(msr_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(msr_inst));
+    msr_inst* inst_cream = (msr_inst*)inst_base->component;
-    msr_inst *inst_cream = (msr_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->field_mask = BITS(inst, 16, 19);
-    inst_cream->R          = BIT(inst, 22);
+    inst_cream->R = BIT(inst, 22);
-    inst_cream->inst       = inst;
+    inst_cream->inst = inst;
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(mul)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(mul)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(mul_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(mul_inst));
+    mul_inst* inst_cream = (mul_inst*)inst_base->component;
-    mul_inst *inst_cream = (mul_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
    inst_cream->Rm = BITS(inst, 0, 3);
    inst_cream->Rs = BITS(inst, 8, 11);
    inst_cream->Rd = BITS(inst, 16, 19);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(mvn)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(mvn)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(mvn_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(mvn_inst));
+    mvn_inst* inst_cream = (mvn_inst*)inst_base->component;
-    mvn_inst *inst_cream = (mvn_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->I  = BIT(inst, 25);
+    inst_cream->I = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->shifter_operand = BITS(inst, 0, 11);
    inst_cream->shtop_func = GetShifterOp(inst);
@@ -709,19 +666,17 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(mvn)(unsigned int inst, int index)
        inst_base->br = TransExtData::INDIRECT_BRANCH;
    }
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(orr)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(orr)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(orr_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(orr_inst));
+    orr_inst* inst_cream = (orr_inst*)inst_base->component;
-    orr_inst *inst_cream = (orr_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->I  = BIT(inst, 25);
+    inst_cream->I = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->Rn = BITS(inst, 16, 19);
    inst_cream->shifter_operand = BITS(inst, 0, 11);
@@ -734,150 +689,132 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(orr)(unsigned int inst, int index)
 }
 // NOP introduced in ARMv6K.
-static ARM_INST_PTR INTERPRETER_TRANSLATE(nop)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(nop)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst));
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(pkhbt)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(pkhbt)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(pkh_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(pkh_inst));
+    pkh_inst* inst_cream = (pkh_inst*)inst_base->component;
-    pkh_inst *inst_cream = (pkh_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
-    inst_cream->Rn  = BITS(inst, 16, 19);
+    inst_cream->Rn = BITS(inst, 16, 19);
-    inst_cream->Rm  = BITS(inst, 0, 3);
+    inst_cream->Rm = BITS(inst, 0, 3);
    inst_cream->imm = BITS(inst, 7, 11);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(pkhtb)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(pkhtb)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(pkhbt)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(pld)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(pld)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(pld_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(pld_inst));
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(qadd)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(qadd)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(generic_arm_inst));
    generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->op1 = BITS(inst, 21, 22);
-    inst_cream->Rm  = BITS(inst, 0, 3);
+    inst_cream->Rm = BITS(inst, 0, 3);
-    inst_cream->Rn  = BITS(inst, 16, 19);
+    inst_cream->Rn = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(qdadd)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(qdadd)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(qadd)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(qdsub)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(qdsub)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(qadd)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(qsub)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(qsub)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(qadd)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(qadd8)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(qadd8)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(generic_arm_inst));
    generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rm  = BITS(inst, 0, 3);
+    inst_cream->Rm = BITS(inst, 0, 3);
-    inst_cream->Rn  = BITS(inst, 16, 19);
+    inst_cream->Rn = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->op1 = BITS(inst, 20, 21);
    inst_cream->op2 = BITS(inst, 5, 7);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(qadd16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(qadd16)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(qadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(qaddsubx)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(qaddsubx)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(qadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(qsub8)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(qsub8)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(qadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(qsub16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(qsub16)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(qadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(qsubaddx)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(qsubaddx)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(qadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(rev)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(rev)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(rev_inst));
    rev_inst* const inst_cream = (rev_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rm  = BITS(inst,  0,  3);
+    inst_cream->Rm = BITS(inst, 0, 3);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->op1 = BITS(inst, 20, 22);
    inst_cream->op2 = BITS(inst, 5, 7);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(rev16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(rev16)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(rev)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(revsh)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(revsh)(unsigned int inst, int index) {
-{
+    return INTERPRETER_TRANSLATE(rev)(inst, index);
-     return INTERPRETER_TRANSLATE(rev)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(rfe)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(rfe)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
    ldst_inst* const inst_cream = (ldst_inst*)inst_base->component;
    inst_base->cond = AL;
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::INDIRECT_BRANCH;
+    inst_base->br = TransExtData::INDIRECT_BRANCH;
    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOp(inst);
@@ -885,17 +822,16 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(rfe)(unsigned int inst, int index)
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(rsb)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(rsb)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(rsb_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(rsb_inst));
+    rsb_inst* inst_cream = (rsb_inst*)inst_base->component;
-    rsb_inst *inst_cream = (rsb_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->I  = BIT(inst, 25);
+    inst_cream->I = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
    inst_cream->Rn = BITS(inst, 16, 19);
    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->shifter_operand = BITS(inst, 0, 11);
@@ -906,17 +842,16 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(rsb)(unsigned int inst, int index)
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(rsc)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(rsc)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(rsc_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(rsc_inst));
+    rsc_inst* inst_cream = (rsc_inst*)inst_base->component;
-    rsc_inst *inst_cream = (rsc_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->I  = BIT(inst, 25);
+    inst_cream->I = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
    inst_cream->Rn = BITS(inst, 16, 19);
    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->shifter_operand = BITS(inst, 0, 11);
@@ -927,55 +862,48 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(rsc)(unsigned int inst, int index)
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(sadd8)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(sadd8)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(generic_arm_inst));
    generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rm  = BITS(inst, 0, 3);
+    inst_cream->Rm = BITS(inst, 0, 3);
-    inst_cream->Rn  = BITS(inst, 16, 19);
+    inst_cream->Rn = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->op1 = BITS(inst, 20, 21);
    inst_cream->op2 = BITS(inst, 5, 7);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(sadd16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(sadd16)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(sadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(saddsubx)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(saddsubx)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(sadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ssub8)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ssub8)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(sadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ssub16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ssub16)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(sadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ssubaddx)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ssubaddx)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(sadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(sbc)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(sbc)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(sbc_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(sbc_inst));
+    sbc_inst* inst_cream = (sbc_inst*)inst_base->component;
-    sbc_inst *inst_cream = (sbc_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->I  = BIT(inst, 25);
+    inst_cream->I = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
    inst_cream->Rn = BITS(inst, 16, 19);
    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->shifter_operand = BITS(inst, 0, 11);
@@ -986,98 +914,88 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(sbc)(unsigned int inst, int index)
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(sel)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(sel)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(generic_arm_inst));
    generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rm  = BITS(inst, 0, 3);
+    inst_cream->Rm = BITS(inst, 0, 3);
-    inst_cream->Rn  = BITS(inst, 16, 19);
+    inst_cream->Rn = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->op1 = BITS(inst, 20, 22);
    inst_cream->op2 = BITS(inst, 5, 7);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(setend)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(setend)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(setend_inst));
    setend_inst* const inst_cream = (setend_inst*)inst_base->component;
    inst_base->cond = AL;
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->set_bigend = BIT(inst, 9);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(sev)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(sev)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst));
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(shadd8)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(shadd8)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(generic_arm_inst));
    generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->op1 = BITS(inst, 20, 21);
    inst_cream->op2 = BITS(inst, 5, 7);
-    inst_cream->Rm  = BITS(inst, 0, 3);
+    inst_cream->Rm = BITS(inst, 0, 3);
-    inst_cream->Rn  = BITS(inst, 16, 19);
+    inst_cream->Rn = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(shadd16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(shadd16)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(shadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(shaddsubx)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(shaddsubx)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(shadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(shsub8)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(shsub8)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(shadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(shsub16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(shsub16)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(shadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(shsubaddx)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(shsubaddx)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(shadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(smla)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(smla)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(smla_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(smla_inst));
+    smla_inst* inst_cream = (smla_inst*)inst_base->component;
-    smla_inst *inst_cream = (smla_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->x  = BIT(inst, 5);
+    inst_cream->x = BIT(inst, 5);
-    inst_cream->y  = BIT(inst, 6);
+    inst_cream->y = BIT(inst, 6);
    inst_cream->Rm = BITS(inst, 0, 3);
    inst_cream->Rs = BITS(inst, 8, 11);
    inst_cream->Rd = BITS(inst, 16, 19);
@@ -1086,192 +1004,176 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(smla)(unsigned int inst, int index)
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(smlad)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(smlad)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(smlad_inst));
    smlad_inst* const inst_cream = (smlad_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->m   = BIT(inst, 5);
+    inst_cream->m = BIT(inst, 5);
-    inst_cream->Rn  = BITS(inst, 0, 3);
+    inst_cream->Rn = BITS(inst, 0, 3);
-    inst_cream->Rm  = BITS(inst, 8, 11);
+    inst_cream->Rm = BITS(inst, 8, 11);
-    inst_cream->Rd  = BITS(inst, 16, 19);
+    inst_cream->Rd = BITS(inst, 16, 19);
-    inst_cream->Ra  = BITS(inst, 12, 15);
+    inst_cream->Ra = BITS(inst, 12, 15);
    inst_cream->op1 = BITS(inst, 20, 22);
    inst_cream->op2 = BITS(inst, 5, 7);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(smuad)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(smuad)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(smlad)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(smusd)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(smusd)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(smlad)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(smlsd)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(smlsd)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(smlad)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(smlal)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(smlal)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(umlal_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(umlal_inst));
+    umlal_inst* inst_cream = (umlal_inst*)inst_base->component;
-    umlal_inst *inst_cream = (umlal_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->S    = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
-    inst_cream->Rm   = BITS(inst, 0, 3);
+    inst_cream->Rm = BITS(inst, 0, 3);
-    inst_cream->Rs   = BITS(inst, 8, 11);
+    inst_cream->Rs = BITS(inst, 8, 11);
    inst_cream->RdHi = BITS(inst, 16, 19);
    inst_cream->RdLo = BITS(inst, 12, 15);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(smlalxy)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(smlalxy)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(smlalxy_inst));
    smlalxy_inst* const inst_cream = (smlalxy_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->x    = BIT(inst, 5);
+    inst_cream->x = BIT(inst, 5);
-    inst_cream->y    = BIT(inst, 6);
+    inst_cream->y = BIT(inst, 6);
    inst_cream->RdLo = BITS(inst, 12, 15);
    inst_cream->RdHi = BITS(inst, 16, 19);
-    inst_cream->Rn   = BITS(inst, 0, 4);
+    inst_cream->Rn = BITS(inst, 0, 4);
-    inst_cream->Rm   = BITS(inst, 8, 11);
+    inst_cream->Rm = BITS(inst, 8, 11);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(smlaw)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(smlaw)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(smlad_inst));
    smlad_inst* const inst_cream = (smlad_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->Ra = BITS(inst, 12, 15);
    inst_cream->Rm = BITS(inst, 8, 11);
    inst_cream->Rn = BITS(inst, 0, 3);
    inst_cream->Rd = BITS(inst, 16, 19);
-    inst_cream->m  = BIT(inst, 6);
+    inst_cream->m = BIT(inst, 6);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(smlald)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(smlald)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(smlald_inst));
    smlald_inst* const inst_cream = (smlald_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rm   = BITS(inst, 8, 11);
+    inst_cream->Rm = BITS(inst, 8, 11);
-    inst_cream->Rn   = BITS(inst, 0, 3);
+    inst_cream->Rn = BITS(inst, 0, 3);
    inst_cream->RdLo = BITS(inst, 12, 15);
    inst_cream->RdHi = BITS(inst, 16, 19);
    inst_cream->swap = BIT(inst, 5);
-    inst_cream->op1  = BITS(inst, 20, 22);
+    inst_cream->op1 = BITS(inst, 20, 22);
-    inst_cream->op2  = BITS(inst, 5, 7);
+    inst_cream->op2 = BITS(inst, 5, 7);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(smlsld)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(smlsld)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(smlald)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(smmla)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(smmla)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(smlad_inst));
    smlad_inst* const inst_cream = (smlad_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->m   = BIT(inst, 5);
+    inst_cream->m = BIT(inst, 5);
-    inst_cream->Ra  = BITS(inst, 12, 15);
+    inst_cream->Ra = BITS(inst, 12, 15);
-    inst_cream->Rm  = BITS(inst, 8, 11);
+    inst_cream->Rm = BITS(inst, 8, 11);
-    inst_cream->Rn  = BITS(inst, 0, 3);
+    inst_cream->Rn = BITS(inst, 0, 3);
-    inst_cream->Rd  = BITS(inst, 16, 19);
+    inst_cream->Rd = BITS(inst, 16, 19);
    inst_cream->op1 = BITS(inst, 20, 22);
    inst_cream->op2 = BITS(inst, 5, 7);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(smmls)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(smmls)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(smmla)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(smmul)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(smmul)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(smmla)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(smul)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(smul)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(smul_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(smul_inst));
+    smul_inst* inst_cream = (smul_inst*)inst_base->component;
-    smul_inst *inst_cream = (smul_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->Rd = BITS(inst, 16, 19);
-    inst_cream->Rs = BITS(inst,  8, 11);
+    inst_cream->Rs = BITS(inst, 8, 11);
-    inst_cream->Rm = BITS(inst,  0,  3);
+    inst_cream->Rm = BITS(inst, 0, 3);
-    inst_cream->x  = BIT(inst, 5);
+    inst_cream->x = BIT(inst, 5);
-    inst_cream->y  = BIT(inst, 6);
+    inst_cream->y = BIT(inst, 6);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(smull)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(smull)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(umull_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(umull_inst));
+    umull_inst* inst_cream = (umull_inst*)inst_base->component;
-    umull_inst *inst_cream = (umull_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->S    = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
-    inst_cream->Rm   = BITS(inst, 0, 3);
+    inst_cream->Rm = BITS(inst, 0, 3);
-    inst_cream->Rs   = BITS(inst, 8, 11);
+    inst_cream->Rs = BITS(inst, 8, 11);
    inst_cream->RdHi = BITS(inst, 16, 19);
    inst_cream->RdLo = BITS(inst, 12, 15);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(smulw)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(smulw)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(smlad_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(smlad_inst));
+    smlad_inst* inst_cream = (smlad_inst*)inst_base->component;
-    smlad_inst *inst_cream = (smlad_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->m  = BIT(inst, 6);
+    inst_cream->m = BIT(inst, 6);
    inst_cream->Rm = BITS(inst, 8, 11);
    inst_cream->Rn = BITS(inst, 0, 3);
    inst_cream->Rd = BITS(inst, 16, 19);
@@ -1279,29 +1181,27 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(smulw)(unsigned int inst, int index)
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(srs)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(srs)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
    ldst_inst* const inst_cream = (ldst_inst*)inst_base->component;
    inst_base->cond = AL;
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->inst     = inst;
+    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOp(inst);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ssat)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ssat)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ssat_inst));
    ssat_inst* const inst_cream = (ssat_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->Rn = BITS(inst, 0, 3);
    inst_cream->Rd = BITS(inst, 12, 15);
@@ -1311,211 +1211,195 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(ssat)(unsigned int inst, int index)
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(ssat16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(ssat16)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ssat_inst));
    ssat_inst* const inst_cream = (ssat_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rn      = BITS(inst, 0, 3);
+    inst_cream->Rn = BITS(inst, 0, 3);
-    inst_cream->Rd      = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->sat_imm = BITS(inst, 16, 19);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(stc)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(stc)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(stc_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(stc_inst));
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(stm)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(stm)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOp(inst);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(sxtb)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(sxtb)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(sxtb_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(sxtb_inst));
+    sxtb_inst* inst_cream = (sxtb_inst*)inst_base->component;
-    sxtb_inst *inst_cream = (sxtb_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rd     = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
-    inst_cream->Rm     = BITS(inst,  0,  3);
+    inst_cream->Rm = BITS(inst, 0, 3);
    inst_cream->rotate = BITS(inst, 10, 11);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(str)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(str)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOp(inst);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uxtb)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uxtb)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(uxth_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(uxth_inst));
+    uxth_inst* inst_cream = (uxth_inst*)inst_base->component;
-    uxth_inst *inst_cream = (uxth_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rd     = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->rotate = BITS(inst, 10, 11);
-    inst_cream->Rm     = BITS(inst,  0,  3);
+    inst_cream->Rm = BITS(inst, 0, 3);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uxtab)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uxtab)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(uxtab_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(uxtab_inst));
+    uxtab_inst* inst_cream = (uxtab_inst*)inst_base->component;
-    uxtab_inst *inst_cream = (uxtab_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rd     = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->rotate = BITS(inst, 10, 11);
-    inst_cream->Rm     = BITS(inst,  0,  3);
+    inst_cream->Rm = BITS(inst, 0, 3);
-    inst_cream->Rn     = BITS(inst, 16, 19);
+    inst_cream->Rn = BITS(inst, 16, 19);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(strb)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(strb)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOp(inst);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(strbt)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(strbt)(unsigned int inst, int index) {
-{
    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOpLoadStoreT(inst);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(strd)(unsigned int inst, int index){
+static ARM_INST_PTR INTERPRETER_TRANSLATE(strd)(unsigned int inst, int index) {
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOp(inst);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(strex)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(strex)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(generic_arm_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(generic_arm_inst));
+    generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
-    generic_arm_inst *inst_cream = (generic_arm_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rn  = BITS(inst, 16, 19);
+    inst_cream->Rn = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
-    inst_cream->Rm  = BITS(inst, 0,   3);
+    inst_cream->Rm = BITS(inst, 0, 3);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(strexb)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(strexb)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(strex)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(strexh)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(strexh)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(strex)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(strexd)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(strexd)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(strex)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(strh)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(strh)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOp(inst);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(strt)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(strt)(unsigned int inst, int index) {
-{
    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->inst = inst;
    inst_cream->get_addr = GetAddressingOpLoadStoreT(inst);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(sub)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(sub)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(sub_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(sub_inst));
+    sub_inst* inst_cream = (sub_inst*)inst_base->component;
-    sub_inst *inst_cream = (sub_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->I  = BIT(inst, 25);
+    inst_cream->I = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
    inst_cream->Rn = BITS(inst, 16, 19);
    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->shifter_operand = BITS(inst, 0, 11);
@@ -1526,71 +1410,68 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(sub)(unsigned int inst, int index)
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(swi)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(swi)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(swi_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(swi_inst));
+    swi_inst* inst_cream = (swi_inst*)inst_base->component;
-    swi_inst *inst_cream = (swi_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->num = BITS(inst, 0, 23);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(swp)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(swp)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(swp_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(swp_inst));
+    swp_inst* inst_cream = (swp_inst*)inst_base->component;
-    swp_inst *inst_cream = (swp_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rn  = BITS(inst, 16, 19);
+    inst_cream->Rn = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
-    inst_cream->Rm  = BITS(inst,  0,  3);
+    inst_cream->Rm = BITS(inst, 0, 3);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(swpb)(unsigned int inst, int index){
+static ARM_INST_PTR INTERPRETER_TRANSLATE(swpb)(unsigned int inst, int index) {
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(swp_inst));
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(swp_inst));
-    swp_inst *inst_cream = (swp_inst *)inst_base->component;
+    swp_inst* inst_cream = (swp_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rn  = BITS(inst, 16, 19);
+    inst_cream->Rn = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
-    inst_cream->Rm  = BITS(inst,  0,  3);
+    inst_cream->Rm = BITS(inst, 0, 3);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(sxtab)(unsigned int inst, int index){
+static ARM_INST_PTR INTERPRETER_TRANSLATE(sxtab)(unsigned int inst, int index) {
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(sxtab_inst));
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(sxtab_inst));
-    sxtab_inst *inst_cream = (sxtab_inst *)inst_base->component;
+    sxtab_inst* inst_cream = (sxtab_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rd     = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->rotate = BITS(inst, 10, 11);
-    inst_cream->Rm     = BITS(inst,  0,  3);
+    inst_cream->Rm = BITS(inst, 0, 3);
-    inst_cream->Rn     = BITS(inst, 16, 19);
+    inst_cream->Rn = BITS(inst, 16, 19);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(sxtab16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(sxtab16)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(sxtab_inst));
    sxtab_inst* const inst_cream = (sxtab_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->Rm = BITS(inst, 0, 3);
    inst_cream->Rn = BITS(inst, 16, 19);
@@ -1599,54 +1480,51 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(sxtab16)(unsigned int inst, int index)
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(sxtb16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(sxtb16)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(sxtab16)(inst, index);
 }
 static ARM_INST_PTR INTERPRETER_TRANSLATE(sxtah)(unsigned int inst, int index) {
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(sxtah_inst));
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(sxtah_inst));
-    sxtah_inst *inst_cream = (sxtah_inst *)inst_base->component;
+    sxtah_inst* inst_cream = (sxtah_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rd     = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->rotate = BITS(inst, 10, 11);
-    inst_cream->Rm     = BITS(inst,  0,  3);
+    inst_cream->Rm = BITS(inst, 0, 3);
-    inst_cream->Rn     = BITS(inst, 16, 19);
+    inst_cream->Rn = BITS(inst, 16, 19);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(teq)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(teq)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(teq_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(teq_inst));
+    teq_inst* inst_cream = (teq_inst*)inst_base->component;
-    teq_inst *inst_cream = (teq_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->I               = BIT(inst, 25);
+    inst_cream->I = BIT(inst, 25);
-    inst_cream->Rn              = BITS(inst, 16, 19);
+    inst_cream->Rn = BITS(inst, 16, 19);
    inst_cream->shifter_operand = BITS(inst, 0, 11);
-    inst_cream->shtop_func      = GetShifterOp(inst);
+    inst_cream->shtop_func = GetShifterOp(inst);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(tst)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(tst)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(tst_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(tst_inst));
+    tst_inst* inst_cream = (tst_inst*)inst_base->component;
-    tst_inst *inst_cream = (tst_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->I  = BIT(inst, 25);
+    inst_cream->I = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
    inst_cream->Rn = BITS(inst, 16, 19);
    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->shifter_operand = BITS(inst, 0, 11);
@@ -1655,309 +1533,274 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(tst)(unsigned int inst, int index)
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uadd8)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uadd8)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(generic_arm_inst));
    generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->op1 = BITS(inst, 20, 21);
    inst_cream->op2 = BITS(inst, 5, 7);
-    inst_cream->Rm  = BITS(inst, 0, 3);
+    inst_cream->Rm = BITS(inst, 0, 3);
-    inst_cream->Rn  = BITS(inst, 16, 19);
+    inst_cream->Rn = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uadd16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uadd16)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(uadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uaddsubx)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uaddsubx)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(uadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(usub8)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(usub8)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(uadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(usub16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(usub16)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(uadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(usubaddx)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(usubaddx)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(uadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uhadd8)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uhadd8)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(generic_arm_inst));
    generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->op1 = BITS(inst, 20, 21);
    inst_cream->op2 = BITS(inst, 5, 7);
-    inst_cream->Rm  = BITS(inst, 0, 3);
+    inst_cream->Rm = BITS(inst, 0, 3);
-    inst_cream->Rn  = BITS(inst, 16, 19);
+    inst_cream->Rn = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uhadd16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uhadd16)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(uhadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uhaddsubx)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uhaddsubx)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(uhadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uhsub8)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uhsub8)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(uhadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uhsub16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uhsub16)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(uhadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uhsubaddx)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uhsubaddx)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(uhadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(umaal)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(umaal)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(umaal_inst));
    umaal_inst* const inst_cream = (umaal_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rm   = BITS(inst, 8, 11);
+    inst_cream->Rm = BITS(inst, 8, 11);
-    inst_cream->Rn   = BITS(inst, 0, 3);
+    inst_cream->Rn = BITS(inst, 0, 3);
    inst_cream->RdLo = BITS(inst, 12, 15);
    inst_cream->RdHi = BITS(inst, 16, 19);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(umlal)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(umlal)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(umlal_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(umlal_inst));
+    umlal_inst* inst_cream = (umlal_inst*)inst_base->component;
-    umlal_inst *inst_cream = (umlal_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->S    = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
-    inst_cream->Rm   = BITS(inst, 0, 3);
+    inst_cream->Rm = BITS(inst, 0, 3);
-    inst_cream->Rs   = BITS(inst, 8, 11);
+    inst_cream->Rs = BITS(inst, 8, 11);
    inst_cream->RdHi = BITS(inst, 16, 19);
    inst_cream->RdLo = BITS(inst, 12, 15);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(umull)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(umull)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(umull_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(umull_inst));
+    umull_inst* inst_cream = (umull_inst*)inst_base->component;
-    umull_inst *inst_cream = (umull_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->S    = BIT(inst, 20);
+    inst_cream->S = BIT(inst, 20);
-    inst_cream->Rm   = BITS(inst, 0, 3);
+    inst_cream->Rm = BITS(inst, 0, 3);
-    inst_cream->Rs   = BITS(inst, 8, 11);
+    inst_cream->Rs = BITS(inst, 8, 11);
    inst_cream->RdHi = BITS(inst, 16, 19);
    inst_cream->RdLo = BITS(inst, 12, 15);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(b_2_thumb)(unsigned int tinst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(b_2_thumb)(unsigned int tinst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(b_2_thumb));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(b_2_thumb));
+    b_2_thumb* inst_cream = (b_2_thumb*)inst_base->component;
-    b_2_thumb *inst_cream = (b_2_thumb *)inst_base->component;
    inst_cream->imm = ((tinst & 0x3FF) << 1) | ((tinst & (1 << 10)) ? 0xFFFFF800 : 0);
    inst_base->idx = index;
-    inst_base->br  = TransExtData::DIRECT_BRANCH;
+    inst_base->br = TransExtData::DIRECT_BRANCH;
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(b_cond_thumb)(unsigned int tinst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(b_cond_thumb)(unsigned int tinst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(b_cond_thumb));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(b_cond_thumb));
+    b_cond_thumb* inst_cream = (b_cond_thumb*)inst_base->component;
-    b_cond_thumb *inst_cream = (b_cond_thumb *)inst_base->component;
-    inst_cream->imm  = (((tinst & 0x7F) << 1) | ((tinst & (1 << 7)) ?    0xFFFFFF00 : 0));
+    inst_cream->imm = (((tinst & 0x7F) << 1) | ((tinst & (1 << 7)) ? 0xFFFFFF00 : 0));
    inst_cream->cond = ((tinst >> 8) & 0xf);
-    inst_base->idx   = index;
+    inst_base->idx = index;
-    inst_base->br    = TransExtData::DIRECT_BRANCH;
+    inst_base->br = TransExtData::DIRECT_BRANCH;
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(bl_1_thumb)(unsigned int tinst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(bl_1_thumb)(unsigned int tinst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(bl_1_thumb));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(bl_1_thumb));
+    bl_1_thumb* inst_cream = (bl_1_thumb*)inst_base->component;
-    bl_1_thumb *inst_cream = (bl_1_thumb *)inst_base->component;
    inst_cream->imm = (((tinst & 0x07FF) << 12) | ((tinst & (1 << 10)) ? 0xFF800000 : 0));
    inst_base->idx = index;
-    inst_base->br  = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(bl_2_thumb)(unsigned int tinst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(bl_2_thumb)(unsigned int tinst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(bl_2_thumb));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(bl_2_thumb));
+    bl_2_thumb* inst_cream = (bl_2_thumb*)inst_base->component;
-    bl_2_thumb *inst_cream = (bl_2_thumb *)inst_base->component;
    inst_cream->imm = (tinst & 0x07FF) << 1;
    inst_base->idx = index;
-    inst_base->br  = TransExtData::DIRECT_BRANCH;
+    inst_base->br = TransExtData::DIRECT_BRANCH;
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(blx_1_thumb)(unsigned int tinst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(blx_1_thumb)(unsigned int tinst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(blx_1_thumb));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(blx_1_thumb));
+    blx_1_thumb* inst_cream = (blx_1_thumb*)inst_base->component;
-    blx_1_thumb *inst_cream = (blx_1_thumb *)inst_base->component;
-    inst_cream->imm   = (tinst & 0x07FF) << 1;
+    inst_cream->imm = (tinst & 0x07FF) << 1;
    inst_cream->instr = tinst;
-    inst_base->idx    = index;
+    inst_base->idx = index;
-    inst_base->br     = TransExtData::DIRECT_BRANCH;
+    inst_base->br = TransExtData::DIRECT_BRANCH;
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uqadd8)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uqadd8)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(generic_arm_inst));
    generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rm  = BITS(inst, 0, 3);
+    inst_cream->Rm = BITS(inst, 0, 3);
-    inst_cream->Rn  = BITS(inst, 16, 19);
+    inst_cream->Rn = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->op1 = BITS(inst, 20, 21);
    inst_cream->op2 = BITS(inst, 5, 7);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uqadd16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uqadd16)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(uqadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uqaddsubx)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uqaddsubx)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(uqadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uqsub8)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uqsub8)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(uqadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uqsub16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uqsub16)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(uqadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uqsubaddx)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uqsubaddx)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(uqadd8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(usada8)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(usada8)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(generic_arm_inst));
    generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->op1 = BITS(inst, 20, 24);
    inst_cream->op2 = BITS(inst, 5, 7);
-    inst_cream->Rd  = BITS(inst, 16, 19);
+    inst_cream->Rd = BITS(inst, 16, 19);
-    inst_cream->Rm  = BITS(inst, 8, 11);
+    inst_cream->Rm = BITS(inst, 8, 11);
-    inst_cream->Rn  = BITS(inst, 0, 3);
+    inst_cream->Rn = BITS(inst, 0, 3);
-    inst_cream->Ra  = BITS(inst, 12, 15);
+    inst_cream->Ra = BITS(inst, 12, 15);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(usad8)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(usad8)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(usada8)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(usat)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(usat)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(ssat)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(usat16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(usat16)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(ssat16)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uxtab16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uxtab16)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(uxtab_inst));
    uxtab_inst* const inst_cream = (uxtab_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->Rm     = BITS(inst, 0, 3);
+    inst_cream->Rm = BITS(inst, 0, 3);
-    inst_cream->Rn     = BITS(inst, 16, 19);
+    inst_cream->Rn = BITS(inst, 16, 19);
-    inst_cream->Rd     = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 12, 15);
    inst_cream->rotate = BITS(inst, 10, 11);
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(uxtb16)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(uxtb16)(unsigned int inst, int index) {
-{
    return INTERPRETER_TRANSLATE(uxtab16)(inst, index);
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(wfe)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(wfe)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst));
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(wfi)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(wfi)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst));
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    return inst_base;
 }
-static ARM_INST_PTR INTERPRETER_TRANSLATE(yield)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(yield)(unsigned int inst, int index) {
-{
    arm_inst* const inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst));
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    return inst_base;
 }
@@ -1968,211 +1811,78 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(yield)(unsigned int inst, int index)
 #undef VFP_INTERPRETER_TRANS
 const transop_fp_t arm_instruction_trans[] = {
-    INTERPRETER_TRANSLATE(vmla),
+    INTERPRETER_TRANSLATE(vmla), INTERPRETER_TRANSLATE(vmls), INTERPRETER_TRANSLATE(vnmla),
-    INTERPRETER_TRANSLATE(vmls),
+    INTERPRETER_TRANSLATE(vnmls), INTERPRETER_TRANSLATE(vnmul), INTERPRETER_TRANSLATE(vmul),
-    INTERPRETER_TRANSLATE(vnmla),
+    INTERPRETER_TRANSLATE(vadd), INTERPRETER_TRANSLATE(vsub), INTERPRETER_TRANSLATE(vdiv),
-    INTERPRETER_TRANSLATE(vnmls),
+    INTERPRETER_TRANSLATE(vmovi), INTERPRETER_TRANSLATE(vmovr), INTERPRETER_TRANSLATE(vabs),
-    INTERPRETER_TRANSLATE(vnmul),
+    INTERPRETER_TRANSLATE(vneg), INTERPRETER_TRANSLATE(vsqrt), INTERPRETER_TRANSLATE(vcmp),
-    INTERPRETER_TRANSLATE(vmul),
+    INTERPRETER_TRANSLATE(vcmp2), INTERPRETER_TRANSLATE(vcvtbds), INTERPRETER_TRANSLATE(vcvtbff),
-    INTERPRETER_TRANSLATE(vadd),
+    INTERPRETER_TRANSLATE(vcvtbfi), INTERPRETER_TRANSLATE(vmovbrs), INTERPRETER_TRANSLATE(vmsr),
-    INTERPRETER_TRANSLATE(vsub),
+    INTERPRETER_TRANSLATE(vmovbrc), INTERPRETER_TRANSLATE(vmrs), INTERPRETER_TRANSLATE(vmovbcr),
-    INTERPRETER_TRANSLATE(vdiv),
+    INTERPRETER_TRANSLATE(vmovbrrss), INTERPRETER_TRANSLATE(vmovbrrd), INTERPRETER_TRANSLATE(vstr),
-    INTERPRETER_TRANSLATE(vmovi),
+    INTERPRETER_TRANSLATE(vpush), INTERPRETER_TRANSLATE(vstm), INTERPRETER_TRANSLATE(vpop),
-    INTERPRETER_TRANSLATE(vmovr),
+    INTERPRETER_TRANSLATE(vldr), INTERPRETER_TRANSLATE(vldm),
-    INTERPRETER_TRANSLATE(vabs),
-    INTERPRETER_TRANSLATE(vneg),
+    INTERPRETER_TRANSLATE(srs), INTERPRETER_TRANSLATE(rfe), INTERPRETER_TRANSLATE(bkpt),
-    INTERPRETER_TRANSLATE(vsqrt),
+    INTERPRETER_TRANSLATE(blx), INTERPRETER_TRANSLATE(cps), INTERPRETER_TRANSLATE(pld),
-    INTERPRETER_TRANSLATE(vcmp),
+    INTERPRETER_TRANSLATE(setend), INTERPRETER_TRANSLATE(clrex), INTERPRETER_TRANSLATE(rev16),
-    INTERPRETER_TRANSLATE(vcmp2),
+    INTERPRETER_TRANSLATE(usad8), INTERPRETER_TRANSLATE(sxtb), INTERPRETER_TRANSLATE(uxtb),
-    INTERPRETER_TRANSLATE(vcvtbds),
+    INTERPRETER_TRANSLATE(sxth), INTERPRETER_TRANSLATE(sxtb16), INTERPRETER_TRANSLATE(uxth),
-    INTERPRETER_TRANSLATE(vcvtbff),
+    INTERPRETER_TRANSLATE(uxtb16), INTERPRETER_TRANSLATE(cpy), INTERPRETER_TRANSLATE(uxtab),
-    INTERPRETER_TRANSLATE(vcvtbfi),
+    INTERPRETER_TRANSLATE(ssub8), INTERPRETER_TRANSLATE(shsub8), INTERPRETER_TRANSLATE(ssubaddx),
-    INTERPRETER_TRANSLATE(vmovbrs),
+    INTERPRETER_TRANSLATE(strex), INTERPRETER_TRANSLATE(strexb), INTERPRETER_TRANSLATE(swp),
-    INTERPRETER_TRANSLATE(vmsr),
+    INTERPRETER_TRANSLATE(swpb), INTERPRETER_TRANSLATE(ssub16), INTERPRETER_TRANSLATE(ssat16),
-    INTERPRETER_TRANSLATE(vmovbrc),
+    INTERPRETER_TRANSLATE(shsubaddx), INTERPRETER_TRANSLATE(qsubaddx),
-    INTERPRETER_TRANSLATE(vmrs),
+    INTERPRETER_TRANSLATE(shaddsubx), INTERPRETER_TRANSLATE(shadd8), INTERPRETER_TRANSLATE(shadd16),
-    INTERPRETER_TRANSLATE(vmovbcr),
+    INTERPRETER_TRANSLATE(sel), INTERPRETER_TRANSLATE(saddsubx), INTERPRETER_TRANSLATE(sadd8),
-    INTERPRETER_TRANSLATE(vmovbrrss),
+    INTERPRETER_TRANSLATE(sadd16), INTERPRETER_TRANSLATE(shsub16), INTERPRETER_TRANSLATE(umaal),
-    INTERPRETER_TRANSLATE(vmovbrrd),
+    INTERPRETER_TRANSLATE(uxtab16), INTERPRETER_TRANSLATE(usubaddx), INTERPRETER_TRANSLATE(usub8),
-    INTERPRETER_TRANSLATE(vstr),
+    INTERPRETER_TRANSLATE(usub16), INTERPRETER_TRANSLATE(usat16), INTERPRETER_TRANSLATE(usada8),
-    INTERPRETER_TRANSLATE(vpush),
+    INTERPRETER_TRANSLATE(uqsubaddx), INTERPRETER_TRANSLATE(uqsub8), INTERPRETER_TRANSLATE(uqsub16),
-    INTERPRETER_TRANSLATE(vstm),
+    INTERPRETER_TRANSLATE(uqaddsubx), INTERPRETER_TRANSLATE(uqadd8), INTERPRETER_TRANSLATE(uqadd16),
-    INTERPRETER_TRANSLATE(vpop),
+    INTERPRETER_TRANSLATE(sxtab), INTERPRETER_TRANSLATE(uhsubaddx), INTERPRETER_TRANSLATE(uhsub8),
-    INTERPRETER_TRANSLATE(vldr),
+    INTERPRETER_TRANSLATE(uhsub16), INTERPRETER_TRANSLATE(uhaddsubx), INTERPRETER_TRANSLATE(uhadd8),
-    INTERPRETER_TRANSLATE(vldm),
+    INTERPRETER_TRANSLATE(uhadd16), INTERPRETER_TRANSLATE(uaddsubx), INTERPRETER_TRANSLATE(uadd8),
+    INTERPRETER_TRANSLATE(uadd16), INTERPRETER_TRANSLATE(sxtah), INTERPRETER_TRANSLATE(sxtab16),
-    INTERPRETER_TRANSLATE(srs),
+    INTERPRETER_TRANSLATE(qadd8), INTERPRETER_TRANSLATE(bxj), INTERPRETER_TRANSLATE(clz),
-    INTERPRETER_TRANSLATE(rfe),
+    INTERPRETER_TRANSLATE(uxtah), INTERPRETER_TRANSLATE(bx), INTERPRETER_TRANSLATE(rev),
-    INTERPRETER_TRANSLATE(bkpt),
+    INTERPRETER_TRANSLATE(blx), INTERPRETER_TRANSLATE(revsh), INTERPRETER_TRANSLATE(qadd),
-    INTERPRETER_TRANSLATE(blx),
+    INTERPRETER_TRANSLATE(qadd16), INTERPRETER_TRANSLATE(qaddsubx), INTERPRETER_TRANSLATE(ldrex),
-    INTERPRETER_TRANSLATE(cps),
+    INTERPRETER_TRANSLATE(qdadd), INTERPRETER_TRANSLATE(qdsub), INTERPRETER_TRANSLATE(qsub),
-    INTERPRETER_TRANSLATE(pld),
+    INTERPRETER_TRANSLATE(ldrexb), INTERPRETER_TRANSLATE(qsub8), INTERPRETER_TRANSLATE(qsub16),
-    INTERPRETER_TRANSLATE(setend),
+    INTERPRETER_TRANSLATE(smuad), INTERPRETER_TRANSLATE(smmul), INTERPRETER_TRANSLATE(smusd),
-    INTERPRETER_TRANSLATE(clrex),
+    INTERPRETER_TRANSLATE(smlsd), INTERPRETER_TRANSLATE(smlsld), INTERPRETER_TRANSLATE(smmla),
-    INTERPRETER_TRANSLATE(rev16),
+    INTERPRETER_TRANSLATE(smmls), INTERPRETER_TRANSLATE(smlald), INTERPRETER_TRANSLATE(smlad),
-    INTERPRETER_TRANSLATE(usad8),
+    INTERPRETER_TRANSLATE(smlaw), INTERPRETER_TRANSLATE(smulw), INTERPRETER_TRANSLATE(pkhtb),
-    INTERPRETER_TRANSLATE(sxtb),
+    INTERPRETER_TRANSLATE(pkhbt), INTERPRETER_TRANSLATE(smul), INTERPRETER_TRANSLATE(smlalxy),
-    INTERPRETER_TRANSLATE(uxtb),
+    INTERPRETER_TRANSLATE(smla), INTERPRETER_TRANSLATE(mcrr), INTERPRETER_TRANSLATE(mrrc),
-    INTERPRETER_TRANSLATE(sxth),
+    INTERPRETER_TRANSLATE(cmp), INTERPRETER_TRANSLATE(tst), INTERPRETER_TRANSLATE(teq),
-    INTERPRETER_TRANSLATE(sxtb16),
+    INTERPRETER_TRANSLATE(cmn), INTERPRETER_TRANSLATE(smull), INTERPRETER_TRANSLATE(umull),
-    INTERPRETER_TRANSLATE(uxth),
+    INTERPRETER_TRANSLATE(umlal), INTERPRETER_TRANSLATE(smlal), INTERPRETER_TRANSLATE(mul),
-    INTERPRETER_TRANSLATE(uxtb16),
+    INTERPRETER_TRANSLATE(mla), INTERPRETER_TRANSLATE(ssat), INTERPRETER_TRANSLATE(usat),
-    INTERPRETER_TRANSLATE(cpy),
+    INTERPRETER_TRANSLATE(mrs), INTERPRETER_TRANSLATE(msr), INTERPRETER_TRANSLATE(and),
-    INTERPRETER_TRANSLATE(uxtab),
+    INTERPRETER_TRANSLATE(bic), INTERPRETER_TRANSLATE(ldm), INTERPRETER_TRANSLATE(eor),
-    INTERPRETER_TRANSLATE(ssub8),
+    INTERPRETER_TRANSLATE(add), INTERPRETER_TRANSLATE(rsb), INTERPRETER_TRANSLATE(rsc),
-    INTERPRETER_TRANSLATE(shsub8),
+    INTERPRETER_TRANSLATE(sbc), INTERPRETER_TRANSLATE(adc), INTERPRETER_TRANSLATE(sub),
-    INTERPRETER_TRANSLATE(ssubaddx),
+    INTERPRETER_TRANSLATE(orr), INTERPRETER_TRANSLATE(mvn), INTERPRETER_TRANSLATE(mov),
-    INTERPRETER_TRANSLATE(strex),
+    INTERPRETER_TRANSLATE(stm), INTERPRETER_TRANSLATE(ldm), INTERPRETER_TRANSLATE(ldrsh),
-    INTERPRETER_TRANSLATE(strexb),
+    INTERPRETER_TRANSLATE(stm), INTERPRETER_TRANSLATE(ldm), INTERPRETER_TRANSLATE(ldrsb),
-    INTERPRETER_TRANSLATE(swp),
+    INTERPRETER_TRANSLATE(strd), INTERPRETER_TRANSLATE(ldrh), INTERPRETER_TRANSLATE(strh),
-    INTERPRETER_TRANSLATE(swpb),
+    INTERPRETER_TRANSLATE(ldrd), INTERPRETER_TRANSLATE(strt), INTERPRETER_TRANSLATE(strbt),
-    INTERPRETER_TRANSLATE(ssub16),
+    INTERPRETER_TRANSLATE(ldrbt), INTERPRETER_TRANSLATE(ldrt), INTERPRETER_TRANSLATE(mrc),
-    INTERPRETER_TRANSLATE(ssat16),
+    INTERPRETER_TRANSLATE(mcr), INTERPRETER_TRANSLATE(msr), INTERPRETER_TRANSLATE(msr),
-    INTERPRETER_TRANSLATE(shsubaddx),
+    INTERPRETER_TRANSLATE(msr), INTERPRETER_TRANSLATE(msr), INTERPRETER_TRANSLATE(msr),
-    INTERPRETER_TRANSLATE(qsubaddx),
+    INTERPRETER_TRANSLATE(ldrb), INTERPRETER_TRANSLATE(strb), INTERPRETER_TRANSLATE(ldr),
-    INTERPRETER_TRANSLATE(shaddsubx),
+    INTERPRETER_TRANSLATE(ldrcond), INTERPRETER_TRANSLATE(str), INTERPRETER_TRANSLATE(cdp),
-    INTERPRETER_TRANSLATE(shadd8),
+    INTERPRETER_TRANSLATE(stc), INTERPRETER_TRANSLATE(ldc), INTERPRETER_TRANSLATE(ldrexd),
-    INTERPRETER_TRANSLATE(shadd16),
+    INTERPRETER_TRANSLATE(strexd), INTERPRETER_TRANSLATE(ldrexh), INTERPRETER_TRANSLATE(strexh),
-    INTERPRETER_TRANSLATE(sel),
+    INTERPRETER_TRANSLATE(nop), INTERPRETER_TRANSLATE(yield), INTERPRETER_TRANSLATE(wfe),
-    INTERPRETER_TRANSLATE(saddsubx),
+    INTERPRETER_TRANSLATE(wfi), INTERPRETER_TRANSLATE(sev), INTERPRETER_TRANSLATE(swi),
-    INTERPRETER_TRANSLATE(sadd8),
-    INTERPRETER_TRANSLATE(sadd16),
-    INTERPRETER_TRANSLATE(shsub16),
-    INTERPRETER_TRANSLATE(umaal),
-    INTERPRETER_TRANSLATE(uxtab16),
-    INTERPRETER_TRANSLATE(usubaddx),
-    INTERPRETER_TRANSLATE(usub8),
-    INTERPRETER_TRANSLATE(usub16),
-    INTERPRETER_TRANSLATE(usat16),
-    INTERPRETER_TRANSLATE(usada8),
-    INTERPRETER_TRANSLATE(uqsubaddx),
-    INTERPRETER_TRANSLATE(uqsub8),
-    INTERPRETER_TRANSLATE(uqsub16),
-    INTERPRETER_TRANSLATE(uqaddsubx),
-    INTERPRETER_TRANSLATE(uqadd8),
-    INTERPRETER_TRANSLATE(uqadd16),
-    INTERPRETER_TRANSLATE(sxtab),
-    INTERPRETER_TRANSLATE(uhsubaddx),
-    INTERPRETER_TRANSLATE(uhsub8),
-    INTERPRETER_TRANSLATE(uhsub16),
-    INTERPRETER_TRANSLATE(uhaddsubx),
-    INTERPRETER_TRANSLATE(uhadd8),
-    INTERPRETER_TRANSLATE(uhadd16),
-    INTERPRETER_TRANSLATE(uaddsubx),
-    INTERPRETER_TRANSLATE(uadd8),
-    INTERPRETER_TRANSLATE(uadd16),
-    INTERPRETER_TRANSLATE(sxtah),
-    INTERPRETER_TRANSLATE(sxtab16),
-    INTERPRETER_TRANSLATE(qadd8),
-    INTERPRETER_TRANSLATE(bxj),
-    INTERPRETER_TRANSLATE(clz),
-    INTERPRETER_TRANSLATE(uxtah),
-    INTERPRETER_TRANSLATE(bx),
-    INTERPRETER_TRANSLATE(rev),
-    INTERPRETER_TRANSLATE(blx),
-    INTERPRETER_TRANSLATE(revsh),
-    INTERPRETER_TRANSLATE(qadd),
-    INTERPRETER_TRANSLATE(qadd16),
-    INTERPRETER_TRANSLATE(qaddsubx),
-    INTERPRETER_TRANSLATE(ldrex),
-    INTERPRETER_TRANSLATE(qdadd),
-    INTERPRETER_TRANSLATE(qdsub),
-    INTERPRETER_TRANSLATE(qsub),
-    INTERPRETER_TRANSLATE(ldrexb),
-    INTERPRETER_TRANSLATE(qsub8),
-    INTERPRETER_TRANSLATE(qsub16),
-    INTERPRETER_TRANSLATE(smuad),
-    INTERPRETER_TRANSLATE(smmul),
-    INTERPRETER_TRANSLATE(smusd),
-    INTERPRETER_TRANSLATE(smlsd),
-    INTERPRETER_TRANSLATE(smlsld),
-    INTERPRETER_TRANSLATE(smmla),
-    INTERPRETER_TRANSLATE(smmls),
-    INTERPRETER_TRANSLATE(smlald),
-    INTERPRETER_TRANSLATE(smlad),
-    INTERPRETER_TRANSLATE(smlaw),
-    INTERPRETER_TRANSLATE(smulw),
-    INTERPRETER_TRANSLATE(pkhtb),
-    INTERPRETER_TRANSLATE(pkhbt),
-    INTERPRETER_TRANSLATE(smul),
-    INTERPRETER_TRANSLATE(smlalxy),
-    INTERPRETER_TRANSLATE(smla),
-    INTERPRETER_TRANSLATE(mcrr),
-    INTERPRETER_TRANSLATE(mrrc),
-    INTERPRETER_TRANSLATE(cmp),
-    INTERPRETER_TRANSLATE(tst),
-    INTERPRETER_TRANSLATE(teq),
-    INTERPRETER_TRANSLATE(cmn),
-    INTERPRETER_TRANSLATE(smull),
-    INTERPRETER_TRANSLATE(umull),
-    INTERPRETER_TRANSLATE(umlal),
-    INTERPRETER_TRANSLATE(smlal),
-    INTERPRETER_TRANSLATE(mul),
-    INTERPRETER_TRANSLATE(mla),
-    INTERPRETER_TRANSLATE(ssat),
-    INTERPRETER_TRANSLATE(usat),
-    INTERPRETER_TRANSLATE(mrs),
-    INTERPRETER_TRANSLATE(msr),
-    INTERPRETER_TRANSLATE(and),
-    INTERPRETER_TRANSLATE(bic),
-    INTERPRETER_TRANSLATE(ldm),
-    INTERPRETER_TRANSLATE(eor),
-    INTERPRETER_TRANSLATE(add),
-    INTERPRETER_TRANSLATE(rsb),
-    INTERPRETER_TRANSLATE(rsc),
-    INTERPRETER_TRANSLATE(sbc),
-    INTERPRETER_TRANSLATE(adc),
-    INTERPRETER_TRANSLATE(sub),
-    INTERPRETER_TRANSLATE(orr),
-    INTERPRETER_TRANSLATE(mvn),
-    INTERPRETER_TRANSLATE(mov),
-    INTERPRETER_TRANSLATE(stm),
-    INTERPRETER_TRANSLATE(ldm),
-    INTERPRETER_TRANSLATE(ldrsh),
-    INTERPRETER_TRANSLATE(stm),
-    INTERPRETER_TRANSLATE(ldm),
-    INTERPRETER_TRANSLATE(ldrsb),
-    INTERPRETER_TRANSLATE(strd),
-    INTERPRETER_TRANSLATE(ldrh),
-    INTERPRETER_TRANSLATE(strh),
-    INTERPRETER_TRANSLATE(ldrd),
-    INTERPRETER_TRANSLATE(strt),
-    INTERPRETER_TRANSLATE(strbt),
-    INTERPRETER_TRANSLATE(ldrbt),
-    INTERPRETER_TRANSLATE(ldrt),
-    INTERPRETER_TRANSLATE(mrc),
-    INTERPRETER_TRANSLATE(mcr),
-    INTERPRETER_TRANSLATE(msr),
-    INTERPRETER_TRANSLATE(msr),
-    INTERPRETER_TRANSLATE(msr),
-    INTERPRETER_TRANSLATE(msr),
-    INTERPRETER_TRANSLATE(msr),
-    INTERPRETER_TRANSLATE(ldrb),
-    INTERPRETER_TRANSLATE(strb),
-    INTERPRETER_TRANSLATE(ldr),
-    INTERPRETER_TRANSLATE(ldrcond),
-    INTERPRETER_TRANSLATE(str),
-    INTERPRETER_TRANSLATE(cdp),
-    INTERPRETER_TRANSLATE(stc),
-    INTERPRETER_TRANSLATE(ldc),
-    INTERPRETER_TRANSLATE(ldrexd),
-    INTERPRETER_TRANSLATE(strexd),
-    INTERPRETER_TRANSLATE(ldrexh),
-    INTERPRETER_TRANSLATE(strexh),
-    INTERPRETER_TRANSLATE(nop),
-    INTERPRETER_TRANSLATE(yield),
-    INTERPRETER_TRANSLATE(wfe),
-    INTERPRETER_TRANSLATE(wfi),
-    INTERPRETER_TRANSLATE(sev),
-    INTERPRETER_TRANSLATE(swi),
    INTERPRETER_TRANSLATE(bbl),
    // All the thumb instructions should be placed the end of table
-    INTERPRETER_TRANSLATE(b_2_thumb),
+    INTERPRETER_TRANSLATE(b_2_thumb), INTERPRETER_TRANSLATE(b_cond_thumb),
-    INTERPRETER_TRANSLATE(b_cond_thumb),
+    INTERPRETER_TRANSLATE(bl_1_thumb), INTERPRETER_TRANSLATE(bl_2_thumb),
-    INTERPRETER_TRANSLATE(bl_1_thumb),
+    INTERPRETER_TRANSLATE(blx_1_thumb)};
-    INTERPRETER_TRANSLATE(bl_2_thumb),
-    INTERPRETER_TRANSLATE(blx_1_thumb)
-};
 const size_t arm_instruction_trans_len = sizeof(arm_instruction_trans) / sizeof(transop_fp_t);
diff --git a/src/core/arm/dyncom/arm_dyncom_trans.h b/src/core/arm/dyncom/arm_dyncom_trans.h
index 7af71f4e3..6fdb3d248 100644
--- a/src/core/arm/dyncom/arm_dyncom_trans.h
+++ b/src/core/arm/dyncom/arm_dyncom_trans.h
@@ -2,15 +2,15 @@ struct ARMul_State;
 typedef unsigned int (*shtop_fp_t)(ARMul_State* cpu, unsigned int sht_oper);
 enum class TransExtData {
-    COND            = (1 << 0),
+    COND = (1 << 0),
-    NON_BRANCH      = (1 << 1),
+    NON_BRANCH = (1 << 1),
-    DIRECT_BRANCH   = (1 << 2),
+    DIRECT_BRANCH = (1 << 2),
    INDIRECT_BRANCH = (1 << 3),
-    CALL            = (1 << 4),
+    CALL = (1 << 4),
-    RET             = (1 << 5),
+    RET = (1 << 5),
-    END_OF_PAGE     = (1 << 6),
+    END_OF_PAGE = (1 << 6),
-    THUMB           = (1 << 7),
+    THUMB = (1 << 7),
-    SINGLE_STEP     = (1 << 8)
+    SINGLE_STEP = (1 << 8)
 };
 struct arm_inst {
@@ -106,8 +106,7 @@ struct cps_inst {
    unsigned int mode;
 };
-struct clrex_inst {
+struct clrex_inst {};
-};
 struct cpy_inst {
    unsigned int Rm;
@@ -163,11 +162,9 @@ struct bkpt_inst {
    u32 imm;
 };
-struct stc_inst {
+struct stc_inst {};
-};
-struct ldc_inst {
+struct ldc_inst {};
-};
 struct swi_inst {
    unsigned int num;
@@ -369,8 +366,7 @@ struct msr_inst {
    unsigned int inst;
 };
-struct pld_inst {
+struct pld_inst {};
-};
 struct sxtb_inst {
    unsigned int Rd;
@@ -475,7 +471,7 @@ struct pkh_inst {
 #include "core/arm/skyeye_common/vfp/vfpinstr.cpp"
 #undef VFP_INTERPRETER_STRUCT
-typedef void (*get_addr_fp_t)(ARMul_State *cpu, unsigned int inst, unsigned int &virt_addr);
+typedef void (*get_addr_fp_t)(ARMul_State* cpu, unsigned int inst, unsigned int& virt_addr);
 struct ldst_inst {
    unsigned int inst;
diff --git a/src/core/arm/skyeye_common/arm_regformat.h b/src/core/arm/skyeye_common/arm_regformat.h
index 38fa97ab9..706195a05 100644
--- a/src/core/arm/skyeye_common/arm_regformat.h
+++ b/src/core/arm/skyeye_common/arm_regformat.h
@@ -16,7 +16,7 @@ enum {
    R12,
    R13,
    LR,
-    R15, //PC,
+    R15, // PC,
    CPSR_REG,
    SPSR_REG,
diff --git a/src/core/arm/skyeye_common/armstate.cpp b/src/core/arm/skyeye_common/armstate.cpp
index 5550c112e..59329c656 100644
--- a/src/core/arm/skyeye_common/armstate.cpp
+++ b/src/core/arm/skyeye_common/armstate.cpp
@@ -2,22 +2,20 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
+#include "core/arm/skyeye_common/armstate.h"
 #include <algorithm>
-#include "common/swap.h"
 #include "common/logging/log.h"
-#include "core/memory.h"
+#include "common/swap.h"
-#include "core/arm/skyeye_common/armstate.h"
 #include "core/arm/skyeye_common/vfp/vfp.h"
 #include "core/gdbstub/gdbstub.h"
+#include "core/memory.h"
-ARMul_State::ARMul_State(PrivilegeMode initial_mode)
+ARMul_State::ARMul_State(PrivilegeMode initial_mode) {
-{
    Reset();
    ChangePrivilegeMode(initial_mode);
 }
-void ARMul_State::ChangePrivilegeMode(u32 new_mode)
+void ARMul_State::ChangePrivilegeMode(u32 new_mode) {
-{
    if (Mode == new_mode)
        return;
@@ -103,8 +101,7 @@ void ARMul_State::ChangePrivilegeMode(u32 new_mode)
 }
 // Performs a reset
-void ARMul_State::Reset()
+void ARMul_State::Reset() {
-{
    VFPInit(this);
    // Set stack pointer to the top of the stack
@@ -128,8 +125,7 @@ void ARMul_State::Reset()
 }
 // Resets certain MPCore CP15 values to their ARM-defined reset values.
-void ARMul_State::ResetMPCoreCP15Registers()
+void ARMul_State::ResetMPCoreCP15Registers() {
-{
    // c0
    CP15[CP15_MAIN_ID] = 0x410FB024;
    CP15[CP15_TLB_TYPE] = 0x00000800;
@@ -185,23 +181,20 @@ void ARMul_State::ResetMPCoreCP15Registers()
    CP15[CP15_TLB_DEBUG_CONTROL] = 0x00000000;
 }
-static void CheckMemoryBreakpoint(u32 address, GDBStub::BreakpointType type)
+static void CheckMemoryBreakpoint(u32 address, GDBStub::BreakpointType type) {
-{
    if (GDBStub::g_server_enabled && GDBStub::CheckBreakpoint(address, type)) {
        LOG_DEBUG(Debug, "Found memory breakpoint @ %08x", address);
        GDBStub::Break(true);
    }
 }
-u8 ARMul_State::ReadMemory8(u32 address) const
+u8 ARMul_State::ReadMemory8(u32 address) const {
-{
    CheckMemoryBreakpoint(address, GDBStub::BreakpointType::Read);
    return Memory::Read8(address);
 }
-u16 ARMul_State::ReadMemory16(u32 address) const
+u16 ARMul_State::ReadMemory16(u32 address) const {
-{
    CheckMemoryBreakpoint(address, GDBStub::BreakpointType::Read);
    u16 data = Memory::Read16(address);
@@ -212,8 +205,7 @@ u16 ARMul_State::ReadMemory16(u32 address) const
    return data;
 }
-u32 ARMul_State::ReadMemory32(u32 address) const
+u32 ARMul_State::ReadMemory32(u32 address) const {
-{
    CheckMemoryBreakpoint(address, GDBStub::BreakpointType::Read);
    u32 data = Memory::Read32(address);
@@ -224,8 +216,7 @@ u32 ARMul_State::ReadMemory32(u32 address) const
    return data;
 }
-u64 ARMul_State::ReadMemory64(u32 address) const
+u64 ARMul_State::ReadMemory64(u32 address) const {
-{
    CheckMemoryBreakpoint(address, GDBStub::BreakpointType::Read);
    u64 data = Memory::Read64(address);
@@ -236,15 +227,13 @@ u64 ARMul_State::ReadMemory64(u32 address) const
    return data;
 }
-void ARMul_State::WriteMemory8(u32 address, u8 data)
+void ARMul_State::WriteMemory8(u32 address, u8 data) {
-{
    CheckMemoryBreakpoint(address, GDBStub::BreakpointType::Write);
    Memory::Write8(address, data);
 }
-void ARMul_State::WriteMemory16(u32 address, u16 data)
+void ARMul_State::WriteMemory16(u32 address, u16 data) {
-{
    CheckMemoryBreakpoint(address, GDBStub::BreakpointType::Write);
    if (InBigEndianMode())
@@ -253,8 +242,7 @@ void ARMul_State::WriteMemory16(u32 address, u16 data)
    Memory::Write16(address, data);
 }
-void ARMul_State::WriteMemory32(u32 address, u32 data)
+void ARMul_State::WriteMemory32(u32 address, u32 data) {
-{
    CheckMemoryBreakpoint(address, GDBStub::BreakpointType::Write);
    if (InBigEndianMode())
@@ -263,8 +251,7 @@ void ARMul_State::WriteMemory32(u32 address, u32 data)
    Memory::Write32(address, data);
 }
-void ARMul_State::WriteMemory64(u32 address, u64 data)
+void ARMul_State::WriteMemory64(u32 address, u64 data) {
-{
    CheckMemoryBreakpoint(address, GDBStub::BreakpointType::Write);
    if (InBigEndianMode())
@@ -273,15 +260,12 @@ void ARMul_State::WriteMemory64(u32 address, u64 data)
    Memory::Write64(address, data);
 }
 // Reads from the CP15 registers. Used with implementation of the MRC instruction.
 // Note that since the 3DS does not have the hypervisor extensions, these registers
 // are not implemented.
-u32 ARMul_State::ReadCP15Register(u32 crn, u32 opcode_1, u32 crm, u32 opcode_2) const
+u32 ARMul_State::ReadCP15Register(u32 crn, u32 opcode_1, u32 crm, u32 opcode_2) const {
-{
    // Unprivileged registers
-    if (crn == 13 && opcode_1 == 0 && crm == 0)
+    if (crn == 13 && opcode_1 == 0 && crm == 0) {
-    {
        if (opcode_2 == 2)
            return CP15[CP15_THREAD_UPRW];
@@ -289,12 +273,9 @@ u32 ARMul_State::ReadCP15Register(u32 crn, u32 opcode_1, u32 crm, u32 opcode_2)
            return CP15[CP15_THREAD_URO];
    }
-    if (InAPrivilegedMode())
+    if (InAPrivilegedMode()) {
-    {
+        if (crn == 0 && opcode_1 == 0) {
-        if (crn == 0 && opcode_1 == 0)
+            if (crm == 0) {
-        {
-            if (crm == 0)
-            {
                if (opcode_2 == 0)
                    return CP15[CP15_MAIN_ID];
@@ -306,9 +287,7 @@ u32 ARMul_State::ReadCP15Register(u32 crn, u32 opcode_1, u32 crm, u32 opcode_2)
                if (opcode_2 == 5)
                    return CP15[CP15_CPU_ID];
-            }
+            } else if (crm == 1) {
-            else if (crm == 1)
-            {
                if (opcode_2 == 0)
                    return CP15[CP15_PROCESSOR_FEATURE_0];
@@ -329,9 +308,7 @@ u32 ARMul_State::ReadCP15Register(u32 crn, u32 opcode_1, u32 crm, u32 opcode_2)
                if (opcode_2 == 7)
                    return CP15[CP15_MEMORY_MODEL_FEATURE_3];
-            }
+            } else if (crm == 2) {
-            else if (crm == 2)
-            {
                if (opcode_2 == 0)
                    return CP15[CP15_ISA_FEATURE_0];
@@ -349,8 +326,7 @@ u32 ARMul_State::ReadCP15Register(u32 crn, u32 opcode_1, u32 crm, u32 opcode_2)
            }
        }
-        if (crn == 1 && opcode_1 == 0 && crm == 0)
+        if (crn == 1 && opcode_1 == 0 && crm == 0) {
-        {
            if (opcode_2 == 0)
                return CP15[CP15_CONTROL];
@@ -361,8 +337,7 @@ u32 ARMul_State::ReadCP15Register(u32 crn, u32 opcode_1, u32 crm, u32 opcode_2)
                return CP15[CP15_COPROCESSOR_ACCESS_CONTROL];
        }
-        if (crn == 2 && opcode_1 == 0 && crm == 0)
+        if (crn == 2 && opcode_1 == 0 && crm == 0) {
-        {
            if (opcode_2 == 0)
                return CP15[CP15_TRANSLATION_BASE_TABLE_0];
@@ -376,8 +351,7 @@ u32 ARMul_State::ReadCP15Register(u32 crn, u32 opcode_1, u32 crm, u32 opcode_2)
        if (crn == 3 && opcode_1 == 0 && crm == 0 && opcode_2 == 0)
            return CP15[CP15_DOMAIN_ACCESS_CONTROL];
-        if (crn == 5 && opcode_1 == 0 && crm == 0)
+        if (crn == 5 && opcode_1 == 0 && crm == 0) {
-        {
            if (opcode_2 == 0)
                return CP15[CP15_FAULT_STATUS];
@@ -385,8 +359,7 @@ u32 ARMul_State::ReadCP15Register(u32 crn, u32 opcode_1, u32 crm, u32 opcode_2)
                return CP15[CP15_INSTR_FAULT_STATUS];
        }
-        if (crn == 6 && opcode_1 == 0 && crm == 0)
+        if (crn == 6 && opcode_1 == 0 && crm == 0) {
-        {
            if (opcode_2 == 0)
                return CP15[CP15_FAULT_ADDRESS];
@@ -400,13 +373,11 @@ u32 ARMul_State::ReadCP15Register(u32 crn, u32 opcode_1, u32 crm, u32 opcode_2)
        if (crn == 9 && opcode_1 == 0 && crm == 0 && opcode_2 == 0)
            return CP15[CP15_DATA_CACHE_LOCKDOWN];
-        if (crn == 10 && opcode_1 == 0)
+        if (crn == 10 && opcode_1 == 0) {
-        {
            if (crm == 0 && opcode_2 == 0)
                return CP15[CP15_TLB_LOCKDOWN];
-            if (crm == 2)
+            if (crm == 2) {
-            {
                if (opcode_2 == 0)
                    return CP15[CP15_PRIMARY_REGION_REMAP];
@@ -415,8 +386,7 @@ u32 ARMul_State::ReadCP15Register(u32 crn, u32 opcode_1, u32 crm, u32 opcode_2)
            }
        }
-        if (crn == 13 && crm == 0)
+        if (crn == 13 && crm == 0) {
-        {
            if (opcode_2 == 0)
                return CP15[CP15_PID];
@@ -427,10 +397,8 @@ u32 ARMul_State::ReadCP15Register(u32 crn, u32 opcode_1, u32 crm, u32 opcode_2)
                return CP15[CP15_THREAD_PRW];
        }
-        if (crn == 15)
+        if (crn == 15) {
-        {
+            if (opcode_1 == 0 && crm == 12) {
-            if (opcode_1 == 0 && crm == 12)
-            {
                if (opcode_2 == 0)
                    return CP15[CP15_PERFORMANCE_MONITOR_CONTROL];
@@ -444,8 +412,7 @@ u32 ARMul_State::ReadCP15Register(u32 crn, u32 opcode_1, u32 crm, u32 opcode_2)
                    return CP15[CP15_COUNT_1];
            }
-            if (opcode_1 == 5 && opcode_2 == 2)
+            if (opcode_1 == 5 && opcode_2 == 2) {
-            {
                if (crm == 5)
                    return CP15[CP15_MAIN_TLB_LOCKDOWN_VIRT_ADDRESS];
@@ -461,66 +428,49 @@ u32 ARMul_State::ReadCP15Register(u32 crn, u32 opcode_1, u32 crm, u32 opcode_2)
        }
    }
-    LOG_ERROR(Core_ARM11, "MRC CRn=%u, CRm=%u, OP1=%u OP2=%u is not implemented. Returning zero.", crn, crm, opcode_1, opcode_2);
+    LOG_ERROR(Core_ARM11, "MRC CRn=%u, CRm=%u, OP1=%u OP2=%u is not implemented. Returning zero.",
+              crn, crm, opcode_1, opcode_2);
    return 0;
 }
 // Write to the CP15 registers. Used with implementation of the MCR instruction.
 // Note that since the 3DS does not have the hypervisor extensions, these registers
 // are not implemented.
-void ARMul_State::WriteCP15Register(u32 value, u32 crn, u32 opcode_1, u32 crm, u32 opcode_2)
+void ARMul_State::WriteCP15Register(u32 value, u32 crn, u32 opcode_1, u32 crm, u32 opcode_2) {
-{
+    if (InAPrivilegedMode()) {
-    if (InAPrivilegedMode())
+        if (crn == 1 && opcode_1 == 0 && crm == 0) {
-    {
-        if (crn == 1 && opcode_1 == 0 && crm == 0)
-        {
            if (opcode_2 == 0)
                CP15[CP15_CONTROL] = value;
            else if (opcode_2 == 1)
                CP15[CP15_AUXILIARY_CONTROL] = value;
            else if (opcode_2 == 2)
                CP15[CP15_COPROCESSOR_ACCESS_CONTROL] = value;
-        }
+        } else if (crn == 2 && opcode_1 == 0 && crm == 0) {
-        else if (crn == 2 && opcode_1 == 0 && crm == 0)
-        {
            if (opcode_2 == 0)
                CP15[CP15_TRANSLATION_BASE_TABLE_0] = value;
            else if (opcode_2 == 1)
                CP15[CP15_TRANSLATION_BASE_TABLE_1] = value;
            else if (opcode_2 == 2)
                CP15[CP15_TRANSLATION_BASE_CONTROL] = value;
-        }
+        } else if (crn == 3 && opcode_1 == 0 && crm == 0 && opcode_2 == 0) {
-        else if (crn == 3 && opcode_1 == 0 && crm == 0 && opcode_2 == 0)
-        {
            CP15[CP15_DOMAIN_ACCESS_CONTROL] = value;
-        }
+        } else if (crn == 5 && opcode_1 == 0 && crm == 0) {
-        else if (crn == 5 && opcode_1 == 0 && crm == 0)
-        {
            if (opcode_2 == 0)
                CP15[CP15_FAULT_STATUS] = value;
            else if (opcode_2 == 1)
                CP15[CP15_INSTR_FAULT_STATUS] = value;
-        }
+        } else if (crn == 6 && opcode_1 == 0 && crm == 0) {
-        else if (crn == 6 && opcode_1 == 0 && crm == 0)
-        {
            if (opcode_2 == 0)
                CP15[CP15_FAULT_ADDRESS] = value;
            else if (opcode_2 == 1)
                CP15[CP15_WFAR] = value;
-        }
+        } else if (crn == 7 && opcode_1 == 0) {
-        else if (crn == 7 && opcode_1 == 0)
+            if (crm == 0 && opcode_2 == 4) {
-        {
-            if (crm == 0 && opcode_2 == 4)
-            {
                CP15[CP15_WAIT_FOR_INTERRUPT] = value;
-            }
+            } else if (crm == 4 && opcode_2 == 0) {
-            else if (crm == 4 && opcode_2 == 0)
-            {
                // NOTE: Not entirely accurate. This should do permission checks.
                CP15[CP15_PHYS_ADDRESS] = Memory::VirtualToPhysicalAddress(value);
-            }
+            } else if (crm == 5) {
-            else if (crm == 5)
-            {
                if (opcode_2 == 0)
                    CP15[CP15_INVALIDATE_INSTR_CACHE] = value;
                else if (opcode_2 == 1)
@@ -531,31 +481,23 @@ void ARMul_State::WriteCP15Register(u32 value, u32 crn, u32 opcode_1, u32 crm, u
                    CP15[CP15_FLUSH_BRANCH_TARGET_CACHE] = value;
                else if (opcode_2 == 7)
                    CP15[CP15_FLUSH_BRANCH_TARGET_CACHE_ENTRY] = value;
-            }
+            } else if (crm == 6) {
-            else if (crm == 6)
-            {
                if (opcode_2 == 0)
                    CP15[CP15_INVALIDATE_DATA_CACHE] = value;
                else if (opcode_2 == 1)
                    CP15[CP15_INVALIDATE_DATA_CACHE_LINE_USING_MVA] = value;
                else if (opcode_2 == 2)
                    CP15[CP15_INVALIDATE_DATA_CACHE_LINE_USING_INDEX] = value;
-            }
+            } else if (crm == 7 && opcode_2 == 0) {
-            else if (crm == 7 && opcode_2 == 0)
-            {
                CP15[CP15_INVALIDATE_DATA_AND_INSTR_CACHE] = value;
-            }
+            } else if (crm == 10) {
-            else if (crm == 10)
-            {
                if (opcode_2 == 0)
                    CP15[CP15_CLEAN_DATA_CACHE] = value;
                else if (opcode_2 == 1)
                    CP15[CP15_CLEAN_DATA_CACHE_LINE_USING_MVA] = value;
                else if (opcode_2 == 2)
                    CP15[CP15_CLEAN_DATA_CACHE_LINE_USING_INDEX] = value;
-            }
+            } else if (crm == 14) {
-            else if (crm == 14)
-            {
                if (opcode_2 == 0)
                    CP15[CP15_CLEAN_AND_INVALIDATE_DATA_CACHE] = value;
                else if (opcode_2 == 1)
@@ -563,11 +505,8 @@ void ARMul_State::WriteCP15Register(u32 value, u32 crn, u32 opcode_1, u32 crm, u
                else if (opcode_2 == 2)
                    CP15[CP15_CLEAN_AND_INVALIDATE_DATA_CACHE_LINE_USING_INDEX] = value;
            }
-        }
+        } else if (crn == 8 && opcode_1 == 0) {
-        else if (crn == 8 && opcode_1 == 0)
+            if (crm == 5) {
-        {
-            if (crm == 5)
-            {
                if (opcode_2 == 0)
                    CP15[CP15_INVALIDATE_ITLB] = value;
                else if (opcode_2 == 1)
@@ -576,9 +515,7 @@ void ARMul_State::WriteCP15Register(u32 value, u32 crn, u32 opcode_1, u32 crm, u
                    CP15[CP15_INVALIDATE_ITLB_ENTRY_ON_ASID_MATCH] = value;
                else if (opcode_2 == 3)
                    CP15[CP15_INVALIDATE_ITLB_ENTRY_ON_MVA] = value;
-            }
+            } else if (crm == 6) {
-            else if (crm == 6)
-            {
                if (opcode_2 == 0)
                    CP15[CP15_INVALIDATE_DTLB] = value;
                else if (opcode_2 == 1)
@@ -587,9 +524,7 @@ void ARMul_State::WriteCP15Register(u32 value, u32 crn, u32 opcode_1, u32 crm, u
                    CP15[CP15_INVALIDATE_DTLB_ENTRY_ON_ASID_MATCH] = value;
                else if (opcode_2 == 3)
                    CP15[CP15_INVALIDATE_DTLB_ENTRY_ON_MVA] = value;
-            }
+            } else if (crm == 7) {
-            else if (crm == 7)
-            {
                if (opcode_2 == 0)
                    CP15[CP15_INVALIDATE_UTLB] = value;
                else if (opcode_2 == 1)
@@ -599,27 +534,18 @@ void ARMul_State::WriteCP15Register(u32 value, u32 crn, u32 opcode_1, u32 crm, u
                else if (opcode_2 == 3)
                    CP15[CP15_INVALIDATE_UTLB_ENTRY_ON_MVA] = value;
            }
-        }
+        } else if (crn == 9 && opcode_1 == 0 && crm == 0 && opcode_2 == 0) {
-        else if (crn == 9 && opcode_1 == 0 && crm == 0 && opcode_2 == 0)
-        {
            CP15[CP15_DATA_CACHE_LOCKDOWN] = value;
-        }
+        } else if (crn == 10 && opcode_1 == 0) {
-        else if (crn == 10 && opcode_1 == 0)
+            if (crm == 0 && opcode_2 == 0) {
-        {
-            if (crm == 0 && opcode_2 == 0)
-            {
                CP15[CP15_TLB_LOCKDOWN] = value;
-            }
+            } else if (crm == 2) {
-            else if (crm == 2)
-            {
                if (opcode_2 == 0)
                    CP15[CP15_PRIMARY_REGION_REMAP] = value;
                else if (opcode_2 == 1)
                    CP15[CP15_NORMAL_REGION_REMAP] = value;
            }
-        }
+        } else if (crn == 13 && opcode_1 == 0 && crm == 0) {
-        else if (crn == 13 && opcode_1 == 0 && crm == 0)
-        {
            if (opcode_2 == 0)
                CP15[CP15_PID] = value;
            else if (opcode_2 == 1)
@@ -628,11 +554,8 @@ void ARMul_State::WriteCP15Register(u32 value, u32 crn, u32 opcode_1, u32 crm, u
                CP15[CP15_THREAD_URO] = value;
            else if (opcode_2 == 4)
                CP15[CP15_THREAD_PRW] = value;
-        }
+        } else if (crn == 15) {
-        else if (crn == 15)
+            if (opcode_1 == 0 && crm == 12) {
-        {
-            if (opcode_1 == 0 && crm == 12)
-            {
                if (opcode_2 == 0)
                    CP15[CP15_PERFORMANCE_MONITOR_CONTROL] = value;
                else if (opcode_2 == 1)
@@ -641,50 +564,34 @@ void ARMul_State::WriteCP15Register(u32 value, u32 crn, u32 opcode_1, u32 crm, u
                    CP15[CP15_COUNT_0] = value;
                else if (opcode_2 == 3)
                    CP15[CP15_COUNT_1] = value;
-            }
+            } else if (opcode_1 == 5) {
-            else if (opcode_1 == 5)
+                if (crm == 4) {
-            {
-                if (crm == 4)
-                {
                    if (opcode_2 == 2)
                        CP15[CP15_READ_MAIN_TLB_LOCKDOWN_ENTRY] = value;
                    else if (opcode_2 == 4)
                        CP15[CP15_WRITE_MAIN_TLB_LOCKDOWN_ENTRY] = value;
-                }
+                } else if (crm == 5 && opcode_2 == 2) {
-                else if (crm == 5 && opcode_2 == 2)
-                {
                    CP15[CP15_MAIN_TLB_LOCKDOWN_VIRT_ADDRESS] = value;
-                }
+                } else if (crm == 6 && opcode_2 == 2) {
-                else if (crm == 6 && opcode_2 == 2)
-                {
                    CP15[CP15_MAIN_TLB_LOCKDOWN_PHYS_ADDRESS] = value;
-                }
+                } else if (crm == 7 && opcode_2 == 2) {
-                else if (crm == 7 && opcode_2 == 2)
-                {
                    CP15[CP15_MAIN_TLB_LOCKDOWN_ATTRIBUTE] = value;
                }
-            }
+            } else if (opcode_1 == 7 && crm == 1 && opcode_2 == 0) {
-            else if (opcode_1 == 7 && crm == 1 && opcode_2 == 0)
-            {
                CP15[CP15_TLB_DEBUG_CONTROL] = value;
            }
        }
    }
    // Unprivileged registers
-    if (crn == 7 && opcode_1 == 0 && crm == 5 && opcode_2 == 4)
+    if (crn == 7 && opcode_1 == 0 && crm == 5 && opcode_2 == 4) {
-    {
        CP15[CP15_FLUSH_PREFETCH_BUFFER] = value;
-    }
+    } else if (crn == 7 && opcode_1 == 0 && crm == 10) {
-    else if (crn == 7 && opcode_1 == 0 && crm == 10)
-    {
        if (opcode_2 == 4)
            CP15[CP15_DATA_SYNC_BARRIER] = value;
        else if (opcode_2 == 5)
            CP15[CP15_DATA_MEMORY_BARRIER] = value;
-    }
+    } else if (crn == 13 && opcode_1 == 0 && crm == 0 && opcode_2 == 2) {
-    else if (crn == 13 && opcode_1 == 0 && crm == 0 && opcode_2 == 2)
-    {
        CP15[CP15_THREAD_UPRW] = value;
    }
 }
diff --git a/src/core/arm/skyeye_common/armstate.h b/src/core/arm/skyeye_common/armstate.h
index d42ff2669..66567c285 100644
--- a/src/core/arm/skyeye_common/armstate.h
+++ b/src/core/arm/skyeye_common/armstate.h
@@ -24,75 +24,70 @@
 #include "core/arm/skyeye_common/arm_regformat.h"
 // Signal levels
-enum {
+enum { LOW = 0, HIGH = 1, LOWHIGH = 1, HIGHLOW = 2 };
-    LOW     = 0,
-    HIGH    = 1,
-    LOWHIGH = 1,
-    HIGHLOW = 2
-};
 // Cache types
 enum {
-    NONCACHE  = 0,
+    NONCACHE = 0,
    DATACACHE = 1,
    INSTCACHE = 2,
 };
 // ARM privilege modes
 enum PrivilegeMode {
-    USER32MODE   = 16,
+    USER32MODE = 16,
-    FIQ32MODE    = 17,
+    FIQ32MODE = 17,
-    IRQ32MODE    = 18,
+    IRQ32MODE = 18,
-    SVC32MODE    = 19,
+    SVC32MODE = 19,
-    ABORT32MODE  = 23,
+    ABORT32MODE = 23,
-    UNDEF32MODE  = 27,
+    UNDEF32MODE = 27,
    SYSTEM32MODE = 31
 };
 // ARM privilege mode register banks
 enum {
-    USERBANK   = 0,
+    USERBANK = 0,
-    FIQBANK    = 1,
+    FIQBANK = 1,
-    IRQBANK    = 2,
+    IRQBANK = 2,
-    SVCBANK    = 3,
+    SVCBANK = 3,
-    ABORTBANK  = 4,
+    ABORTBANK = 4,
-    UNDEFBANK  = 5,
+    UNDEFBANK = 5,
-    DUMMYBANK  = 6,
+    DUMMYBANK = 6,
    SYSTEMBANK = 7
 };
 // Hardware vector addresses
 enum {
-    ARMResetV          = 0,
+    ARMResetV = 0,
    ARMUndefinedInstrV = 4,
-    ARMSWIV            = 8,
+    ARMSWIV = 8,
-    ARMPrefetchAbortV  = 12,
+    ARMPrefetchAbortV = 12,
-    ARMDataAbortV      = 16,
+    ARMDataAbortV = 16,
-    ARMAddrExceptnV    = 20,
+    ARMAddrExceptnV = 20,
-    ARMIRQV            = 24,
+    ARMIRQV = 24,
-    ARMFIQV            = 28,
+    ARMFIQV = 28,
-    ARMErrorV          = 32, // This is an offset, not an address!
+    ARMErrorV = 32, // This is an offset, not an address!
-    ARMul_ResetV          = ARMResetV,
+    ARMul_ResetV = ARMResetV,
    ARMul_UndefinedInstrV = ARMUndefinedInstrV,
-    ARMul_SWIV            = ARMSWIV,
+    ARMul_SWIV = ARMSWIV,
-    ARMul_PrefetchAbortV  = ARMPrefetchAbortV,
+    ARMul_PrefetchAbortV = ARMPrefetchAbortV,
-    ARMul_DataAbortV      = ARMDataAbortV,
+    ARMul_DataAbortV = ARMDataAbortV,
-    ARMul_AddrExceptnV    = ARMAddrExceptnV,
+    ARMul_AddrExceptnV = ARMAddrExceptnV,
-    ARMul_IRQV            = ARMIRQV,
+    ARMul_IRQV = ARMIRQV,
-    ARMul_FIQV            = ARMFIQV
+    ARMul_FIQV = ARMFIQV
 };
 // Coprocessor status values
 enum {
-    ARMul_FIRST     = 0,
+    ARMul_FIRST = 0,
-    ARMul_TRANSFER  = 1,
+    ARMul_TRANSFER = 1,
-    ARMul_BUSY      = 2,
+    ARMul_BUSY = 2,
-    ARMul_DATA      = 3,
+    ARMul_DATA = 3,
    ARMul_INTERRUPT = 4,
-    ARMul_DONE      = 0,
+    ARMul_DONE = 0,
-    ARMul_CANT      = 1,
+    ARMul_CANT = 1,
-    ARMul_INC       = 3
+    ARMul_INC = 3
 };
 // Instruction condition codes
@@ -136,15 +131,13 @@ enum : u32 {
 // Values for Emulate.
 enum {
-    STOP       = 0, // Stop
+    STOP = 0,       // Stop
    CHANGEMODE = 1, // Change mode
-    ONCE       = 2, // Execute just one iteration
+    ONCE = 2,       // Execute just one iteration
-    RUN        = 3  // Continuous execution
+    RUN = 3         // Continuous execution
 };
+struct ARMul_State final {
-struct ARMul_State final
-{
 public:
    explicit ARMul_State(PrivilegeMode initial_mode);
@@ -193,7 +186,7 @@ public:
        return TFlag ? 2 : 4;
    }
-    std::array<u32, 16> Reg{};      // The current register file
+    std::array<u32, 16> Reg{}; // The current register file
    std::array<u32, 2> Reg_usr{};
    std::array<u32, 2> Reg_svc{};   // R13_SVC R14_SVC
    std::array<u32, 2> Reg_abort{}; // R13_ABORT R14_ABORT
@@ -216,8 +209,8 @@ public:
    u32 Spsr_copy;
    u32 phys_pc;
-    u32 Mode;          // The current mode
+    u32 Mode; // The current mode
-    u32 Bank;          // The current register bank
+    u32 Bank; // The current register bank
    u32 NFlag, ZFlag, CFlag, VFlag, IFFlags; // Dummy flags for speed
    unsigned int shifter_carry_out;
@@ -243,8 +236,10 @@ public:
 private:
    void ResetMPCoreCP15Registers();
-    // Defines a reservation granule of 2 words, which protects the first 2 words starting at the tag.
+    // Defines a reservation granule of 2 words, which protects the first 2 words starting at the
-    // This is the smallest granule allowed by the v7 spec, and is coincidentally just large enough to
+    // tag.
+    // This is the smallest granule allowed by the v7 spec, and is coincidentally just large enough
+    // to
    // support LDR/STREXD.
    static const u32 RESERVATION_GRANULE_MASK = 0xFFFFFFF8;
diff --git a/src/core/arm/skyeye_common/armsupp.cpp b/src/core/arm/skyeye_common/armsupp.cpp
index 883713e86..e70be29a7 100644
--- a/src/core/arm/skyeye_common/armsupp.cpp
+++ b/src/core/arm/skyeye_common/armsupp.cpp
@@ -22,8 +22,7 @@
 #include "core/arm/skyeye_common/armsupp.h"
 // Unsigned sum of absolute difference
-u8 ARMul_UnsignedAbsoluteDifference(u8 left, u8 right)
+u8 ARMul_UnsignedAbsoluteDifference(u8 left, u8 right) {
-{
    if (left > right)
        return left - right;
@@ -31,8 +30,8 @@ u8 ARMul_UnsignedAbsoluteDifference(u8 left, u8 right)
 }
 // Add with carry, indicates if a carry-out or signed overflow occurred.
-u32 AddWithCarry(u32 left, u32 right, u32 carry_in, bool* carry_out_occurred, bool* overflow_occurred)
+u32 AddWithCarry(u32 left, u32 right, u32 carry_in, bool* carry_out_occurred,
-{
+                 bool* overflow_occurred) {
    u64 unsigned_sum = (u64)left + (u64)right + (u64)carry_in;
    s64 signed_sum = (s64)(s32)left + (s64)(s32)right + (s64)carry_in;
    u64 result = (unsigned_sum & 0xFFFFFFFF);
@@ -47,22 +46,17 @@ u32 AddWithCarry(u32 left, u32 right, u32 carry_in, bool* carry_out_occurred, bo
 }
 // Compute whether an addition of A and B, giving RESULT, overflowed.
-bool AddOverflow(u32 a, u32 b, u32 result)
+bool AddOverflow(u32 a, u32 b, u32 result) {
-{
+    return ((NEG(a) && NEG(b) && POS(result)) || (POS(a) && POS(b) && NEG(result)));
-    return ((NEG(a) && NEG(b) && POS(result)) ||
-            (POS(a) && POS(b) && NEG(result)));
 }
 // Compute whether a subtraction of A and B, giving RESULT, overflowed.
-bool SubOverflow(u32 a, u32 b, u32 result)
+bool SubOverflow(u32 a, u32 b, u32 result) {
-{
+    return ((NEG(a) && POS(b) && POS(result)) || (POS(a) && NEG(b) && NEG(result)));
-    return ((NEG(a) && POS(b) && POS(result)) ||
-            (POS(a) && NEG(b) && NEG(result)));
 }
 // Returns true if the Q flag should be set as a result of overflow.
-bool ARMul_AddOverflowQ(u32 a, u32 b)
+bool ARMul_AddOverflowQ(u32 a, u32 b) {
-{
    u32 result = a + b;
    if (((result ^ a) & (u32)0x80000000) && ((a ^ b) & (u32)0x80000000) == 0)
        return true;
@@ -71,8 +65,7 @@ bool ARMul_AddOverflowQ(u32 a, u32 b)
 }
 // 8-bit signed saturated addition
-u8 ARMul_SignedSaturatedAdd8(u8 left, u8 right)
+u8 ARMul_SignedSaturatedAdd8(u8 left, u8 right) {
-{
    u8 result = left + right;
    if (((result ^ left) & 0x80) && ((left ^ right) & 0x80) == 0) {
@@ -86,8 +79,7 @@ u8 ARMul_SignedSaturatedAdd8(u8 left, u8 right)
 }
 // 8-bit signed saturated subtraction
-u8 ARMul_SignedSaturatedSub8(u8 left, u8 right)
+u8 ARMul_SignedSaturatedSub8(u8 left, u8 right) {
-{
    u8 result = left - right;
    if (((result ^ left) & 0x80) && ((left ^ right) & 0x80) != 0) {
@@ -101,8 +93,7 @@ u8 ARMul_SignedSaturatedSub8(u8 left, u8 right)
 }
 // 16-bit signed saturated addition
-u16 ARMul_SignedSaturatedAdd16(u16 left, u16 right)
+u16 ARMul_SignedSaturatedAdd16(u16 left, u16 right) {
-{
    u16 result = left + right;
    if (((result ^ left) & 0x8000) && ((left ^ right) & 0x8000) == 0) {
@@ -116,8 +107,7 @@ u16 ARMul_SignedSaturatedAdd16(u16 left, u16 right)
 }
 // 16-bit signed saturated subtraction
-u16 ARMul_SignedSaturatedSub16(u16 left, u16 right)
+u16 ARMul_SignedSaturatedSub16(u16 left, u16 right) {
-{
    u16 result = left - right;
    if (((result ^ left) & 0x8000) && ((left ^ right) & 0x8000) != 0) {
@@ -131,8 +121,7 @@ u16 ARMul_SignedSaturatedSub16(u16 left, u16 right)
 }
 // 8-bit unsigned saturated addition
-u8 ARMul_UnsignedSaturatedAdd8(u8 left, u8 right)
+u8 ARMul_UnsignedSaturatedAdd8(u8 left, u8 right) {
-{
    u8 result = left + right;
    if (result < left)
@@ -142,8 +131,7 @@ u8 ARMul_UnsignedSaturatedAdd8(u8 left, u8 right)
 }
 // 16-bit unsigned saturated addition
-u16 ARMul_UnsignedSaturatedAdd16(u16 left, u16 right)
+u16 ARMul_UnsignedSaturatedAdd16(u16 left, u16 right) {
-{
    u16 result = left + right;
    if (result < left)
@@ -153,8 +141,7 @@ u16 ARMul_UnsignedSaturatedAdd16(u16 left, u16 right)
 }
 // 8-bit unsigned saturated subtraction
-u8 ARMul_UnsignedSaturatedSub8(u8 left, u8 right)
+u8 ARMul_UnsignedSaturatedSub8(u8 left, u8 right) {
-{
    if (left <= right)
        return 0;
@@ -162,8 +149,7 @@ u8 ARMul_UnsignedSaturatedSub8(u8 left, u8 right)
 }
 // 16-bit unsigned saturated subtraction
-u16 ARMul_UnsignedSaturatedSub16(u16 left, u16 right)
+u16 ARMul_UnsignedSaturatedSub16(u16 left, u16 right) {
-{
    if (left <= right)
        return 0;
@@ -171,16 +157,14 @@ u16 ARMul_UnsignedSaturatedSub16(u16 left, u16 right)
 }
 // Signed saturation.
-u32 ARMul_SignedSatQ(s32 value, u8 shift, bool* saturation_occurred)
+u32 ARMul_SignedSatQ(s32 value, u8 shift, bool* saturation_occurred) {
-{
    const u32 max = (1 << shift) - 1;
    const s32 top = (value >> shift);
    if (top > 0) {
        *saturation_occurred = true;
        return max;
-    }
+    } else if (top < -1) {
-    else if (top < -1) {
        *saturation_occurred = true;
        return ~max;
    }
@@ -190,8 +174,7 @@ u32 ARMul_SignedSatQ(s32 value, u8 shift, bool* saturation_occurred)
 }
 // Unsigned saturation
-u32 ARMul_UnsignedSatQ(s32 value, u8 shift, bool* saturation_occurred)
+u32 ARMul_UnsignedSatQ(s32 value, u8 shift, bool* saturation_occurred) {
-{
    const u32 max = (1 << shift) - 1;
    if (value < 0) {
diff --git a/src/core/arm/skyeye_common/armsupp.h b/src/core/arm/skyeye_common/armsupp.h
index 391309fa8..bf9299c07 100644
--- a/src/core/arm/skyeye_common/armsupp.h
+++ b/src/core/arm/skyeye_common/armsupp.h
@@ -9,8 +9,8 @@
 #define BITS(s, a, b) ((s << ((sizeof(s) * 8 - 1) - b)) >> (sizeof(s) * 8 - b + a - 1))
 #define BIT(s, n) ((s >> (n)) & 1)
-#define POS(i) ( (~(i)) >> 31 )
+#define POS(i) ((~(i)) >> 31)
-#define NEG(i) ( (i) >> 31 )
+#define NEG(i) ((i) >> 31)
 bool AddOverflow(u32, u32, u32);
 bool SubOverflow(u32, u32, u32);
diff --git a/src/core/arm/skyeye_common/vfp/asm_vfp.h b/src/core/arm/skyeye_common/vfp/asm_vfp.h
index 1187924f4..15b2394eb 100644
--- a/src/core/arm/skyeye_common/vfp/asm_vfp.h
+++ b/src/core/arm/skyeye_common/vfp/asm_vfp.h
@@ -10,74 +10,74 @@
 // ARM11 MPCore FPSID Information
 // Note that these are used as values and not as flags.
 enum : u32 {
-    VFP_FPSID_IMPLMEN  = 0x41, // Implementation code. Should be the same as cp15 0 c0 0
+    VFP_FPSID_IMPLMEN = 0x41, // Implementation code. Should be the same as cp15 0 c0 0
-    VFP_FPSID_SW       = 0,    // Software emulation bit value
+    VFP_FPSID_SW = 0,         // Software emulation bit value
-    VFP_FPSID_SUBARCH  = 0x1,  // Subarchitecture version number
+    VFP_FPSID_SUBARCH = 0x1,  // Subarchitecture version number
-    VFP_FPSID_PARTNUM  = 0x20, // Part number
+    VFP_FPSID_PARTNUM = 0x20, // Part number
-    VFP_FPSID_VARIANT  = 0xB,  // Variant number
+    VFP_FPSID_VARIANT = 0xB,  // Variant number
-    VFP_FPSID_REVISION = 0x4   // Revision number
+    VFP_FPSID_REVISION = 0x4  // Revision number
 };
 // FPEXC bits
 enum : u32 {
-    FPEXC_EX          = (1U << 31U),
+    FPEXC_EX = (1U << 31U),
-    FPEXC_EN          = (1 << 30),
+    FPEXC_EN = (1 << 30),
-    FPEXC_DEX         = (1 << 29),
+    FPEXC_DEX = (1 << 29),
-    FPEXC_FP2V        = (1 << 28),
+    FPEXC_FP2V = (1 << 28),
-    FPEXC_VV          = (1 << 27),
+    FPEXC_VV = (1 << 27),
-    FPEXC_TFV         = (1 << 26),
+    FPEXC_TFV = (1 << 26),
-    FPEXC_LENGTH_BIT  = (8),
+    FPEXC_LENGTH_BIT = (8),
    FPEXC_LENGTH_MASK = (7 << FPEXC_LENGTH_BIT),
-    FPEXC_IDF         = (1 << 7),
+    FPEXC_IDF = (1 << 7),
-    FPEXC_IXF         = (1 << 4),
+    FPEXC_IXF = (1 << 4),
-    FPEXC_UFF         = (1 << 3),
+    FPEXC_UFF = (1 << 3),
-    FPEXC_OFF         = (1 << 2),
+    FPEXC_OFF = (1 << 2),
-    FPEXC_DZF         = (1 << 1),
+    FPEXC_DZF = (1 << 1),
-    FPEXC_IOF         = (1 << 0),
+    FPEXC_IOF = (1 << 0),
-    FPEXC_TRAP_MASK   = (FPEXC_IDF|FPEXC_IXF|FPEXC_UFF|FPEXC_OFF|FPEXC_DZF|FPEXC_IOF)
+    FPEXC_TRAP_MASK = (FPEXC_IDF | FPEXC_IXF | FPEXC_UFF | FPEXC_OFF | FPEXC_DZF | FPEXC_IOF)
 };
 // FPSCR Flags
 enum : u32 {
-    FPSCR_NFLAG         = (1U << 31U), // Negative condition flag
+    FPSCR_NFLAG = (1U << 31U), // Negative condition flag
-    FPSCR_ZFLAG         = (1 << 30),   // Zero condition flag
+    FPSCR_ZFLAG = (1 << 30),   // Zero condition flag
-    FPSCR_CFLAG         = (1 << 29),   // Carry condition flag
+    FPSCR_CFLAG = (1 << 29),   // Carry condition flag
-    FPSCR_VFLAG         = (1 << 28),   // Overflow condition flag
+    FPSCR_VFLAG = (1 << 28),   // Overflow condition flag
-    FPSCR_QC            = (1 << 27),   // Cumulative saturation bit
+    FPSCR_QC = (1 << 27),            // Cumulative saturation bit
-    FPSCR_AHP           = (1 << 26),   // Alternative half-precision control bit
+    FPSCR_AHP = (1 << 26),           // Alternative half-precision control bit
-    FPSCR_DEFAULT_NAN   = (1 << 25),   // Default NaN mode control bit
+    FPSCR_DEFAULT_NAN = (1 << 25),   // Default NaN mode control bit
-    FPSCR_FLUSH_TO_ZERO = (1 << 24),   // Flush-to-zero mode control bit
+    FPSCR_FLUSH_TO_ZERO = (1 << 24), // Flush-to-zero mode control bit
-    FPSCR_RMODE_MASK    = (3 << 22),   // Rounding Mode bit mask
+    FPSCR_RMODE_MASK = (3 << 22),    // Rounding Mode bit mask
-    FPSCR_STRIDE_MASK   = (3 << 20),   // Vector stride bit mask
+    FPSCR_STRIDE_MASK = (3 << 20),   // Vector stride bit mask
-    FPSCR_LENGTH_MASK   = (7 << 16),   // Vector length bit mask
+    FPSCR_LENGTH_MASK = (7 << 16),   // Vector length bit mask
-    FPSCR_IDE           = (1 << 15),   // Input Denormal exception trap enable.
+    FPSCR_IDE = (1 << 15), // Input Denormal exception trap enable.
-    FPSCR_IXE           = (1 << 12),   // Inexact exception trap enable
+    FPSCR_IXE = (1 << 12), // Inexact exception trap enable
-    FPSCR_UFE           = (1 << 11),   // Undeflow exception trap enable
+    FPSCR_UFE = (1 << 11), // Undeflow exception trap enable
-    FPSCR_OFE           = (1 << 10),   // Overflow exception trap enable
+    FPSCR_OFE = (1 << 10), // Overflow exception trap enable
-    FPSCR_DZE           = (1 << 9),    // Division by Zero exception trap enable
+    FPSCR_DZE = (1 << 9),  // Division by Zero exception trap enable
-    FPSCR_IOE           = (1 << 8),    // Invalid Operation exception trap enable
+    FPSCR_IOE = (1 << 8),  // Invalid Operation exception trap enable
-    FPSCR_IDC           = (1 << 7),    // Input Denormal cumulative exception bit
+    FPSCR_IDC = (1 << 7), // Input Denormal cumulative exception bit
-    FPSCR_IXC           = (1 << 4),    // Inexact cumulative exception bit
+    FPSCR_IXC = (1 << 4), // Inexact cumulative exception bit
-    FPSCR_UFC           = (1 << 3),    // Undeflow cumulative exception bit
+    FPSCR_UFC = (1 << 3), // Undeflow cumulative exception bit
-    FPSCR_OFC           = (1 << 2),    // Overflow cumulative exception bit
+    FPSCR_OFC = (1 << 2), // Overflow cumulative exception bit
-    FPSCR_DZC           = (1 << 1),    // Division by Zero cumulative exception bit
+    FPSCR_DZC = (1 << 1), // Division by Zero cumulative exception bit
-    FPSCR_IOC           = (1 << 0),    // Invalid Operation cumulative exception bit
+    FPSCR_IOC = (1 << 0), // Invalid Operation cumulative exception bit
 };
 // FPSCR bit offsets
 enum : u32 {
-    FPSCR_RMODE_BIT  = 22,
+    FPSCR_RMODE_BIT = 22,
    FPSCR_STRIDE_BIT = 20,
    FPSCR_LENGTH_BIT = 16,
 };
 // FPSCR rounding modes
 enum : u32 {
-    FPSCR_ROUND_NEAREST  = (0 << 22),
+    FPSCR_ROUND_NEAREST = (0 << 22),
-    FPSCR_ROUND_PLUSINF  = (1 << 22),
+    FPSCR_ROUND_PLUSINF = (1 << 22),
    FPSCR_ROUND_MINUSINF = (2 << 22),
-    FPSCR_ROUND_TOZERO   = (3 << 22)
+    FPSCR_ROUND_TOZERO = (3 << 22)
 };
diff --git a/src/core/arm/skyeye_common/vfp/vfp.cpp b/src/core/arm/skyeye_common/vfp/vfp.cpp
index a27a7e194..859937645 100644
--- a/src/core/arm/skyeye_common/vfp/vfp.cpp
+++ b/src/core/arm/skyeye_common/vfp/vfp.cpp
@@ -28,15 +28,14 @@
 #include "core/arm/skyeye_common/vfp/asm_vfp.h"
 #include "core/arm/skyeye_common/vfp/vfp.h"
-void VFPInit(ARMul_State* state)
+void VFPInit(ARMul_State* state) {
-{
+    state->VFP[VFP_FPSID] = VFP_FPSID_IMPLMEN << 24 | VFP_FPSID_SW << 23 | VFP_FPSID_SUBARCH << 16 |
-    state->VFP[VFP_FPSID] = VFP_FPSID_IMPLMEN<<24 | VFP_FPSID_SW<<23 | VFP_FPSID_SUBARCH<<16 |
+                            VFP_FPSID_PARTNUM << 8 | VFP_FPSID_VARIANT << 4 | VFP_FPSID_REVISION;
-                            VFP_FPSID_PARTNUM<<8 | VFP_FPSID_VARIANT<<4 | VFP_FPSID_REVISION;
    state->VFP[VFP_FPEXC] = 0;
    state->VFP[VFP_FPSCR] = 0;
    // ARM11 MPCore instruction register reset values.
-    state->VFP[VFP_FPINST]  = 0xEE000A00;
+    state->VFP[VFP_FPINST] = 0xEE000A00;
    state->VFP[VFP_FPINST2] = 0;
    // ARM11 MPCore feature register values.
@@ -44,104 +43,80 @@ void VFPInit(ARMul_State* state)
    state->VFP[VFP_MVFR1] = 0;
 }
-void VMOVBRS(ARMul_State* state, u32 to_arm, u32 t, u32 n, u32* value)
+void VMOVBRS(ARMul_State* state, u32 to_arm, u32 t, u32 n, u32* value) {
-{
+    if (to_arm) {
-    if (to_arm)
-    {
        *value = state->ExtReg[n];
-    }
+    } else {
-    else
-    {
        state->ExtReg[n] = *value;
    }
 }
-void VMOVBRRD(ARMul_State* state, u32 to_arm, u32 t, u32 t2, u32 n, u32* value1, u32* value2)
+void VMOVBRRD(ARMul_State* state, u32 to_arm, u32 t, u32 t2, u32 n, u32* value1, u32* value2) {
-{
+    if (to_arm) {
-    if (to_arm)
+        *value2 = state->ExtReg[n * 2 + 1];
-    {
+        *value1 = state->ExtReg[n * 2];
-        *value2 = state->ExtReg[n*2+1];
+    } else {
-        *value1 = state->ExtReg[n*2];
+        state->ExtReg[n * 2 + 1] = *value2;
-    }
+        state->ExtReg[n * 2] = *value1;
-    else
-    {
-        state->ExtReg[n*2+1] = *value2;
-        state->ExtReg[n*2] = *value1;
    }
 }
-void VMOVBRRSS(ARMul_State* state, u32 to_arm, u32 t, u32 t2, u32 n, u32* value1, u32* value2)
+void VMOVBRRSS(ARMul_State* state, u32 to_arm, u32 t, u32 t2, u32 n, u32* value1, u32* value2) {
-{
+    if (to_arm) {
-    if (to_arm)
+        *value1 = state->ExtReg[n + 0];
-    {
+        *value2 = state->ExtReg[n + 1];
-        *value1 = state->ExtReg[n+0];
+    } else {
-        *value2 = state->ExtReg[n+1];
+        state->ExtReg[n + 0] = *value1;
-    }
+        state->ExtReg[n + 1] = *value2;
-    else
-    {
-        state->ExtReg[n+0] = *value1;
-        state->ExtReg[n+1] = *value2;
    }
 }
-void VMOVI(ARMul_State* state, u32 single, u32 d, u32 imm)
+void VMOVI(ARMul_State* state, u32 single, u32 d, u32 imm) {
-{
+    if (single) {
-    if (single)
-    {
        state->ExtReg[d] = imm;
-    }
+    } else {
-    else
-    {
        /* Check endian please */
-        state->ExtReg[d*2+1] = imm;
+        state->ExtReg[d * 2 + 1] = imm;
-        state->ExtReg[d*2] = 0;
+        state->ExtReg[d * 2] = 0;
    }
 }
-void VMOVR(ARMul_State* state, u32 single, u32 d, u32 m)
+void VMOVR(ARMul_State* state, u32 single, u32 d, u32 m) {
-{
+    if (single) {
-    if (single)
-    {
        state->ExtReg[d] = state->ExtReg[m];
-    }
+    } else {
-    else
-    {
        /* Check endian please */
-        state->ExtReg[d*2+1] = state->ExtReg[m*2+1];
+        state->ExtReg[d * 2 + 1] = state->ExtReg[m * 2 + 1];
-        state->ExtReg[d*2] = state->ExtReg[m*2];
+        state->ExtReg[d * 2] = state->ExtReg[m * 2];
    }
 }
 /* Miscellaneous functions */
-s32 vfp_get_float(ARMul_State* state, unsigned int reg)
+s32 vfp_get_float(ARMul_State* state, unsigned int reg) {
-{
    LOG_TRACE(Core_ARM11, "VFP get float: s%d=[%08x]", reg, state->ExtReg[reg]);
    return state->ExtReg[reg];
 }
-void vfp_put_float(ARMul_State* state, s32 val, unsigned int reg)
+void vfp_put_float(ARMul_State* state, s32 val, unsigned int reg) {
-{
    LOG_TRACE(Core_ARM11, "VFP put float: s%d <= [%08x]", reg, val);
    state->ExtReg[reg] = val;
 }
-u64 vfp_get_double(ARMul_State* state, unsigned int reg)
+u64 vfp_get_double(ARMul_State* state, unsigned int reg) {
-{
+    u64 result = ((u64)state->ExtReg[reg * 2 + 1]) << 32 | state->ExtReg[reg * 2];
-    u64 result = ((u64) state->ExtReg[reg*2+1])<<32 | state->ExtReg[reg*2];
    LOG_TRACE(Core_ARM11, "VFP get double: s[%d-%d]=[%016llx]", reg * 2 + 1, reg * 2, result);
    return result;
 }
-void vfp_put_double(ARMul_State* state, u64 val, unsigned int reg)
+void vfp_put_double(ARMul_State* state, u64 val, unsigned int reg) {
-{
+    LOG_TRACE(Core_ARM11, "VFP put double: s[%d-%d] <= [%08x-%08x]", reg * 2 + 1, reg * 2,
-    LOG_TRACE(Core_ARM11, "VFP put double: s[%d-%d] <= [%08x-%08x]", reg * 2 + 1, reg * 2, (u32)(val >> 32), (u32)(val & 0xffffffff));
+              (u32)(val >> 32), (u32)(val & 0xffffffff));
-    state->ExtReg[reg*2] = (u32) (val & 0xffffffff);
+    state->ExtReg[reg * 2] = (u32)(val & 0xffffffff);
-    state->ExtReg[reg*2+1] = (u32) (val>>32);
+    state->ExtReg[reg * 2 + 1] = (u32)(val >> 32);
 }
 /*
 * Process bitmask of exception conditions. (from vfpmodule.c)
 */
-void vfp_raise_exceptions(ARMul_State* state, u32 exceptions, u32 inst, u32 fpscr)
+void vfp_raise_exceptions(ARMul_State* state, u32 exceptions, u32 inst, u32 fpscr) {
-{
    LOG_TRACE(Core_ARM11, "VFP: raising exceptions %08x", exceptions);
    if (exceptions == VFP_EXCEPTION_ERROR) {
@@ -154,8 +129,8 @@ void vfp_raise_exceptions(ARMul_State* state, u32 exceptions, u32 inst, u32 fpsc
     * Comparison instructions always return at least one of
     * these flags set.
     */
-    if (exceptions & (FPSCR_NFLAG|FPSCR_ZFLAG|FPSCR_CFLAG|FPSCR_VFLAG))
+    if (exceptions & (FPSCR_NFLAG | FPSCR_ZFLAG | FPSCR_CFLAG | FPSCR_VFLAG))
-        fpscr &= ~(FPSCR_NFLAG|FPSCR_ZFLAG|FPSCR_CFLAG|FPSCR_VFLAG);
+        fpscr &= ~(FPSCR_NFLAG | FPSCR_ZFLAG | FPSCR_CFLAG | FPSCR_VFLAG);
    fpscr |= exceptions;
diff --git a/src/core/arm/skyeye_common/vfp/vfp_helper.h b/src/core/arm/skyeye_common/vfp/vfp_helper.h
index 68714800c..5e14345ce 100644
--- a/src/core/arm/skyeye_common/vfp/vfp_helper.h
+++ b/src/core/arm/skyeye_common/vfp/vfp_helper.h
@@ -37,56 +37,56 @@
 #include "core/arm/skyeye_common/armstate.h"
 #include "core/arm/skyeye_common/vfp/asm_vfp.h"
-#define do_div(n, base) {n/=base;}
+#define do_div(n, base)                                                                            \
+    { n /= base; }
 enum : u32 {
-    FOP_MASK  = 0x00b00040,
+    FOP_MASK = 0x00b00040,
-    FOP_FMAC  = 0x00000000,
+    FOP_FMAC = 0x00000000,
    FOP_FNMAC = 0x00000040,
-    FOP_FMSC  = 0x00100000,
+    FOP_FMSC = 0x00100000,
    FOP_FNMSC = 0x00100040,
-    FOP_FMUL  = 0x00200000,
+    FOP_FMUL = 0x00200000,
    FOP_FNMUL = 0x00200040,
-    FOP_FADD  = 0x00300000,
+    FOP_FADD = 0x00300000,
-    FOP_FSUB  = 0x00300040,
+    FOP_FSUB = 0x00300040,
-    FOP_FDIV  = 0x00800000,
+    FOP_FDIV = 0x00800000,
-    FOP_EXT   = 0x00b00040
+    FOP_EXT = 0x00b00040
 };
 #define FOP_TO_IDX(inst) ((inst & 0x00b00000) >> 20 | (inst & (1 << 6)) >> 4)
 enum : u32 {
-    FEXT_MASK   = 0x000f0080,
+    FEXT_MASK = 0x000f0080,
-    FEXT_FCPY   = 0x00000000,
+    FEXT_FCPY = 0x00000000,
-    FEXT_FABS   = 0x00000080,
+    FEXT_FABS = 0x00000080,
-    FEXT_FNEG   = 0x00010000,
+    FEXT_FNEG = 0x00010000,
-    FEXT_FSQRT  = 0x00010080,
+    FEXT_FSQRT = 0x00010080,
-    FEXT_FCMP   = 0x00040000,
+    FEXT_FCMP = 0x00040000,
-    FEXT_FCMPE  = 0x00040080,
+    FEXT_FCMPE = 0x00040080,
-    FEXT_FCMPZ  = 0x00050000,
+    FEXT_FCMPZ = 0x00050000,
    FEXT_FCMPEZ = 0x00050080,
-    FEXT_FCVT   = 0x00070080,
+    FEXT_FCVT = 0x00070080,
-    FEXT_FUITO  = 0x00080000,
+    FEXT_FUITO = 0x00080000,
-    FEXT_FSITO  = 0x00080080,
+    FEXT_FSITO = 0x00080080,
-    FEXT_FTOUI  = 0x000c0000,
+    FEXT_FTOUI = 0x000c0000,
    FEXT_FTOUIZ = 0x000c0080,
-    FEXT_FTOSI  = 0x000d0000,
+    FEXT_FTOSI = 0x000d0000,
    FEXT_FTOSIZ = 0x000d0080
 };
 #define FEXT_TO_IDX(inst) ((inst & 0x000f0000) >> 15 | (inst & (1 << 7)) >> 7)
-#define vfp_get_sd(inst)  ((inst & 0x0000f000) >> 11 | (inst & (1 << 22)) >> 22)
+#define vfp_get_sd(inst) ((inst & 0x0000f000) >> 11 | (inst & (1 << 22)) >> 22)
-#define vfp_get_dd(inst)  ((inst & 0x0000f000) >> 12 | (inst & (1 << 22)) >> 18)
+#define vfp_get_dd(inst) ((inst & 0x0000f000) >> 12 | (inst & (1 << 22)) >> 18)
-#define vfp_get_sm(inst)  ((inst & 0x0000000f) << 1 | (inst & (1 << 5)) >> 5)
+#define vfp_get_sm(inst) ((inst & 0x0000000f) << 1 | (inst & (1 << 5)) >> 5)
-#define vfp_get_dm(inst)  ((inst & 0x0000000f) | (inst & (1 << 5)) >> 1)
+#define vfp_get_dm(inst) ((inst & 0x0000000f) | (inst & (1 << 5)) >> 1)
-#define vfp_get_sn(inst)  ((inst & 0x000f0000) >> 15 | (inst & (1 << 7)) >> 7)
+#define vfp_get_sn(inst) ((inst & 0x000f0000) >> 15 | (inst & (1 << 7)) >> 7)
-#define vfp_get_dn(inst)  ((inst & 0x000f0000) >> 16 | (inst & (1 << 7)) >> 3)
+#define vfp_get_dn(inst) ((inst & 0x000f0000) >> 16 | (inst & (1 << 7)) >> 3)
-#define vfp_single(inst)  (((inst) & 0x0000f00) == 0xa00)
+#define vfp_single(inst) (((inst)&0x0000f00) == 0xa00)
-inline u32 vfp_shiftright32jamming(u32 val, unsigned int shift)
+inline u32 vfp_shiftright32jamming(u32 val, unsigned int shift) {
-{
    if (shift) {
        if (shift < 32)
            val = val >> shift | ((val << (32 - shift)) != 0);
@@ -96,8 +96,7 @@ inline u32 vfp_shiftright32jamming(u32 val, unsigned int shift)
    return val;
 }
-inline u64 vfp_shiftright64jamming(u64 val, unsigned int shift)
+inline u64 vfp_shiftright64jamming(u64 val, unsigned int shift) {
-{
    if (shift) {
        if (shift < 64)
            val = val >> shift | ((val << (64 - shift)) != 0);
@@ -107,8 +106,7 @@ inline u64 vfp_shiftright64jamming(u64 val, unsigned int shift)
    return val;
 }
-inline u32 vfp_hi64to32jamming(u64 val)
+inline u32 vfp_hi64to32jamming(u64 val) {
-{
    u32 v;
    u32 highval = val >> 32;
    u32 lowval = val & 0xffffffff;
@@ -121,24 +119,21 @@ inline u32 vfp_hi64to32jamming(u64 val)
    return v;
 }
-inline void add128(u64* resh, u64* resl, u64 nh, u64 nl, u64 mh, u64 ml)
+inline void add128(u64* resh, u64* resl, u64 nh, u64 nl, u64 mh, u64 ml) {
-{
    *resl = nl + ml;
    *resh = nh + mh;
    if (*resl < nl)
        *resh += 1;
 }
-inline void sub128(u64* resh, u64* resl, u64 nh, u64 nl, u64 mh, u64 ml)
+inline void sub128(u64* resh, u64* resl, u64 nh, u64 nl, u64 mh, u64 ml) {
-{
    *resl = nl - ml;
    *resh = nh - mh;
    if (*resl > nl)
        *resh -= 1;
 }
-inline void mul64to128(u64* resh, u64* resl, u64 n, u64 m)
+inline void mul64to128(u64* resh, u64* resl, u64 n, u64 m) {
-{
    u32 nh, nl, mh, ml;
    u64 rh, rma, rmb, rl;
@@ -164,21 +159,18 @@ inline void mul64to128(u64* resh, u64* resl, u64 n, u64 m)
    *resh = rh;
 }
-inline void shift64left(u64* resh, u64* resl, u64 n)
+inline void shift64left(u64* resh, u64* resl, u64 n) {
-{
    *resh = n >> 63;
    *resl = n << 1;
 }
-inline u64 vfp_hi64multiply64(u64 n, u64 m)
+inline u64 vfp_hi64multiply64(u64 n, u64 m) {
-{
    u64 rh, rl;
    mul64to128(&rh, &rl, n, m);
    return rh | (rl != 0);
 }
-inline u64 vfp_estimate_div128to64(u64 nh, u64 nl, u64 m)
+inline u64 vfp_estimate_div128to64(u64 nh, u64 nl, u64 m) {
-{
    u64 mh, ml, remh, reml, termh, terml, z;
    if (nh >= m)
@@ -213,9 +205,9 @@ inline u64 vfp_estimate_div128to64(u64 nh, u64 nl, u64 m)
 // Single-precision
 struct vfp_single {
-    s16 exponent;
+    s16 exponent;
-    u16 sign;
+    u16 sign;
-    u32 significand;
+    u32 significand;
 };
 // VFP_SINGLE_MANTISSA_BITS - number of bits in the mantissa
@@ -224,33 +216,33 @@ struct vfp_single {
 // which are not propagated to the float upon packing.
 #define VFP_SINGLE_MANTISSA_BITS (23)
 #define VFP_SINGLE_EXPONENT_BITS (8)
-#define VFP_SINGLE_LOW_BITS      (32 - VFP_SINGLE_MANTISSA_BITS - 2)
+#define VFP_SINGLE_LOW_BITS (32 - VFP_SINGLE_MANTISSA_BITS - 2)
 #define VFP_SINGLE_LOW_BITS_MASK ((1 << VFP_SINGLE_LOW_BITS) - 1)
 // The bit in an unpacked float which indicates that it is a quiet NaN
-#define VFP_SINGLE_SIGNIFICAND_QNAN     (1 << (VFP_SINGLE_MANTISSA_BITS - 1 + VFP_SINGLE_LOW_BITS))
+#define VFP_SINGLE_SIGNIFICAND_QNAN (1 << (VFP_SINGLE_MANTISSA_BITS - 1 + VFP_SINGLE_LOW_BITS))
 // Operations on packed single-precision numbers
-#define vfp_single_packed_sign(v)     ((v) & 0x80000000)
+#define vfp_single_packed_sign(v) ((v)&0x80000000)
-#define vfp_single_packed_negate(v)   ((v) ^ 0x80000000)
+#define vfp_single_packed_negate(v) ((v) ^ 0x80000000)
-#define vfp_single_packed_abs(v)      ((v) & ~0x80000000)
+#define vfp_single_packed_abs(v) ((v) & ~0x80000000)
-#define vfp_single_packed_exponent(v) (((v) >> VFP_SINGLE_MANTISSA_BITS) & ((1 << VFP_SINGLE_EXPONENT_BITS) - 1))
+#define vfp_single_packed_exponent(v)                                                              \
+    (((v) >> VFP_SINGLE_MANTISSA_BITS) & ((1 << VFP_SINGLE_EXPONENT_BITS) - 1))
 #define vfp_single_packed_mantissa(v) ((v) & ((1 << VFP_SINGLE_MANTISSA_BITS) - 1))
 enum : u32 {
-    VFP_NUMBER     = (1 << 0),
+    VFP_NUMBER = (1 << 0),
-    VFP_ZERO       = (1 << 1),
+    VFP_ZERO = (1 << 1),
-    VFP_DENORMAL   = (1 << 2),
+    VFP_DENORMAL = (1 << 2),
-    VFP_INFINITY   = (1 << 3),
+    VFP_INFINITY = (1 << 3),
-    VFP_NAN        = (1 << 4),
+    VFP_NAN = (1 << 4),
    VFP_NAN_SIGNAL = (1 << 5),
-    VFP_QNAN       = (VFP_NAN),
+    VFP_QNAN = (VFP_NAN),
-    VFP_SNAN       = (VFP_NAN|VFP_NAN_SIGNAL)
+    VFP_SNAN = (VFP_NAN | VFP_NAN_SIGNAL)
 };
-inline int vfp_single_type(const vfp_single* s)
+inline int vfp_single_type(const vfp_single* s) {
-{
    int type = VFP_NUMBER;
    if (s->exponent == 255) {
        if (s->significand == 0)
@@ -271,11 +263,9 @@ inline int vfp_single_type(const vfp_single* s)
 // Unpack a single-precision float.  Note that this returns the magnitude
 // of the single-precision float mantissa with the 1. if necessary,
 // aligned to bit 30.
-inline u32 vfp_single_unpack(vfp_single* s, s32 val, u32 fpscr)
+inline u32 vfp_single_unpack(vfp_single* s, s32 val, u32 fpscr) {
-{
    u32 exceptions = 0;
-    s->sign = vfp_single_packed_sign(val) >> 16,
+    s->sign = vfp_single_packed_sign(val) >> 16, s->exponent = vfp_single_packed_exponent(val);
-    s->exponent = vfp_single_packed_exponent(val);
    u32 significand = ((u32)val << (32 - VFP_SINGLE_MANTISSA_BITS)) >> 2;
    if (s->exponent && s->exponent != 255)
@@ -295,22 +285,20 @@ inline u32 vfp_single_unpack(vfp_single* s, s32 val, u32 fpscr)
 // Re-pack a single-precision float. This assumes that the float is
 // already normalised such that the MSB is bit 30, _not_ bit 31.
-inline s32 vfp_single_pack(const vfp_single* s)
+inline s32 vfp_single_pack(const vfp_single* s) {
-{
+    u32 val = (s->sign << 16) + (s->exponent << VFP_SINGLE_MANTISSA_BITS) +
-    u32 val = (s->sign << 16) +
-              (s->exponent << VFP_SINGLE_MANTISSA_BITS) +
              (s->significand >> VFP_SINGLE_LOW_BITS);
    return (s32)val;
 }
+u32 vfp_single_normaliseround(ARMul_State* state, int sd, vfp_single* vs, u32 fpscr,
-u32 vfp_single_normaliseround(ARMul_State* state, int sd, vfp_single* vs, u32 fpscr, const char* func);
+                              const char* func);
 // Double-precision
 struct vfp_double {
-    s16 exponent;
+    s16 exponent;
-    u16 sign;
+    u16 sign;
-    u64 significand;
+    u64 significand;
 };
 // VFP_REG_ZERO is a special register number for vfp_get_double
@@ -324,21 +312,21 @@ struct vfp_double {
 #define VFP_DOUBLE_MANTISSA_BITS (52)
 #define VFP_DOUBLE_EXPONENT_BITS (11)
-#define VFP_DOUBLE_LOW_BITS      (64 - VFP_DOUBLE_MANTISSA_BITS - 2)
+#define VFP_DOUBLE_LOW_BITS (64 - VFP_DOUBLE_MANTISSA_BITS - 2)
 #define VFP_DOUBLE_LOW_BITS_MASK ((1 << VFP_DOUBLE_LOW_BITS) - 1)
 // The bit in an unpacked double which indicates that it is a quiet NaN
 #define VFP_DOUBLE_SIGNIFICAND_QNAN (1ULL << (VFP_DOUBLE_MANTISSA_BITS - 1 + VFP_DOUBLE_LOW_BITS))
 // Operations on packed single-precision numbers
-#define vfp_double_packed_sign(v)     ((v) & (1ULL << 63))
+#define vfp_double_packed_sign(v) ((v) & (1ULL << 63))
-#define vfp_double_packed_negate(v)   ((v) ^ (1ULL << 63))
+#define vfp_double_packed_negate(v) ((v) ^ (1ULL << 63))
-#define vfp_double_packed_abs(v)      ((v) & ~(1ULL << 63))
+#define vfp_double_packed_abs(v) ((v) & ~(1ULL << 63))
-#define vfp_double_packed_exponent(v) (((v) >> VFP_DOUBLE_MANTISSA_BITS) & ((1 << VFP_DOUBLE_EXPONENT_BITS) - 1))
+#define vfp_double_packed_exponent(v)                                                              \
+    (((v) >> VFP_DOUBLE_MANTISSA_BITS) & ((1 << VFP_DOUBLE_EXPONENT_BITS) - 1))
 #define vfp_double_packed_mantissa(v) ((v) & ((1ULL << VFP_DOUBLE_MANTISSA_BITS) - 1))
-inline int vfp_double_type(const vfp_double* s)
+inline int vfp_double_type(const vfp_double* s) {
-{
    int type = VFP_NUMBER;
    if (s->exponent == 2047) {
        if (s->significand == 0)
@@ -359,8 +347,7 @@ inline int vfp_double_type(const vfp_double* s)
 // Unpack a double-precision float.  Note that this returns the magnitude
 // of the double-precision float mantissa with the 1. if necessary,
 // aligned to bit 62.
-inline u32 vfp_double_unpack(vfp_double* s, s64 val, u32 fpscr)
+inline u32 vfp_double_unpack(vfp_double* s, s64 val, u32 fpscr) {
-{
    u32 exceptions = 0;
    s->sign = vfp_double_packed_sign(val) >> 48;
    s->exponent = vfp_double_packed_exponent(val);
@@ -383,10 +370,8 @@ inline u32 vfp_double_unpack(vfp_double* s, s64 val, u32 fpscr)
 // Re-pack a double-precision float. This assumes that the float is
 // already normalised such that the MSB is bit 30, _not_ bit 31.
-inline s64 vfp_double_pack(const vfp_double* s)
+inline s64 vfp_double_pack(const vfp_double* s) {
-{
+    u64 val = ((u64)s->sign << 48) + ((u64)s->exponent << VFP_DOUBLE_MANTISSA_BITS) +
-    u64 val = ((u64)s->sign << 48) +
-              ((u64)s->exponent << VFP_DOUBLE_MANTISSA_BITS) +
              (s->significand >> VFP_DOUBLE_LOW_BITS);
    return (s64)val;
 }
@@ -407,20 +392,14 @@ u32 vfp_estimate_sqrt_significand(u32 exponent, u32 significand);
 //  OP_SD     - The instruction exceptionally writes to a single precision result.
 //  OP_DD     - The instruction exceptionally writes to a double precision result.
 //  OP_SM     - The instruction exceptionally reads from a single precision operand.
-enum : u32 {
+enum : u32 { OP_SCALAR = (1 << 0), OP_SD = (1 << 1), OP_DD = (1 << 1), OP_SM = (1 << 2) };
-    OP_SCALAR = (1 << 0),
-    OP_SD     = (1 << 1),
-    OP_DD     = (1 << 1),
-    OP_SM     = (1 << 2)
-};
 struct op {
-    u32 (* const fn)(ARMul_State* state, int dd, int dn, int dm, u32 fpscr);
+    u32 (*const fn)(ARMul_State* state, int dd, int dn, int dm, u32 fpscr);
    u32 flags;
 };
-inline u32 fls(u32 x)
+inline u32 fls(u32 x) {
-{
    int r = 32;
    if (!x)
@@ -446,9 +425,9 @@ inline u32 fls(u32 x)
        r -= 1;
    }
    return r;
 }
 u32 vfp_double_multiply(vfp_double* vdd, vfp_double* vdn, vfp_double* vdm, u32 fpscr);
-u32 vfp_double_add(vfp_double* vdd, vfp_double* vdn, vfp_double *vdm, u32 fpscr);
+u32 vfp_double_add(vfp_double* vdd, vfp_double* vdn, vfp_double* vdm, u32 fpscr);
-u32 vfp_double_normaliseround(ARMul_State* state, int dd, vfp_double* vd, u32 fpscr, const char* func);
+u32 vfp_double_normaliseround(ARMul_State* state, int dd, vfp_double* vd, u32 fpscr,
+                              const char* func);
diff --git a/src/core/arm/skyeye_common/vfp/vfpdouble.cpp b/src/core/arm/skyeye_common/vfp/vfpdouble.cpp
index 1d5641810..4d89743e7 100644
--- a/src/core/arm/skyeye_common/vfp/vfpdouble.cpp
+++ b/src/core/arm/skyeye_common/vfp/vfpdouble.cpp
@@ -51,26 +51,22 @@
 * ===========================================================================
 */
+#include "core/arm/skyeye_common/vfp/vfp.h"
 #include <algorithm>
 #include "common/logging/log.h"
-#include "core/arm/skyeye_common/vfp/vfp.h"
-#include "core/arm/skyeye_common/vfp/vfp_helper.h"
 #include "core/arm/skyeye_common/vfp/asm_vfp.h"
+#include "core/arm/skyeye_common/vfp/vfp_helper.h"
 static struct vfp_double vfp_double_default_qnan = {
-    2047,
+    2047, 0, VFP_DOUBLE_SIGNIFICAND_QNAN,
-    0,
-    VFP_DOUBLE_SIGNIFICAND_QNAN,
 };
-static void vfp_double_dump(const char *str, struct vfp_double *d)
+static void vfp_double_dump(const char* str, struct vfp_double* d) {
-{
+    LOG_TRACE(Core_ARM11, "VFP: %s: sign=%d exponent=%d significand=%016llx", str, d->sign != 0,
-    LOG_TRACE(Core_ARM11, "VFP: %s: sign=%d exponent=%d significand=%016llx",
+              d->exponent, d->significand);
-             str, d->sign != 0, d->exponent, d->significand);
 }
-static void vfp_double_normalise_denormal(struct vfp_double *vd)
+static void vfp_double_normalise_denormal(struct vfp_double* vd) {
-{
    int bits = 31 - fls((u32)(vd->significand >> 32));
    if (bits == 31)
        bits = 63 - fls((u32)vd->significand);
@@ -85,8 +81,8 @@ static void vfp_double_normalise_denormal(struct vfp_double *vd)
    vfp_double_dump("normalise_denormal: out", vd);
 }
-u32 vfp_double_normaliseround(ARMul_State* state, int dd, struct vfp_double *vd, u32 fpscr, const char *func)
+u32 vfp_double_normaliseround(ARMul_State* state, int dd, struct vfp_double* vd, u32 fpscr,
-{
+                              const char* func) {
    u64 significand, incr;
    int exponent, shift, underflow;
    u32 rmode;
@@ -193,7 +189,7 @@ u32 vfp_double_normaliseround(ARMul_State* state, int dd, struct vfp_double *vd,
            vd->exponent = 2045;
            vd->significand = 0x7fffffffffffffffULL;
        } else {
-            vd->exponent = 2047;                /* infinity */
+            vd->exponent = 2047; /* infinity */
            vd->significand = 0;
        }
    } else {
@@ -211,8 +207,7 @@ pack:
    vfp_double_dump("pack: final", vd);
    {
        s64 d = vfp_double_pack(vd);
-        LOG_TRACE(Core_ARM11, "VFP: %s: d(d%d)=%016llx exceptions=%08x", func,
+        LOG_TRACE(Core_ARM11, "VFP: %s: d(d%d)=%016llx exceptions=%08x", func, dd, d, exceptions);
-                 dd, d, exceptions);
        vfp_put_double(state, d, dd);
    }
    return exceptions;
@@ -222,11 +217,9 @@ pack:
 * Propagate the NaN, setting exceptions if it is signalling.
 * 'n' is always a NaN.  'm' may be a number, NaN or infinity.
 */
-static u32
+static u32 vfp_propagate_nan(struct vfp_double* vdd, struct vfp_double* vdn, struct vfp_double* vdm,
-vfp_propagate_nan(struct vfp_double *vdd, struct vfp_double *vdn,
+                             u32 fpscr) {
-                  struct vfp_double *vdm, u32 fpscr)
+    struct vfp_double* nan;
-{
-    struct vfp_double *nan;
    int tn, tm = 0;
    tn = vfp_double_type(vdn);
@@ -266,29 +259,25 @@ vfp_propagate_nan(struct vfp_double *vdd, struct vfp_double *vdn,
 /*
 * Extended operations
 */
-static u32 vfp_double_fabs(ARMul_State* state, int dd, int unused, int dm, u32 fpscr)
+static u32 vfp_double_fabs(ARMul_State* state, int dd, int unused, int dm, u32 fpscr) {
-{
    LOG_TRACE(Core_ARM11, "In %s", __FUNCTION__);
    vfp_put_double(state, vfp_double_packed_abs(vfp_get_double(state, dm)), dd);
    return 0;
 }
-static u32 vfp_double_fcpy(ARMul_State* state, int dd, int unused, int dm, u32 fpscr)
+static u32 vfp_double_fcpy(ARMul_State* state, int dd, int unused, int dm, u32 fpscr) {
-{
    LOG_TRACE(Core_ARM11, "In %s", __FUNCTION__);
    vfp_put_double(state, vfp_get_double(state, dm), dd);
    return 0;
 }
-static u32 vfp_double_fneg(ARMul_State* state, int dd, int unused, int dm, u32 fpscr)
+static u32 vfp_double_fneg(ARMul_State* state, int dd, int unused, int dm, u32 fpscr) {
-{
    LOG_TRACE(Core_ARM11, "In %s", __FUNCTION__);
    vfp_put_double(state, vfp_double_packed_negate(vfp_get_double(state, dm)), dd);
    return 0;
 }
-static u32 vfp_double_fsqrt(ARMul_State* state, int dd, int unused, int dm, u32 fpscr)
+static u32 vfp_double_fsqrt(ARMul_State* state, int dd, int unused, int dm, u32 fpscr) {
-{
    LOG_TRACE(Core_ARM11, "In %s", __FUNCTION__);
    vfp_double vdm, vdd, *vdp;
    int ret, tm;
@@ -297,17 +286,17 @@ static u32 vfp_double_fsqrt(ARMul_State* state, int dd, int unused, int dm, u32
    exceptions |= vfp_double_unpack(&vdm, vfp_get_double(state, dm), fpscr);
    tm = vfp_double_type(&vdm);
-    if (tm & (VFP_NAN|VFP_INFINITY)) {
+    if (tm & (VFP_NAN | VFP_INFINITY)) {
        vdp = &vdd;
        if (tm & VFP_NAN)
            ret = vfp_propagate_nan(vdp, &vdm, nullptr, fpscr);
        else if (vdm.sign == 0) {
-sqrt_copy:
+        sqrt_copy:
            vdp = &vdm;
            ret = 0;
        } else {
-sqrt_invalid:
+        sqrt_invalid:
            vdp = &vfp_double_default_qnan;
            ret = FPSCR_IOC;
        }
@@ -381,8 +370,7 @@ sqrt_invalid:
 * Greater than := C
 * Unordered    := CV
 */
-static u32 vfp_compare(ARMul_State* state, int dd, int signal_on_qnan, int dm, u32 fpscr)
+static u32 vfp_compare(ARMul_State* state, int dd, int signal_on_qnan, int dm, u32 fpscr) {
-{
    s64 d, m;
    u32 ret = 0;
@@ -390,7 +378,8 @@ static u32 vfp_compare(ARMul_State* state, int dd, int signal_on_qnan, int dm, u
    m = vfp_get_double(state, dm);
    if (vfp_double_packed_exponent(m) == 2047 && vfp_double_packed_mantissa(m)) {
        ret |= FPSCR_CFLAG | FPSCR_VFLAG;
-        if (signal_on_qnan || !(vfp_double_packed_mantissa(m) & (1ULL << (VFP_DOUBLE_MANTISSA_BITS - 1))))
+        if (signal_on_qnan ||
+            !(vfp_double_packed_mantissa(m) & (1ULL << (VFP_DOUBLE_MANTISSA_BITS - 1))))
            /*
             * Signalling NaN, or signalling on quiet NaN
             */
@@ -400,7 +389,8 @@ static u32 vfp_compare(ARMul_State* state, int dd, int signal_on_qnan, int dm, u
    d = vfp_get_double(state, dd);
    if (vfp_double_packed_exponent(d) == 2047 && vfp_double_packed_mantissa(d)) {
        ret |= FPSCR_CFLAG | FPSCR_VFLAG;
-        if (signal_on_qnan || !(vfp_double_packed_mantissa(d) & (1ULL << (VFP_DOUBLE_MANTISSA_BITS - 1))))
+        if (signal_on_qnan ||
+            !(vfp_double_packed_mantissa(d) & (1ULL << (VFP_DOUBLE_MANTISSA_BITS - 1))))
            /*
             * Signalling NaN, or signalling on quiet NaN
             */
@@ -408,13 +398,13 @@ static u32 vfp_compare(ARMul_State* state, int dd, int signal_on_qnan, int dm, u
    }
    if (ret == 0) {
-        //printf("In %s, d=%lld, m =%lld\n ", __FUNCTION__, d, m);
+        // printf("In %s, d=%lld, m =%lld\n ", __FUNCTION__, d, m);
        if (d == m || vfp_double_packed_abs(d | m) == 0) {
            /*
             * equal
             */
            ret |= FPSCR_ZFLAG | FPSCR_CFLAG;
-            //printf("In %s,1 ret=0x%x\n", __FUNCTION__, ret);
+            // printf("In %s,1 ret=0x%x\n", __FUNCTION__, ret);
        } else if (vfp_double_packed_sign(d ^ m)) {
            /*
             * different signs
@@ -446,32 +436,27 @@ static u32 vfp_compare(ARMul_State* state, int dd, int signal_on_qnan, int dm, u
    return ret;
 }
-static u32 vfp_double_fcmp(ARMul_State* state, int dd, int unused, int dm, u32 fpscr)
+static u32 vfp_double_fcmp(ARMul_State* state, int dd, int unused, int dm, u32 fpscr) {
-{
    LOG_TRACE(Core_ARM11, "In %s", __FUNCTION__);
    return vfp_compare(state, dd, 0, dm, fpscr);
 }
-static u32 vfp_double_fcmpe(ARMul_State* state, int dd, int unused, int dm, u32 fpscr)
+static u32 vfp_double_fcmpe(ARMul_State* state, int dd, int unused, int dm, u32 fpscr) {
-{
    LOG_TRACE(Core_ARM11, "In %s", __FUNCTION__);
    return vfp_compare(state, dd, 1, dm, fpscr);
 }
-static u32 vfp_double_fcmpz(ARMul_State* state, int dd, int unused, int dm, u32 fpscr)
+static u32 vfp_double_fcmpz(ARMul_State* state, int dd, int unused, int dm, u32 fpscr) {
-{
    LOG_TRACE(Core_ARM11, "In %s", __FUNCTION__);
    return vfp_compare(state, dd, 0, VFP_REG_ZERO, fpscr);
 }
-static u32 vfp_double_fcmpez(ARMul_State* state, int dd, int unused, int dm, u32 fpscr)
+static u32 vfp_double_fcmpez(ARMul_State* state, int dd, int unused, int dm, u32 fpscr) {
-{
    LOG_TRACE(Core_ARM11, "In %s", __FUNCTION__);
    return vfp_compare(state, dd, 1, VFP_REG_ZERO, fpscr);
 }
-static u32 vfp_double_fcvts(ARMul_State* state, int sd, int unused, int dm, u32 fpscr)
+static u32 vfp_double_fcvts(ARMul_State* state, int sd, int unused, int dm, u32 fpscr) {
-{
    struct vfp_double vdm;
    struct vfp_single vsd;
    int tm;
@@ -497,7 +482,7 @@ static u32 vfp_double_fcvts(ARMul_State* state, int sd, int unused, int dm, u32
    /*
     * If we have an infinity or a NaN, the exponent must be 255
     */
-    if (tm & (VFP_INFINITY|VFP_NAN)) {
+    if (tm & (VFP_INFINITY | VFP_NAN)) {
        vsd.exponent = 255;
        if (tm == VFP_QNAN)
            vsd.significand |= VFP_SINGLE_SIGNIFICAND_QNAN;
@@ -515,8 +500,7 @@ pack_nan:
    return exceptions;
 }
-static u32 vfp_double_fuito(ARMul_State* state, int dd, int unused, int dm, u32 fpscr)
+static u32 vfp_double_fuito(ARMul_State* state, int dd, int unused, int dm, u32 fpscr) {
-{
    struct vfp_double vdm;
    u32 exceptions = 0;
    u32 m = vfp_get_float(state, dm);
@@ -530,8 +514,7 @@ static u32 vfp_double_fuito(ARMul_State* state, int dd, int unused, int dm, u32
    return exceptions;
 }
-static u32 vfp_double_fsito(ARMul_State* state, int dd, int unused, int dm, u32 fpscr)
+static u32 vfp_double_fsito(ARMul_State* state, int dd, int unused, int dm, u32 fpscr) {
-{
    struct vfp_double vdm;
    u32 exceptions = 0;
    u32 m = vfp_get_float(state, dm);
@@ -545,8 +528,7 @@ static u32 vfp_double_fsito(ARMul_State* state, int dd, int unused, int dm, u32
    return exceptions;
 }
-static u32 vfp_double_ftoui(ARMul_State* state, int sd, int unused, int dm, u32 fpscr)
+static u32 vfp_double_ftoui(ARMul_State* state, int sd, int unused, int dm, u32 fpscr) {
-{
    struct vfp_double vdm;
    u32 d, exceptions = 0;
    int rmode = fpscr & FPSCR_RMODE_MASK;
@@ -628,14 +610,13 @@ static u32 vfp_double_ftoui(ARMul_State* state, int sd, int unused, int dm, u32
    return exceptions;
 }
-static u32 vfp_double_ftouiz(ARMul_State* state, int sd, int unused, int dm, u32 fpscr)
+static u32 vfp_double_ftouiz(ARMul_State* state, int sd, int unused, int dm, u32 fpscr) {
-{
    LOG_TRACE(Core_ARM11, "In %s", __FUNCTION__);
-    return vfp_double_ftoui(state, sd, unused, dm, (fpscr & ~FPSCR_RMODE_MASK) | FPSCR_ROUND_TOZERO);
+    return vfp_double_ftoui(state, sd, unused, dm,
+                            (fpscr & ~FPSCR_RMODE_MASK) | FPSCR_ROUND_TOZERO);
 }
-static u32 vfp_double_ftosi(ARMul_State* state, int sd, int unused, int dm, u32 fpscr)
+static u32 vfp_double_ftosi(ARMul_State* state, int sd, int unused, int dm, u32 fpscr) {
-{
    struct vfp_double vdm;
    u32 d, exceptions = 0;
    int rmode = fpscr & FPSCR_RMODE_MASK;
@@ -661,7 +642,7 @@ static u32 vfp_double_ftosi(ARMul_State* state, int sd, int unused, int dm, u32
            d = ~d;
        exceptions |= FPSCR_IOC;
    } else if (vdm.exponent >= 1023) {
-        int shift = 1023 + 63 - vdm.exponent;   /* 58 */
+        int shift = 1023 + 63 - vdm.exponent; /* 58 */
        u64 rem, incr = 0;
        d = (u32)((vdm.significand << 1) >> shift);
@@ -712,48 +693,46 @@ static u32 vfp_double_ftosi(ARMul_State* state, int sd, int unused, int dm, u32
    return exceptions;
 }
-static u32 vfp_double_ftosiz(ARMul_State* state, int dd, int unused, int dm, u32 fpscr)
+static u32 vfp_double_ftosiz(ARMul_State* state, int dd, int unused, int dm, u32 fpscr) {
-{
    LOG_TRACE(Core_ARM11, "In %s", __FUNCTION__);
-    return vfp_double_ftosi(state, dd, unused, dm, (fpscr & ~FPSCR_RMODE_MASK) | FPSCR_ROUND_TOZERO);
+    return vfp_double_ftosi(state, dd, unused, dm,
+                            (fpscr & ~FPSCR_RMODE_MASK) | FPSCR_ROUND_TOZERO);
 }
 static struct op fops_ext[] = {
-    { vfp_double_fcpy,   0 },                 //0x00000000 - FEXT_FCPY
+    {vfp_double_fcpy, 0},  // 0x00000000 - FEXT_FCPY
-    { vfp_double_fabs,   0 },                 //0x00000001 - FEXT_FABS
+    {vfp_double_fabs, 0},  // 0x00000001 - FEXT_FABS
-    { vfp_double_fneg,   0 },                 //0x00000002 - FEXT_FNEG
+    {vfp_double_fneg, 0},  // 0x00000002 - FEXT_FNEG
-    { vfp_double_fsqrt,  0 },                 //0x00000003 - FEXT_FSQRT
+    {vfp_double_fsqrt, 0}, // 0x00000003 - FEXT_FSQRT
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { vfp_double_fcmp,   OP_SCALAR },         //0x00000008 - FEXT_FCMP
+    {vfp_double_fcmp, OP_SCALAR},   // 0x00000008 - FEXT_FCMP
-    { vfp_double_fcmpe,  OP_SCALAR },         //0x00000009 - FEXT_FCMPE
+    {vfp_double_fcmpe, OP_SCALAR},  // 0x00000009 - FEXT_FCMPE
-    { vfp_double_fcmpz,  OP_SCALAR },         //0x0000000A - FEXT_FCMPZ
+    {vfp_double_fcmpz, OP_SCALAR},  // 0x0000000A - FEXT_FCMPZ
-    { vfp_double_fcmpez, OP_SCALAR },         //0x0000000B - FEXT_FCMPEZ
+    {vfp_double_fcmpez, OP_SCALAR}, // 0x0000000B - FEXT_FCMPEZ
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { vfp_double_fcvts,  OP_SCALAR|OP_DD },   //0x0000000F - FEXT_FCVT
+    {vfp_double_fcvts, OP_SCALAR | OP_DD}, // 0x0000000F - FEXT_FCVT
-    { vfp_double_fuito,  OP_SCALAR|OP_SM },   //0x00000010 - FEXT_FUITO
+    {vfp_double_fuito, OP_SCALAR | OP_SM}, // 0x00000010 - FEXT_FUITO
-    { vfp_double_fsito,  OP_SCALAR|OP_SM },   //0x00000011 - FEXT_FSITO
+    {vfp_double_fsito, OP_SCALAR | OP_SM}, // 0x00000011 - FEXT_FSITO
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { vfp_double_ftoui,  OP_SCALAR|OP_SD },   //0x00000018 - FEXT_FTOUI
+    {vfp_double_ftoui, OP_SCALAR | OP_SD},  // 0x00000018 - FEXT_FTOUI
-    { vfp_double_ftouiz, OP_SCALAR|OP_SD },   //0x00000019 - FEXT_FTOUIZ
+    {vfp_double_ftouiz, OP_SCALAR | OP_SD}, // 0x00000019 - FEXT_FTOUIZ
-    { vfp_double_ftosi,  OP_SCALAR|OP_SD },   //0x0000001A - FEXT_FTOSI
+    {vfp_double_ftosi, OP_SCALAR | OP_SD},  // 0x0000001A - FEXT_FTOSI
-    { vfp_double_ftosiz, OP_SCALAR|OP_SD },   //0x0000001B - FEXT_FTOSIZ
+    {vfp_double_ftosiz, OP_SCALAR | OP_SD}, // 0x0000001B - FEXT_FTOSIZ
 };
-static u32
+static u32 vfp_double_fadd_nonnumber(struct vfp_double* vdd, struct vfp_double* vdn,
-vfp_double_fadd_nonnumber(struct vfp_double *vdd, struct vfp_double *vdn,
+                                     struct vfp_double* vdm, u32 fpscr) {
-                          struct vfp_double *vdm, u32 fpscr)
+    struct vfp_double* vdp;
-{
-    struct vfp_double *vdp;
    u32 exceptions = 0;
    int tn, tm;
@@ -791,13 +770,12 @@ vfp_double_fadd_nonnumber(struct vfp_double *vdd, struct vfp_double *vdn,
    return exceptions;
 }
-u32 vfp_double_add(struct vfp_double *vdd, struct vfp_double *vdn,struct vfp_double *vdm, u32 fpscr)
+u32 vfp_double_add(struct vfp_double* vdd, struct vfp_double* vdn, struct vfp_double* vdm,
-{
+                   u32 fpscr) {
    u32 exp_diff;
    u64 m_sig;
-    if (vdn->significand & (1ULL << 63) ||
+    if (vdn->significand & (1ULL << 63) || vdm->significand & (1ULL << 63)) {
-            vdm->significand & (1ULL << 63)) {
        LOG_INFO(Core_ARM11, "VFP: bad FP values in %s", __func__);
        vfp_double_dump("VDN", vdn);
        vfp_double_dump("VDM", vdm);
@@ -841,8 +819,7 @@ u32 vfp_double_add(struct vfp_double *vdd, struct vfp_double *vdn,struct vfp_dou
            vdd->sign = vfp_sign_negate(vdd->sign);
            m_sig = (~m_sig + 1);
        } else if (m_sig == 0) {
-            vdd->sign = (fpscr & FPSCR_RMODE_MASK) ==
+            vdd->sign = (fpscr & FPSCR_RMODE_MASK) == FPSCR_ROUND_MINUSINF ? 0x8000 : 0;
-                        FPSCR_ROUND_MINUSINF ? 0x8000 : 0;
        }
    } else {
        m_sig += vdn->significand;
@@ -852,10 +829,8 @@ u32 vfp_double_add(struct vfp_double *vdd, struct vfp_double *vdn,struct vfp_dou
    return 0;
 }
-u32
+u32 vfp_double_multiply(struct vfp_double* vdd, struct vfp_double* vdn, struct vfp_double* vdm,
-vfp_double_multiply(struct vfp_double *vdd, struct vfp_double *vdn,
+                        u32 fpscr) {
-                    struct vfp_double *vdm, u32 fpscr)
-{
    vfp_double_dump("VDN", vdn);
    vfp_double_dump("VDM", vdm);
@@ -908,12 +883,11 @@ vfp_double_multiply(struct vfp_double *vdd, struct vfp_double *vdn,
    return 0;
 }
-#define NEG_MULTIPLY    (1 << 0)
+#define NEG_MULTIPLY (1 << 0)
-#define NEG_SUBTRACT    (1 << 1)
+#define NEG_SUBTRACT (1 << 1)
-static u32
+static u32 vfp_double_multiply_accumulate(ARMul_State* state, int dd, int dn, int dm, u32 fpscr,
-vfp_double_multiply_accumulate(ARMul_State* state, int dd, int dn, int dm, u32 fpscr, u32 negate, const char *func)
+                                          u32 negate, const char* func) {
-{
    struct vfp_double vdd, vdp, vdn, vdm;
    u32 exceptions = 0;
@@ -949,8 +923,7 @@ vfp_double_multiply_accumulate(ARMul_State* state, int dd, int dn, int dm, u32 f
 /*
 * sd = sd + (sn * sm)
 */
-static u32 vfp_double_fmac(ARMul_State* state, int dd, int dn, int dm, u32 fpscr)
+static u32 vfp_double_fmac(ARMul_State* state, int dd, int dn, int dm, u32 fpscr) {
-{
    LOG_TRACE(Core_ARM11, "In %s", __FUNCTION__);
    return vfp_double_multiply_accumulate(state, dd, dn, dm, fpscr, 0, "fmac");
 }
@@ -958,8 +931,7 @@ static u32 vfp_double_fmac(ARMul_State* state, int dd, int dn, int dm, u32 fpscr
 /*
 * sd = sd - (sn * sm)
 */
-static u32 vfp_double_fnmac(ARMul_State* state, int dd, int dn, int dm, u32 fpscr)
+static u32 vfp_double_fnmac(ARMul_State* state, int dd, int dn, int dm, u32 fpscr) {
-{
    LOG_TRACE(Core_ARM11, "In %s", __FUNCTION__);
    return vfp_double_multiply_accumulate(state, dd, dn, dm, fpscr, NEG_MULTIPLY, "fnmac");
 }
@@ -967,8 +939,7 @@ static u32 vfp_double_fnmac(ARMul_State* state, int dd, int dn, int dm, u32 fpsc
 /*
 * sd = -sd + (sn * sm)
 */
-static u32 vfp_double_fmsc(ARMul_State* state, int dd, int dn, int dm, u32 fpscr)
+static u32 vfp_double_fmsc(ARMul_State* state, int dd, int dn, int dm, u32 fpscr) {
-{
    LOG_TRACE(Core_ARM11, "In %s", __FUNCTION__);
    return vfp_double_multiply_accumulate(state, dd, dn, dm, fpscr, NEG_SUBTRACT, "fmsc");
 }
@@ -976,17 +947,16 @@ static u32 vfp_double_fmsc(ARMul_State* state, int dd, int dn, int dm, u32 fpscr
 /*
 * sd = -sd - (sn * sm)
 */
-static u32 vfp_double_fnmsc(ARMul_State* state, int dd, int dn, int dm, u32 fpscr)
+static u32 vfp_double_fnmsc(ARMul_State* state, int dd, int dn, int dm, u32 fpscr) {
-{
    LOG_TRACE(Core_ARM11, "In %s", __FUNCTION__);
-    return vfp_double_multiply_accumulate(state, dd, dn, dm, fpscr, NEG_SUBTRACT | NEG_MULTIPLY, "fnmsc");
+    return vfp_double_multiply_accumulate(state, dd, dn, dm, fpscr, NEG_SUBTRACT | NEG_MULTIPLY,
+                                          "fnmsc");
 }
 /*
 * sd = sn * sm
 */
-static u32 vfp_double_fmul(ARMul_State* state, int dd, int dn, int dm, u32 fpscr)
+static u32 vfp_double_fmul(ARMul_State* state, int dd, int dn, int dm, u32 fpscr) {
-{
    struct vfp_double vdd, vdn, vdm;
    u32 exceptions = 0;
@@ -1008,8 +978,7 @@ static u32 vfp_double_fmul(ARMul_State* state, int dd, int dn, int dm, u32 fpscr
 /*
 * sd = -(sn * sm)
 */
-static u32 vfp_double_fnmul(ARMul_State* state, int dd, int dn, int dm, u32 fpscr)
+static u32 vfp_double_fnmul(ARMul_State* state, int dd, int dn, int dm, u32 fpscr) {
-{
    struct vfp_double vdd, vdn, vdm;
    u32 exceptions = 0;
@@ -1032,8 +1001,7 @@ static u32 vfp_double_fnmul(ARMul_State* state, int dd, int dn, int dm, u32 fpsc
 /*
 * sd = sn + sm
 */
-static u32 vfp_double_fadd(ARMul_State* state, int dd, int dn, int dm, u32 fpscr)
+static u32 vfp_double_fadd(ARMul_State* state, int dd, int dn, int dm, u32 fpscr) {
-{
    struct vfp_double vdd, vdn, vdm;
    u32 exceptions = 0;
@@ -1055,8 +1023,7 @@ static u32 vfp_double_fadd(ARMul_State* state, int dd, int dn, int dm, u32 fpscr
 /*
 * sd = sn - sm
 */
-static u32 vfp_double_fsub(ARMul_State* state, int dd, int dn, int dm, u32 fpscr)
+static u32 vfp_double_fsub(ARMul_State* state, int dd, int dn, int dm, u32 fpscr) {
-{
    struct vfp_double vdd, vdn, vdm;
    u32 exceptions = 0;
@@ -1083,8 +1050,7 @@ static u32 vfp_double_fsub(ARMul_State* state, int dd, int dn, int dm, u32 fpscr
 /*
 * sd = sn / sm
 */
-static u32 vfp_double_fdiv(ARMul_State* state, int dd, int dn, int dm, u32 fpscr)
+static u32 vfp_double_fdiv(ARMul_State* state, int dd, int dn, int dm, u32 fpscr) {
-{
    struct vfp_double vdd, vdn, vdm;
    u32 exceptions = 0;
    int tm, tn;
@@ -1114,7 +1080,7 @@ static u32 vfp_double_fdiv(ARMul_State* state, int dd, int dn, int dm, u32 fpscr
     * If n and m are infinity, the result is invalid
     * If n and m are zero, the result is invalid
     */
-    if (tm & tn & (VFP_INFINITY|VFP_ZERO))
+    if (tm & tn & (VFP_INFINITY | VFP_ZERO))
        goto invalid;
    /*
@@ -1193,29 +1159,22 @@ invalid:
 }
 static struct op fops[] = {
-    { vfp_double_fmac,  0 },
+    {vfp_double_fmac, 0},  {vfp_double_fmsc, 0},  {vfp_double_fmul, 0},
-    { vfp_double_fmsc,  0 },
+    {vfp_double_fadd, 0},  {vfp_double_fnmac, 0}, {vfp_double_fnmsc, 0},
-    { vfp_double_fmul,  0 },
+    {vfp_double_fnmul, 0}, {vfp_double_fsub, 0},  {vfp_double_fdiv, 0},
-    { vfp_double_fadd,  0 },
-    { vfp_double_fnmac, 0 },
-    { vfp_double_fnmsc, 0 },
-    { vfp_double_fnmul, 0 },
-    { vfp_double_fsub,  0 },
-    { vfp_double_fdiv,  0 },
 };
-#define FREG_BANK(x)    ((x) & 0x0c)
+#define FREG_BANK(x) ((x)&0x0c)
-#define FREG_IDX(x)     ((x) & 3)
+#define FREG_IDX(x) ((x)&3)
-u32 vfp_double_cpdo(ARMul_State* state, u32 inst, u32 fpscr)
+u32 vfp_double_cpdo(ARMul_State* state, u32 inst, u32 fpscr) {
-{
    u32 op = inst & FOP_MASK;
    u32 exceptions = 0;
    unsigned int dest;
    unsigned int dn = vfp_get_dn(inst);
    unsigned int dm;
    unsigned int vecitr, veclen, vecstride;
-    struct op *fop;
+    struct op* fop;
    LOG_TRACE(Core_ARM11, "In %s", __FUNCTION__);
    vecstride = (1 + ((fpscr & FPSCR_STRIDE_MASK) == FPSCR_STRIDE_MASK));
@@ -1249,7 +1208,7 @@ u32 vfp_double_cpdo(ARMul_State* state, u32 inst, u32 fpscr)
        veclen = fpscr & FPSCR_LENGTH_MASK;
    LOG_TRACE(Core_ARM11, "VFP: vecstride=%u veclen=%u", vecstride,
-             (veclen >> FPSCR_LENGTH_BIT) + 1);
+              (veclen >> FPSCR_LENGTH_BIT) + 1);
    if (!fop->fn) {
        printf("VFP: could not find double op %d\n", FEXT_TO_IDX(inst));
@@ -1262,17 +1221,14 @@ u32 vfp_double_cpdo(ARMul_State* state, u32 inst, u32 fpscr)
        type = (fop->flags & OP_SD) ? 's' : 'd';
        if (op == FOP_EXT)
-            LOG_TRACE(Core_ARM11, "VFP: itr%d (%c%u) = op[%u] (d%u)",
+            LOG_TRACE(Core_ARM11, "VFP: itr%d (%c%u) = op[%u] (d%u)", vecitr >> FPSCR_LENGTH_BIT,
-                     vecitr >> FPSCR_LENGTH_BIT,
+                      type, dest, dn, dm);
-                     type, dest, dn, dm);
        else
            LOG_TRACE(Core_ARM11, "VFP: itr%d (%c%u) = (d%u) op[%u] (d%u)",
-                     vecitr >> FPSCR_LENGTH_BIT,
+                      vecitr >> FPSCR_LENGTH_BIT, type, dest, dn, FOP_TO_IDX(op), dm);
-                     type, dest, dn, FOP_TO_IDX(op), dm);
        except = fop->fn(state, dest, dn, dm, fpscr);
-        LOG_TRACE(Core_ARM11, "VFP: itr%d: exceptions=%08x",
+        LOG_TRACE(Core_ARM11, "VFP: itr%d: exceptions=%08x", vecitr >> FPSCR_LENGTH_BIT, except);
-                 vecitr >> FPSCR_LENGTH_BIT, except);
        exceptions |= except;
diff --git a/src/core/arm/skyeye_common/vfp/vfpinstr.cpp b/src/core/arm/skyeye_common/vfp/vfpinstr.cpp
index 1a98d0114..a66dc1016 100644
--- a/src/core/arm/skyeye_common/vfp/vfpinstr.cpp
+++ b/src/core/arm/skyeye_common/vfp/vfpinstr.cpp
@@ -19,14 +19,13 @@ struct vmla_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vmla)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vmla)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vmla_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmla_inst));
+    vmla_inst* inst_cream = (vmla_inst*)inst_base->component;
-    vmla_inst *inst_cream = (vmla_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->dp_operation = BIT(inst, 8);
    inst_cream->instr = inst;
@@ -35,12 +34,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vmla)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VMLA_INST:
+VMLA_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vmla_inst *inst_cream = (vmla_inst *)inst_base->component;
+        vmla_inst* inst_cream = (vmla_inst*)inst_base->component;
        int ret;
@@ -68,14 +66,13 @@ struct vmls_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vmls)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vmls)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vmls_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmls_inst));
+    vmls_inst* inst_cream = (vmls_inst*)inst_base->component;
-    vmls_inst *inst_cream = (vmls_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->dp_operation = BIT(inst, 8);
    inst_cream->instr = inst;
@@ -84,12 +81,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vmls)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VMLS_INST:
+VMLS_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vmls_inst *inst_cream = (vmls_inst *)inst_base->component;
+        vmls_inst* inst_cream = (vmls_inst*)inst_base->component;
        int ret;
@@ -117,14 +113,13 @@ struct vnmla_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vnmla)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vnmla)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vnmla_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vnmla_inst));
+    vnmla_inst* inst_cream = (vnmla_inst*)inst_base->component;
-    vnmla_inst *inst_cream = (vnmla_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->dp_operation = BIT(inst, 8);
    inst_cream->instr = inst;
@@ -133,12 +128,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vnmla)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VNMLA_INST:
+VNMLA_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vnmla_inst *inst_cream = (vnmla_inst *)inst_base->component;
+        vnmla_inst* inst_cream = (vnmla_inst*)inst_base->component;
        int ret;
@@ -167,14 +161,13 @@ struct vnmls_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vnmls)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vnmls)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vnmls_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vnmls_inst));
+    vnmls_inst* inst_cream = (vnmls_inst*)inst_base->component;
-    vnmls_inst *inst_cream = (vnmls_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->dp_operation = BIT(inst, 8);
    inst_cream->instr = inst;
@@ -183,12 +176,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vnmls)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VNMLS_INST:
+VNMLS_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vnmls_inst *inst_cream = (vnmls_inst *)inst_base->component;
+        vnmls_inst* inst_cream = (vnmls_inst*)inst_base->component;
        int ret;
@@ -216,14 +208,13 @@ struct vnmul_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vnmul)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vnmul)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vnmul_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vnmul_inst));
+    vnmul_inst* inst_cream = (vnmul_inst*)inst_base->component;
-    vnmul_inst *inst_cream = (vnmul_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->dp_operation = BIT(inst, 8);
    inst_cream->instr = inst;
@@ -232,12 +223,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vnmul)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VNMUL_INST:
+VNMUL_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vnmul_inst *inst_cream = (vnmul_inst *)inst_base->component;
+        vnmul_inst* inst_cream = (vnmul_inst*)inst_base->component;
        int ret;
@@ -265,14 +255,13 @@ struct vmul_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vmul)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vmul)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vmul_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmul_inst));
+    vmul_inst* inst_cream = (vmul_inst*)inst_base->component;
-    vmul_inst *inst_cream = (vmul_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->dp_operation = BIT(inst, 8);
    inst_cream->instr = inst;
@@ -281,12 +270,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vmul)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VMUL_INST:
+VMUL_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vmul_inst *inst_cream = (vmul_inst *)inst_base->component;
+        vmul_inst* inst_cream = (vmul_inst*)inst_base->component;
        int ret;
@@ -314,14 +302,13 @@ struct vadd_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vadd)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vadd)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vadd_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vadd_inst));
+    vadd_inst* inst_cream = (vadd_inst*)inst_base->component;
-    vadd_inst *inst_cream = (vadd_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->dp_operation = BIT(inst, 8);
    inst_cream->instr = inst;
@@ -330,12 +317,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vadd)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VADD_INST:
+VADD_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vadd_inst *inst_cream = (vadd_inst *)inst_base->component;
+        vadd_inst* inst_cream = (vadd_inst*)inst_base->component;
        int ret;
@@ -363,14 +349,13 @@ struct vsub_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vsub)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vsub)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vsub_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vsub_inst));
+    vsub_inst* inst_cream = (vsub_inst*)inst_base->component;
-    vsub_inst *inst_cream = (vsub_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->dp_operation = BIT(inst, 8);
    inst_cream->instr = inst;
@@ -379,12 +364,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vsub)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VSUB_INST:
+VSUB_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vsub_inst *inst_cream = (vsub_inst *)inst_base->component;
+        vsub_inst* inst_cream = (vsub_inst*)inst_base->component;
        int ret;
@@ -412,14 +396,13 @@ struct vdiv_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vdiv)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vdiv)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vdiv_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vdiv_inst));
+    vdiv_inst* inst_cream = (vdiv_inst*)inst_base->component;
-    vdiv_inst *inst_cream = (vdiv_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->dp_operation = BIT(inst, 8);
    inst_cream->instr = inst;
@@ -428,12 +411,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vdiv)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VDIV_INST:
+VDIV_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vdiv_inst *inst_cream = (vdiv_inst *)inst_base->component;
+        vdiv_inst* inst_cream = (vdiv_inst*)inst_base->component;
        int ret;
@@ -463,32 +445,33 @@ struct vmovi_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vmovi)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vmovi)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vmovi_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmovi_inst));
+    vmovi_inst* inst_cream = (vmovi_inst*)inst_base->component;
-    vmovi_inst *inst_cream = (vmovi_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->single = BIT(inst, 8) == 0;
-    inst_cream->d      = (inst_cream->single ? BITS(inst,12,15)<<1 | BIT(inst,22) : BITS(inst,12,15) | BIT(inst,22)<<4);
+    inst_cream->d = (inst_cream->single ? BITS(inst, 12, 15) << 1 | BIT(inst, 22)
+                                        : BITS(inst, 12, 15) | BIT(inst, 22) << 4);
    unsigned int imm8 = BITS(inst, 16, 19) << 4 | BITS(inst, 0, 3);
    if (inst_cream->single)
-        inst_cream->imm = BIT(imm8, 7)<<31 | (BIT(imm8, 6)==0)<<30 | (BIT(imm8, 6) ? 0x1f : 0)<<25 | BITS(imm8, 0, 5)<<19;
+        inst_cream->imm = BIT(imm8, 7) << 31 | (BIT(imm8, 6) == 0) << 30 |
+                          (BIT(imm8, 6) ? 0x1f : 0) << 25 | BITS(imm8, 0, 5) << 19;
    else
-        inst_cream->imm = BIT(imm8, 7)<<31 | (BIT(imm8, 6)==0)<<30 | (BIT(imm8, 6) ? 0xff : 0)<<22 | BITS(imm8, 0, 5)<<16;
+        inst_cream->imm = BIT(imm8, 7) << 31 | (BIT(imm8, 6) == 0) << 30 |
+                          (BIT(imm8, 6) ? 0xff : 0) << 22 | BITS(imm8, 0, 5) << 16;
    return inst_base;
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VMOVI_INST:
+VMOVI_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vmovi_inst *inst_cream = (vmovi_inst *)inst_base->component;
+        vmovi_inst* inst_cream = (vmovi_inst*)inst_base->component;
        VMOVI(cpu, inst_cream->single, inst_cream->d, inst_cream->imm);
    }
@@ -511,28 +494,28 @@ struct vmovr_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vmovr)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vmovr)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vmovr_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmovr_inst));
+    vmovr_inst* inst_cream = (vmovr_inst*)inst_base->component;
-    vmovr_inst *inst_cream = (vmovr_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->single = BIT(inst, 8) == 0;
-    inst_cream->d      = (inst_cream->single ? BITS(inst,12,15)<<1 | BIT(inst,22) : BITS(inst,12,15) | BIT(inst,22)<<4);
+    inst_cream->d = (inst_cream->single ? BITS(inst, 12, 15) << 1 | BIT(inst, 22)
-    inst_cream->m      = (inst_cream->single ? BITS(inst, 0, 3)<<1 | BIT(inst, 5) : BITS(inst, 0, 3) | BIT(inst, 5)<<4);
+                                        : BITS(inst, 12, 15) | BIT(inst, 22) << 4);
+    inst_cream->m = (inst_cream->single ? BITS(inst, 0, 3) << 1 | BIT(inst, 5)
+                                        : BITS(inst, 0, 3) | BIT(inst, 5) << 4);
    return inst_base;
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VMOVR_INST:
+VMOVR_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vmovr_inst *inst_cream = (vmovr_inst *)inst_base->component;
+        vmovr_inst* inst_cream = (vmovr_inst*)inst_base->component;
        VMOVR(cpu, inst_cream->single, inst_cream->d, inst_cream->m);
    }
@@ -553,14 +536,13 @@ typedef struct _vabs_inst {
 } vabs_inst;
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vabs)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vabs)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vabs_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vabs_inst));
+    vabs_inst* inst_cream = (vabs_inst*)inst_base->component;
-    vabs_inst *inst_cream = (vabs_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->dp_operation = BIT(inst, 8);
    inst_cream->instr = inst;
@@ -569,12 +551,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vabs)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VABS_INST:
+VABS_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vabs_inst *inst_cream = (vabs_inst *)inst_base->component;
+        vabs_inst* inst_cream = (vabs_inst*)inst_base->component;
        int ret;
@@ -603,14 +584,13 @@ struct vneg_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vneg)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vneg)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vneg_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vneg_inst));
+    vneg_inst* inst_cream = (vneg_inst*)inst_base->component;
-    vneg_inst *inst_cream = (vneg_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->dp_operation = BIT(inst, 8);
    inst_cream->instr = inst;
@@ -619,12 +599,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vneg)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VNEG_INST:
+VNEG_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vneg_inst *inst_cream = (vneg_inst *)inst_base->component;
+        vneg_inst* inst_cream = (vneg_inst*)inst_base->component;
        int ret;
@@ -652,14 +631,13 @@ struct vsqrt_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vsqrt)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vsqrt)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vsqrt_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vsqrt_inst));
+    vsqrt_inst* inst_cream = (vsqrt_inst*)inst_base->component;
-    vsqrt_inst *inst_cream = (vsqrt_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->dp_operation = BIT(inst, 8);
    inst_cream->instr = inst;
@@ -668,12 +646,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vsqrt)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VSQRT_INST:
+VSQRT_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vsqrt_inst *inst_cream = (vsqrt_inst *)inst_base->component;
+        vsqrt_inst* inst_cream = (vsqrt_inst*)inst_base->component;
        int ret;
@@ -701,14 +678,13 @@ struct vcmp_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vcmp)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vcmp)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vcmp_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vcmp_inst));
+    vcmp_inst* inst_cream = (vcmp_inst*)inst_base->component;
-    vcmp_inst *inst_cream = (vcmp_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->dp_operation = BIT(inst, 8);
    inst_cream->instr = inst;
@@ -717,12 +693,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vcmp)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VCMP_INST:
+VCMP_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vcmp_inst *inst_cream = (vcmp_inst *)inst_base->component;
+        vcmp_inst* inst_cream = (vcmp_inst*)inst_base->component;
        int ret;
@@ -750,14 +725,13 @@ struct vcmp2_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vcmp2)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vcmp2)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vcmp2_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vcmp2_inst));
+    vcmp2_inst* inst_cream = (vcmp2_inst*)inst_base->component;
-    vcmp2_inst *inst_cream = (vcmp2_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->dp_operation = BIT(inst, 8);
    inst_cream->instr = inst;
@@ -766,12 +740,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vcmp2)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VCMP2_INST:
+VCMP2_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vcmp2_inst *inst_cream = (vcmp2_inst *)inst_base->component;
+        vcmp2_inst* inst_cream = (vcmp2_inst*)inst_base->component;
        int ret;
@@ -799,14 +772,13 @@ struct vcvtbds_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vcvtbds)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vcvtbds)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vcvtbds_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vcvtbds_inst));
+    vcvtbds_inst* inst_cream = (vcvtbds_inst*)inst_base->component;
-    vcvtbds_inst *inst_cream = (vcvtbds_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->dp_operation = BIT(inst, 8);
    inst_cream->instr = inst;
@@ -815,12 +787,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vcvtbds)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VCVTBDS_INST:
+VCVTBDS_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vcvtbds_inst *inst_cream = (vcvtbds_inst *)inst_base->component;
+        vcvtbds_inst* inst_cream = (vcvtbds_inst*)inst_base->component;
        int ret;
@@ -848,16 +819,15 @@ struct vcvtbff_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vcvtbff)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vcvtbff)(unsigned int inst, int index) {
-{
    VFP_DEBUG_UNTESTED(VCVTBFF);
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vcvtbff_inst));
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vcvtbff_inst));
-    vcvtbff_inst *inst_cream = (vcvtbff_inst *)inst_base->component;
+    vcvtbff_inst* inst_cream = (vcvtbff_inst*)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->dp_operation = BIT(inst, 8);
    inst_cream->instr = inst;
@@ -866,12 +836,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vcvtbff)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VCVTBFF_INST:
+VCVTBFF_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vcvtbff_inst *inst_cream = (vcvtbff_inst *)inst_base->component;
+        vcvtbff_inst* inst_cream = (vcvtbff_inst*)inst_base->component;
        int ret;
@@ -899,14 +868,13 @@ struct vcvtbfi_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vcvtbfi)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vcvtbfi)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vcvtbfi_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vcvtbfi_inst));
+    vcvtbfi_inst* inst_cream = (vcvtbfi_inst*)inst_base->component;
-    vcvtbfi_inst *inst_cream = (vcvtbfi_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->dp_operation = BIT(inst, 8);
    inst_cream->instr = inst;
@@ -915,12 +883,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vcvtbfi)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VCVTBFI_INST:
+VCVTBFI_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vcvtbfi_inst *inst_cream = (vcvtbfi_inst *)inst_base->component;
+        vcvtbfi_inst* inst_cream = (vcvtbfi_inst*)inst_base->component;
        int ret;
@@ -955,29 +922,27 @@ struct vmovbrs_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vmovbrs)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vmovbrs)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vmovbrs_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmovbrs_inst));
+    vmovbrs_inst* inst_cream = (vmovbrs_inst*)inst_base->component;
-    vmovbrs_inst *inst_cream = (vmovbrs_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->to_arm = BIT(inst, 20) == 1;
-    inst_cream->t      = BITS(inst, 12, 15);
+    inst_cream->t = BITS(inst, 12, 15);
-    inst_cream->n      = BIT(inst, 7) | BITS(inst, 16, 19)<<1;
+    inst_cream->n = BIT(inst, 7) | BITS(inst, 16, 19) << 1;
    return inst_base;
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VMOVBRS_INST:
+VMOVBRS_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vmovbrs_inst *inst_cream = (vmovbrs_inst *)inst_base->component;
+        vmovbrs_inst* inst_cream = (vmovbrs_inst*)inst_base->component;
        VMOVBRS(cpu, inst_cream->to_arm, inst_cream->t, inst_cream->n, &(cpu->Reg[inst_cream->t]));
    }
@@ -999,24 +964,22 @@ struct vmsr_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vmsr)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vmsr)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vmsr_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmsr_inst));
+    vmsr_inst* inst_cream = (vmsr_inst*)inst_base->component;
-    vmsr_inst *inst_cream = (vmsr_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->reg = BITS(inst, 16, 19);
-    inst_cream->Rt  = BITS(inst, 12, 15);
+    inst_cream->Rt = BITS(inst, 12, 15);
    return inst_base;
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VMSR_INST:
+VMSR_INST : {
-{
    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
        /* FIXME: special case for access to FPSID and FPEXC, VFP must be disabled ,
           and in privileged mode */
@@ -1026,14 +989,11 @@ VMSR_INST:
        vmsr_inst* const inst_cream = (vmsr_inst*)inst_base->component;
        unsigned int reg = inst_cream->reg;
-        unsigned int rt  = inst_cream->Rt;
+        unsigned int rt = inst_cream->Rt;
-        if (reg == 1)
+        if (reg == 1) {
-        {
            cpu->VFP[VFP_FPSCR] = cpu->Reg[rt];
-        }
+        } else if (cpu->InAPrivilegedMode()) {
-        else if (cpu->InAPrivilegedMode())
-        {
            if (reg == 8)
                cpu->VFP[VFP_FPEXC] = cpu->Reg[rt];
            else if (reg == 9)
@@ -1062,17 +1022,16 @@ struct vmovbrc_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vmovbrc)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vmovbrc)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vmovbrc_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmovbrc_inst));
+    vmovbrc_inst* inst_cream = (vmovbrc_inst*)inst_base->component;
-    vmovbrc_inst *inst_cream = (vmovbrc_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->d     = BITS(inst, 16, 19)|BIT(inst, 7)<<4;
+    inst_cream->d = BITS(inst, 16, 19) | BIT(inst, 7) << 4;
-    inst_cream->t     = BITS(inst, 12, 15);
+    inst_cream->t = BITS(inst, 12, 15);
    /* VFP variant of instruction */
    inst_cream->esize = 32;
    inst_cream->index = BIT(inst, 21);
@@ -1081,8 +1040,7 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vmovbrc)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VMOVBRC_INST:
+VMOVBRC_INST : {
-{
    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
@@ -1108,24 +1066,22 @@ struct vmrs_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vmrs)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vmrs)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vmrs_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmrs_inst));
+    vmrs_inst* inst_cream = (vmrs_inst*)inst_base->component;
-    vmrs_inst *inst_cream = (vmrs_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->reg = BITS(inst, 16, 19);
-    inst_cream->Rt  = BITS(inst, 12, 15);
+    inst_cream->Rt = BITS(inst, 12, 15);
    return inst_base;
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VMRS_INST:
+VMRS_INST : {
-{
    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
        /* FIXME: special case for access to FPSID and FPEXC, VFP must be disabled,
           and in privileged mode */
@@ -1135,36 +1091,25 @@ VMRS_INST:
        vmrs_inst* const inst_cream = (vmrs_inst*)inst_base->component;
        unsigned int reg = inst_cream->reg;
-        unsigned int rt  = inst_cream->Rt;
+        unsigned int rt = inst_cream->Rt;
        if (reg == 1) // FPSCR
        {
-            if (rt != 15)
+            if (rt != 15) {
-            {
                cpu->Reg[rt] = cpu->VFP[VFP_FPSCR];
-            }
+            } else {
-            else
-            {
                cpu->NFlag = (cpu->VFP[VFP_FPSCR] >> 31) & 1;
                cpu->ZFlag = (cpu->VFP[VFP_FPSCR] >> 30) & 1;
                cpu->CFlag = (cpu->VFP[VFP_FPSCR] >> 29) & 1;
                cpu->VFlag = (cpu->VFP[VFP_FPSCR] >> 28) & 1;
            }
-        }
+        } else if (reg == 0) {
-        else if (reg == 0)
-        {
            cpu->Reg[rt] = cpu->VFP[VFP_FPSID];
-        }
+        } else if (reg == 6) {
-        else if (reg == 6)
-        {
            cpu->Reg[rt] = cpu->VFP[VFP_MVFR1];
-        }
+        } else if (reg == 7) {
-        else if (reg == 7)
-        {
            cpu->Reg[rt] = cpu->VFP[VFP_MVFR0];
-        }
+        } else if (cpu->InAPrivilegedMode()) {
-        else if (cpu->InAPrivilegedMode())
-        {
            if (reg == 8)
                cpu->Reg[rt] = cpu->VFP[VFP_FPEXC];
            else if (reg == 9)
@@ -1193,17 +1138,16 @@ struct vmovbcr_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vmovbcr)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vmovbcr)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vmovbcr_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmovbcr_inst));
+    vmovbcr_inst* inst_cream = (vmovbcr_inst*)inst_base->component;
-    vmovbcr_inst *inst_cream = (vmovbcr_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->d     = BITS(inst, 16, 19)|BIT(inst, 7)<<4;
+    inst_cream->d = BITS(inst, 16, 19) | BIT(inst, 7) << 4;
-    inst_cream->t     = BITS(inst, 12, 15);
+    inst_cream->t = BITS(inst, 12, 15);
    /* VFP variant of instruction */
    inst_cream->esize = 32;
    inst_cream->index = BIT(inst, 21);
@@ -1212,12 +1156,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(vmovbcr)(unsigned int inst, int index)
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VMOVBCR_INST:
+VMOVBCR_INST : {
-{
    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vmovbcr_inst* const inst_cream = (vmovbcr_inst*) inst_base->component;
+        vmovbcr_inst* const inst_cream = (vmovbcr_inst*)inst_base->component;
        cpu->Reg[inst_cream->t] = cpu->ExtReg[(2 * inst_cream->d) + inst_cream->index];
    }
@@ -1246,33 +1189,31 @@ struct vmovbrrss_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vmovbrrss)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vmovbrrss)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vmovbrrss_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmovbrrss_inst));
+    vmovbrrss_inst* inst_cream = (vmovbrrss_inst*)inst_base->component;
-    vmovbrrss_inst *inst_cream = (vmovbrrss_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->to_arm = BIT(inst, 20) == 1;
-    inst_cream->t      = BITS(inst, 12, 15);
+    inst_cream->t = BITS(inst, 12, 15);
-    inst_cream->t2     = BITS(inst, 16, 19);
+    inst_cream->t2 = BITS(inst, 16, 19);
-    inst_cream->m      = BITS(inst, 0, 3)<<1|BIT(inst, 5);
+    inst_cream->m = BITS(inst, 0, 3) << 1 | BIT(inst, 5);
    return inst_base;
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VMOVBRRSS_INST:
+VMOVBRRSS_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
        vmovbrrss_inst* const inst_cream = (vmovbrrss_inst*)inst_base->component;
        VMOVBRRSS(cpu, inst_cream->to_arm, inst_cream->t, inst_cream->t2, inst_cream->m,
-            &cpu->Reg[inst_cream->t], &cpu->Reg[inst_cream->t2]);
+                  &cpu->Reg[inst_cream->t], &cpu->Reg[inst_cream->t2]);
    }
    cpu->Reg[15] += cpu->GetInstructionSize();
    INC_PC(sizeof(vmovbrrss_inst));
@@ -1294,33 +1235,31 @@ struct vmovbrrd_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vmovbrrd)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vmovbrrd)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vmovbrrd_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmovbrrd_inst));
+    vmovbrrd_inst* inst_cream = (vmovbrrd_inst*)inst_base->component;
-    vmovbrrd_inst *inst_cream = (vmovbrrd_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->to_arm = BIT(inst, 20) == 1;
-    inst_cream->t      = BITS(inst, 12, 15);
+    inst_cream->t = BITS(inst, 12, 15);
-    inst_cream->t2     = BITS(inst, 16, 19);
+    inst_cream->t2 = BITS(inst, 16, 19);
-    inst_cream->m      = BIT(inst, 5)<<4 | BITS(inst, 0, 3);
+    inst_cream->m = BIT(inst, 5) << 4 | BITS(inst, 0, 3);
    return inst_base;
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VMOVBRRD_INST:
+VMOVBRRD_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vmovbrrd_inst *inst_cream = (vmovbrrd_inst *)inst_base->component;
+        vmovbrrd_inst* inst_cream = (vmovbrrd_inst*)inst_base->component;
        VMOVBRRD(cpu, inst_cream->to_arm, inst_cream->t, inst_cream->t2, inst_cream->m,
-            &(cpu->Reg[inst_cream->t]), &(cpu->Reg[inst_cream->t2]));
+                 &(cpu->Reg[inst_cream->t]), &(cpu->Reg[inst_cream->t2]));
    }
    cpu->Reg[15] += cpu->GetInstructionSize();
    INC_PC(sizeof(vmovbrrd_inst));
@@ -1347,43 +1286,40 @@ struct vstr_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vstr)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vstr)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vstr_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vstr_inst));
+    vstr_inst* inst_cream = (vstr_inst*)inst_base->component;
-    vstr_inst *inst_cream = (vstr_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->single = BIT(inst, 8) == 0;
-    inst_cream->add    = BIT(inst, 23);
+    inst_cream->add = BIT(inst, 23);
-    inst_cream->imm32  = BITS(inst, 0,7) << 2;
+    inst_cream->imm32 = BITS(inst, 0, 7) << 2;
-    inst_cream->d      = (inst_cream->single ? BITS(inst, 12, 15)<<1|BIT(inst, 22) : BITS(inst, 12, 15)|BIT(inst, 22)<<4);
+    inst_cream->d = (inst_cream->single ? BITS(inst, 12, 15) << 1 | BIT(inst, 22)
-    inst_cream->n      = BITS(inst, 16, 19);
+                                        : BITS(inst, 12, 15) | BIT(inst, 22) << 4);
+    inst_cream->n = BITS(inst, 16, 19);
    return inst_base;
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VSTR_INST:
+VSTR_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vstr_inst *inst_cream = (vstr_inst *)inst_base->component;
+        vstr_inst* inst_cream = (vstr_inst*)inst_base->component;
-        unsigned int base = (inst_cream->n == 15 ? (cpu->Reg[inst_cream->n] & 0xFFFFFFFC) + 8 : cpu->Reg[inst_cream->n]);
+        unsigned int base = (inst_cream->n == 15 ? (cpu->Reg[inst_cream->n] & 0xFFFFFFFC) + 8
+                                                 : cpu->Reg[inst_cream->n]);
        addr = (inst_cream->add ? base + inst_cream->imm32 : base - inst_cream->imm32);
-        if (inst_cream->single)
+        if (inst_cream->single) {
-        {
            cpu->WriteMemory32(addr, cpu->ExtReg[inst_cream->d]);
-        }
+        } else {
-        else
+            const u32 word1 = cpu->ExtReg[inst_cream->d * 2 + 0];
-        {
+            const u32 word2 = cpu->ExtReg[inst_cream->d * 2 + 1];
-            const u32 word1 = cpu->ExtReg[inst_cream->d*2+0];
-            const u32 word2 = cpu->ExtReg[inst_cream->d*2+1];
            if (cpu->InBigEndianMode()) {
                cpu->WriteMemory32(addr + 0, word2);
@@ -1413,44 +1349,39 @@ struct vpush_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vpush)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vpush)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vpush_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vpush_inst));
+    vpush_inst* inst_cream = (vpush_inst*)inst_base->component;
-    vpush_inst *inst_cream = (vpush_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->single  = BIT(inst, 8) == 0;
+    inst_cream->single = BIT(inst, 8) == 0;
-    inst_cream->d       = (inst_cream->single ? BITS(inst, 12, 15)<<1|BIT(inst, 22) : BITS(inst, 12, 15)|BIT(inst, 22)<<4);
+    inst_cream->d = (inst_cream->single ? BITS(inst, 12, 15) << 1 | BIT(inst, 22)
-    inst_cream->imm32   = BITS(inst, 0, 7)<<2;
+                                        : BITS(inst, 12, 15) | BIT(inst, 22) << 4);
-    inst_cream->regs    = (inst_cream->single ? BITS(inst, 0, 7) : BITS(inst, 1, 7));
+    inst_cream->imm32 = BITS(inst, 0, 7) << 2;
+    inst_cream->regs = (inst_cream->single ? BITS(inst, 0, 7) : BITS(inst, 1, 7));
    return inst_base;
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VPUSH_INST:
+VPUSH_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vpush_inst *inst_cream = (vpush_inst *)inst_base->component;
+        vpush_inst* inst_cream = (vpush_inst*)inst_base->component;
        addr = cpu->Reg[R13] - inst_cream->imm32;
-        for (unsigned int i = 0; i < inst_cream->regs; i++)
+        for (unsigned int i = 0; i < inst_cream->regs; i++) {
-        {
+            if (inst_cream->single) {
-            if (inst_cream->single)
+                cpu->WriteMemory32(addr, cpu->ExtReg[inst_cream->d + i]);
-            {
-                cpu->WriteMemory32(addr, cpu->ExtReg[inst_cream->d+i]);
                addr += 4;
-            }
+            } else {
-            else
+                const u32 word1 = cpu->ExtReg[(inst_cream->d + i) * 2 + 0];
-            {
+                const u32 word2 = cpu->ExtReg[(inst_cream->d + i) * 2 + 1];
-                const u32 word1 = cpu->ExtReg[(inst_cream->d+i)*2+0];
-                const u32 word2 = cpu->ExtReg[(inst_cream->d+i)*2+1];
                if (cpu->InBigEndianMode()) {
                    cpu->WriteMemory32(addr + 0, word2);
@@ -1488,28 +1419,28 @@ struct vstm_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vstm)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vstm)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vstm_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vstm_inst));
+    vstm_inst* inst_cream = (vstm_inst*)inst_base->component;
-    vstm_inst *inst_cream = (vstm_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->single = BIT(inst, 8) == 0;
-    inst_cream->add    = BIT(inst, 23);
+    inst_cream->add = BIT(inst, 23);
-    inst_cream->wback  = BIT(inst, 21);
+    inst_cream->wback = BIT(inst, 21);
-    inst_cream->d      = (inst_cream->single ? BITS(inst, 12, 15)<<1|BIT(inst, 22) : BITS(inst, 12, 15)|BIT(inst, 22)<<4);
+    inst_cream->d = (inst_cream->single ? BITS(inst, 12, 15) << 1 | BIT(inst, 22)
-    inst_cream->n      = BITS(inst, 16, 19);
+                                        : BITS(inst, 12, 15) | BIT(inst, 22) << 4);
-    inst_cream->imm32  = BITS(inst, 0, 7)<<2;
+    inst_cream->n = BITS(inst, 16, 19);
-    inst_cream->regs   = (inst_cream->single ? BITS(inst, 0, 7) : BITS(inst, 1, 7));
+    inst_cream->imm32 = BITS(inst, 0, 7) << 2;
+    inst_cream->regs = (inst_cream->single ? BITS(inst, 0, 7) : BITS(inst, 1, 7));
    return inst_base;
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VSTM_INST: /* encoding 1 */
+VSTM_INST : /* encoding 1 */
 {
    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
@@ -1525,17 +1456,13 @@ VSTM_INST: /* encoding 1 */
        if (inst_cream->add == 0)
            address -= inst_cream->imm32;
-        for (unsigned int i = 0; i < inst_cream->regs; i++)
+        for (unsigned int i = 0; i < inst_cream->regs; i++) {
-        {
+            if (inst_cream->single) {
-            if (inst_cream->single)
+                cpu->WriteMemory32(address, cpu->ExtReg[inst_cream->d + i]);
-            {
-                cpu->WriteMemory32(address, cpu->ExtReg[inst_cream->d+i]);
                address += 4;
-            }
+            } else {
-            else
+                const u32 word1 = cpu->ExtReg[(inst_cream->d + i) * 2 + 0];
-            {
+                const u32 word2 = cpu->ExtReg[(inst_cream->d + i) * 2 + 1];
-                const u32 word1 = cpu->ExtReg[(inst_cream->d+i)*2+0];
-                const u32 word2 = cpu->ExtReg[(inst_cream->d+i)*2+1];
                if (cpu->InBigEndianMode()) {
                    cpu->WriteMemory32(address + 0, word2);
@@ -1549,8 +1476,9 @@ VSTM_INST: /* encoding 1 */
            }
        }
        if (inst_cream->wback) {
-            cpu->Reg[inst_cream->n] = (inst_cream->add ? cpu->Reg[inst_cream->n] + inst_cream->imm32 :
+            cpu->Reg[inst_cream->n] =
-                cpu->Reg[inst_cream->n] - inst_cream->imm32);
+                (inst_cream->add ? cpu->Reg[inst_cream->n] + inst_cream->imm32
+                                 : cpu->Reg[inst_cream->n] - inst_cream->imm32);
        }
    }
    cpu->Reg[15] += 4;
@@ -1573,51 +1501,46 @@ struct vpop_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vpop)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vpop)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vpop_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vpop_inst));
+    vpop_inst* inst_cream = (vpop_inst*)inst_base->component;
-    vpop_inst *inst_cream = (vpop_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
-    inst_cream->single  = BIT(inst, 8) == 0;
+    inst_cream->single = BIT(inst, 8) == 0;
-    inst_cream->d       = (inst_cream->single ? (BITS(inst, 12, 15)<<1)|BIT(inst, 22) : BITS(inst, 12, 15)|(BIT(inst, 22)<<4));
+    inst_cream->d = (inst_cream->single ? (BITS(inst, 12, 15) << 1) | BIT(inst, 22)
-    inst_cream->imm32   = BITS(inst, 0, 7)<<2;
+                                        : BITS(inst, 12, 15) | (BIT(inst, 22) << 4));
-    inst_cream->regs    = (inst_cream->single ? BITS(inst, 0, 7) : BITS(inst, 1, 7));
+    inst_cream->imm32 = BITS(inst, 0, 7) << 2;
+    inst_cream->regs = (inst_cream->single ? BITS(inst, 0, 7) : BITS(inst, 1, 7));
    return inst_base;
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VPOP_INST:
+VPOP_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vpop_inst *inst_cream = (vpop_inst *)inst_base->component;
+        vpop_inst* inst_cream = (vpop_inst*)inst_base->component;
        addr = cpu->Reg[R13];
-        for (unsigned int i = 0; i < inst_cream->regs; i++)
+        for (unsigned int i = 0; i < inst_cream->regs; i++) {
-        {
+            if (inst_cream->single) {
-            if (inst_cream->single)
+                cpu->ExtReg[inst_cream->d + i] = cpu->ReadMemory32(addr);
-            {
-                cpu->ExtReg[inst_cream->d+i] = cpu->ReadMemory32(addr);
                addr += 4;
-            }
+            } else {
-            else
-            {
                const u32 word1 = cpu->ReadMemory32(addr + 0);
                const u32 word2 = cpu->ReadMemory32(addr + 4);
                if (cpu->InBigEndianMode()) {
-                    cpu->ExtReg[(inst_cream->d+i)*2+0] = word2;
+                    cpu->ExtReg[(inst_cream->d + i) * 2 + 0] = word2;
-                    cpu->ExtReg[(inst_cream->d+i)*2+1] = word1;
+                    cpu->ExtReg[(inst_cream->d + i) * 2 + 1] = word1;
                } else {
-                    cpu->ExtReg[(inst_cream->d+i)*2+0] = word1;
+                    cpu->ExtReg[(inst_cream->d + i) * 2 + 0] = word1;
-                    cpu->ExtReg[(inst_cream->d+i)*2+1] = word2;
+                    cpu->ExtReg[(inst_cream->d + i) * 2 + 1] = word2;
                }
                addr += 8;
@@ -1632,7 +1555,6 @@ VPOP_INST:
 }
 #endif
 /* ----------------------------------------------------------------------- */
 /* VLDR */
 /* cond 1101 UD01 Rn-- Vd-- 101X imm8 imm8 */
@@ -1646,50 +1568,47 @@ struct vldr_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vldr)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vldr)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vldr_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vldr_inst));
+    vldr_inst* inst_cream = (vldr_inst*)inst_base->component;
-    vldr_inst *inst_cream = (vldr_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->single = BIT(inst, 8) == 0;
-    inst_cream->add    = BIT(inst, 23);
+    inst_cream->add = BIT(inst, 23);
-    inst_cream->imm32  = BITS(inst, 0,7) << 2;
+    inst_cream->imm32 = BITS(inst, 0, 7) << 2;
-    inst_cream->d      = (inst_cream->single ? BITS(inst, 12, 15)<<1|BIT(inst, 22) : BITS(inst, 12, 15)|BIT(inst, 22)<<4);
+    inst_cream->d = (inst_cream->single ? BITS(inst, 12, 15) << 1 | BIT(inst, 22)
-    inst_cream->n      = BITS(inst, 16, 19);
+                                        : BITS(inst, 12, 15) | BIT(inst, 22) << 4);
+    inst_cream->n = BITS(inst, 16, 19);
    return inst_base;
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VLDR_INST:
+VLDR_INST : {
-{
    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
-        vldr_inst *inst_cream = (vldr_inst *)inst_base->component;
+        vldr_inst* inst_cream = (vldr_inst*)inst_base->component;
-        unsigned int base = (inst_cream->n == 15 ? (cpu->Reg[inst_cream->n] & 0xFFFFFFFC) + 8 : cpu->Reg[inst_cream->n]);
+        unsigned int base = (inst_cream->n == 15 ? (cpu->Reg[inst_cream->n] & 0xFFFFFFFC) + 8
+                                                 : cpu->Reg[inst_cream->n]);
        addr = (inst_cream->add ? base + inst_cream->imm32 : base - inst_cream->imm32);
-        if (inst_cream->single)
+        if (inst_cream->single) {
-        {
            cpu->ExtReg[inst_cream->d] = cpu->ReadMemory32(addr);
-        }
+        } else {
-        else
-        {
            const u32 word1 = cpu->ReadMemory32(addr + 0);
            const u32 word2 = cpu->ReadMemory32(addr + 4);
            if (cpu->InBigEndianMode()) {
-                cpu->ExtReg[inst_cream->d*2+0] = word2;
+                cpu->ExtReg[inst_cream->d * 2 + 0] = word2;
-                cpu->ExtReg[inst_cream->d*2+1] = word1;
+                cpu->ExtReg[inst_cream->d * 2 + 1] = word1;
            } else {
-                cpu->ExtReg[inst_cream->d*2+0] = word1;
+                cpu->ExtReg[inst_cream->d * 2 + 0] = word1;
-                cpu->ExtReg[inst_cream->d*2+1] = word2;
+                cpu->ExtReg[inst_cream->d * 2 + 1] = word2;
            }
        }
    }
@@ -1715,29 +1634,28 @@ struct vldm_inst {
 };
 #endif
 #ifdef VFP_INTERPRETER_TRANS
-static ARM_INST_PTR INTERPRETER_TRANSLATE(vldm)(unsigned int inst, int index)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(vldm)(unsigned int inst, int index) {
-{
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vldm_inst));
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vldm_inst));
+    vldm_inst* inst_cream = (vldm_inst*)inst_base->component;
-    vldm_inst *inst_cream = (vldm_inst *)inst_base->component;
    inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
+    inst_base->idx = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->br = TransExtData::NON_BRANCH;
    inst_cream->single = BIT(inst, 8) == 0;
-    inst_cream->add    = BIT(inst, 23);
+    inst_cream->add = BIT(inst, 23);
-    inst_cream->wback  = BIT(inst, 21);
+    inst_cream->wback = BIT(inst, 21);
-    inst_cream->d      = (inst_cream->single ? BITS(inst, 12, 15)<<1|BIT(inst, 22) : BITS(inst, 12, 15)|BIT(inst, 22)<<4);
+    inst_cream->d = (inst_cream->single ? BITS(inst, 12, 15) << 1 | BIT(inst, 22)
-    inst_cream->n      = BITS(inst, 16, 19);
+                                        : BITS(inst, 12, 15) | BIT(inst, 22) << 4);
-    inst_cream->imm32  = BITS(inst, 0, 7)<<2;
+    inst_cream->n = BITS(inst, 16, 19);
-    inst_cream->regs   = (inst_cream->single ? BITS(inst, 0, 7) : BITS(inst, 1, 7));
+    inst_cream->imm32 = BITS(inst, 0, 7) << 2;
+    inst_cream->regs = (inst_cream->single ? BITS(inst, 0, 7) : BITS(inst, 1, 7));
    return inst_base;
 }
 #endif
 #ifdef VFP_INTERPRETER_IMPL
-VLDM_INST:
+VLDM_INST : {
-{
    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
        CHECK_VFP_ENABLED;
@@ -1752,32 +1670,29 @@ VLDM_INST:
        if (inst_cream->add == 0)
            address -= inst_cream->imm32;
-        for (unsigned int i = 0; i < inst_cream->regs; i++)
+        for (unsigned int i = 0; i < inst_cream->regs; i++) {
-        {
+            if (inst_cream->single) {
-            if (inst_cream->single)
+                cpu->ExtReg[inst_cream->d + i] = cpu->ReadMemory32(address);
-            {
-                cpu->ExtReg[inst_cream->d+i] = cpu->ReadMemory32(address);
                address += 4;
-            }
+            } else {
-            else
-            {
                const u32 word1 = cpu->ReadMemory32(address + 0);
                const u32 word2 = cpu->ReadMemory32(address + 4);
                if (cpu->InBigEndianMode()) {
-                    cpu->ExtReg[(inst_cream->d+i)*2+0] = word2;
+                    cpu->ExtReg[(inst_cream->d + i) * 2 + 0] = word2;
-                    cpu->ExtReg[(inst_cream->d+i)*2+1] = word1;
+                    cpu->ExtReg[(inst_cream->d + i) * 2 + 1] = word1;
                } else {
-                    cpu->ExtReg[(inst_cream->d+i)*2+0] = word1;
+                    cpu->ExtReg[(inst_cream->d + i) * 2 + 0] = word1;
-                    cpu->ExtReg[(inst_cream->d+i)*2+1] = word2;
+                    cpu->ExtReg[(inst_cream->d + i) * 2 + 1] = word2;
                }
                address += 8;
            }
        }
        if (inst_cream->wback) {
-            cpu->Reg[inst_cream->n] = (inst_cream->add ? cpu->Reg[inst_cream->n] + inst_cream->imm32 :
+            cpu->Reg[inst_cream->n] =
-                cpu->Reg[inst_cream->n] - inst_cream->imm32);
+                (inst_cream->add ? cpu->Reg[inst_cream->n] + inst_cream->imm32
+                                 : cpu->Reg[inst_cream->n] - inst_cream->imm32);
        }
    }
    cpu->Reg[15] += cpu->GetInstructionSize();
diff --git a/src/core/arm/skyeye_common/vfp/vfpsingle.cpp b/src/core/arm/skyeye_common/vfp/vfpsingle.cpp
index 60264f9b3..3c21efe62 100644
--- a/src/core/arm/skyeye_common/vfp/vfpsingle.cpp
+++ b/src/core/arm/skyeye_common/vfp/vfpsingle.cpp
@@ -58,24 +58,20 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "core/arm/skyeye_common/vfp/vfp_helper.h"
 #include "core/arm/skyeye_common/vfp/asm_vfp.h"
 #include "core/arm/skyeye_common/vfp/vfp.h"
+#include "core/arm/skyeye_common/vfp/vfp_helper.h"
 static struct vfp_single vfp_single_default_qnan = {
-    255,
+    255, 0, VFP_SINGLE_SIGNIFICAND_QNAN,
-    0,
-    VFP_SINGLE_SIGNIFICAND_QNAN,
 };
-static void vfp_single_dump(const char *str, struct vfp_single *s)
+static void vfp_single_dump(const char* str, struct vfp_single* s) {
-{
+    LOG_TRACE(Core_ARM11, "%s: sign=%d exponent=%d significand=%08x", str, s->sign != 0,
-    LOG_TRACE(Core_ARM11, "%s: sign=%d exponent=%d significand=%08x",
+              s->exponent, s->significand);
-              str, s->sign != 0, s->exponent, s->significand);
 }
-static void vfp_single_normalise_denormal(struct vfp_single *vs)
+static void vfp_single_normalise_denormal(struct vfp_single* vs) {
-{
    int bits = 31 - fls(vs->significand);
    vfp_single_dump("normalise_denormal: in", vs);
@@ -88,9 +84,8 @@ static void vfp_single_normalise_denormal(struct vfp_single *vs)
    vfp_single_dump("normalise_denormal: out", vs);
 }
+u32 vfp_single_normaliseround(ARMul_State* state, int sd, struct vfp_single* vs, u32 fpscr,
-u32 vfp_single_normaliseround(ARMul_State* state, int sd, struct vfp_single *vs, u32 fpscr, const char *func)
+                              const char* func) {
-{
    u32 significand, incr, rmode;
    int exponent, shift, underflow;
    u32 exceptions = 0;
@@ -199,7 +194,7 @@ u32 vfp_single_normaliseround(ARMul_State* state, int sd, struct vfp_single *vs,
            vs->exponent = 253;
            vs->significand = 0x7fffffff;
        } else {
-            vs->exponent = 255;         /* infinity */
+            vs->exponent = 255; /* infinity */
            vs->significand = 0;
        }
    } else {
@@ -217,8 +212,7 @@ pack:
    vfp_single_dump("pack: final", vs);
    {
        s32 d = vfp_single_pack(vs);
-        LOG_TRACE(Core_ARM11, "%s: d(s%d)=%08x exceptions=%08x", func,
+        LOG_TRACE(Core_ARM11, "%s: d(s%d)=%08x exceptions=%08x", func, sd, d, exceptions);
-                  sd, d, exceptions);
        vfp_put_float(state, d, sd);
    }
@@ -229,11 +223,9 @@ pack:
 * Propagate the NaN, setting exceptions if it is signalling.
 * 'n' is always a NaN.  'm' may be a number, NaN or infinity.
 */
-static u32
+static u32 vfp_propagate_nan(struct vfp_single* vsd, struct vfp_single* vsn, struct vfp_single* vsm,
-vfp_propagate_nan(struct vfp_single *vsd, struct vfp_single *vsn,
+                             u32 fpscr) {
-                  struct vfp_single *vsm, u32 fpscr)
+    struct vfp_single* nan;
-{
-    struct vfp_single *nan;
    int tn, tm = 0;
    tn = vfp_single_type(vsn);
@@ -270,40 +262,33 @@ vfp_propagate_nan(struct vfp_single *vsd, struct vfp_single *vsn,
    return tn == VFP_SNAN || tm == VFP_SNAN ? FPSCR_IOC : VFP_NAN_FLAG;
 }
 /*
 * Extended operations
 */
-static u32 vfp_single_fabs(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr)
+static u32 vfp_single_fabs(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr) {
-{
    vfp_put_float(state, vfp_single_packed_abs(m), sd);
    return 0;
 }
-static u32 vfp_single_fcpy(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr)
+static u32 vfp_single_fcpy(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr) {
-{
    vfp_put_float(state, m, sd);
    return 0;
 }
-static u32 vfp_single_fneg(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr)
+static u32 vfp_single_fneg(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr) {
-{
    vfp_put_float(state, vfp_single_packed_negate(m), sd);
    return 0;
 }
-static const u16 sqrt_oddadjust[] = {
+static const u16 sqrt_oddadjust[] = {0x0004, 0x0022, 0x005d, 0x00b1, 0x011d, 0x019f,
-    0x0004, 0x0022, 0x005d, 0x00b1, 0x011d, 0x019f, 0x0236, 0x02e0,
+                                     0x0236, 0x02e0, 0x039c, 0x0468, 0x0545, 0x0631,
-    0x039c, 0x0468, 0x0545, 0x0631, 0x072b, 0x0832, 0x0946, 0x0a67
+                                     0x072b, 0x0832, 0x0946, 0x0a67};
-};
-static const u16 sqrt_evenadjust[] = {
+static const u16 sqrt_evenadjust[] = {0x0a2d, 0x08af, 0x075a, 0x0629, 0x051a, 0x0429,
-    0x0a2d, 0x08af, 0x075a, 0x0629, 0x051a, 0x0429, 0x0356, 0x029e,
+                                      0x0356, 0x029e, 0x0200, 0x0179, 0x0109, 0x00af,
-    0x0200, 0x0179, 0x0109, 0x00af, 0x0068, 0x0034, 0x0012, 0x0002
+                                      0x0068, 0x0034, 0x0012, 0x0002};
-};
-u32 vfp_estimate_sqrt_significand(u32 exponent, u32 significand)
+u32 vfp_estimate_sqrt_significand(u32 exponent, u32 significand) {
-{
    int index;
    u32 z, a;
@@ -331,25 +316,24 @@ u32 vfp_estimate_sqrt_significand(u32 exponent, u32 significand)
    }
 }
-static u32 vfp_single_fsqrt(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr)
+static u32 vfp_single_fsqrt(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr) {
-{
    struct vfp_single vsm, vsd, *vsp;
    int ret, tm;
    u32 exceptions = 0;
    exceptions |= vfp_single_unpack(&vsm, m, fpscr);
    tm = vfp_single_type(&vsm);
-    if (tm & (VFP_NAN|VFP_INFINITY)) {
+    if (tm & (VFP_NAN | VFP_INFINITY)) {
        vsp = &vsd;
        if (tm & VFP_NAN)
            ret = vfp_propagate_nan(vsp, &vsm, nullptr, fpscr);
        else if (vsm.sign == 0) {
-sqrt_copy:
+        sqrt_copy:
            vsp = &vsm;
            ret = 0;
        } else {
-sqrt_invalid:
+        sqrt_invalid:
            vsp = &vfp_single_default_qnan;
            ret = FPSCR_IOC;
        }
@@ -420,15 +404,15 @@ sqrt_invalid:
 * Greater than := C
 * Unordered    := CV
 */
-static u32 vfp_compare(ARMul_State* state, int sd, int signal_on_qnan, s32 m, u32 fpscr)
+static u32 vfp_compare(ARMul_State* state, int sd, int signal_on_qnan, s32 m, u32 fpscr) {
-{
    s32 d;
    u32 ret = 0;
    d = vfp_get_float(state, sd);
    if (vfp_single_packed_exponent(m) == 255 && vfp_single_packed_mantissa(m)) {
        ret |= FPSCR_CFLAG | FPSCR_VFLAG;
-        if (signal_on_qnan || !(vfp_single_packed_mantissa(m) & (1 << (VFP_SINGLE_MANTISSA_BITS - 1))))
+        if (signal_on_qnan ||
+            !(vfp_single_packed_mantissa(m) & (1 << (VFP_SINGLE_MANTISSA_BITS - 1))))
            /*
             * Signalling NaN, or signalling on quiet NaN
             */
@@ -437,7 +421,8 @@ static u32 vfp_compare(ARMul_State* state, int sd, int signal_on_qnan, s32 m, u3
    if (vfp_single_packed_exponent(d) == 255 && vfp_single_packed_mantissa(d)) {
        ret |= FPSCR_CFLAG | FPSCR_VFLAG;
-        if (signal_on_qnan || !(vfp_single_packed_mantissa(d) & (1 << (VFP_SINGLE_MANTISSA_BITS - 1))))
+        if (signal_on_qnan ||
+            !(vfp_single_packed_mantissa(d) & (1 << (VFP_SINGLE_MANTISSA_BITS - 1))))
            /*
             * Signalling NaN, or signalling on quiet NaN
             */
@@ -479,28 +464,23 @@ static u32 vfp_compare(ARMul_State* state, int sd, int signal_on_qnan, s32 m, u3
    return ret;
 }
-static u32 vfp_single_fcmp(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr)
+static u32 vfp_single_fcmp(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr) {
-{
    return vfp_compare(state, sd, 0, m, fpscr);
 }
-static u32 vfp_single_fcmpe(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr)
+static u32 vfp_single_fcmpe(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr) {
-{
    return vfp_compare(state, sd, 1, m, fpscr);
 }
-static u32 vfp_single_fcmpz(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr)
+static u32 vfp_single_fcmpz(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr) {
-{
    return vfp_compare(state, sd, 0, 0, fpscr);
 }
-static u32 vfp_single_fcmpez(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr)
+static u32 vfp_single_fcmpez(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr) {
-{
    return vfp_compare(state, sd, 1, 0, fpscr);
 }
-static u32 vfp_single_fcvtd(ARMul_State* state, int dd, int unused, s32 m, u32 fpscr)
+static u32 vfp_single_fcvtd(ARMul_State* state, int dd, int unused, s32 m, u32 fpscr) {
-{
    struct vfp_single vsm;
    struct vfp_double vdd;
    int tm;
@@ -525,7 +505,7 @@ static u32 vfp_single_fcvtd(ARMul_State* state, int dd, int unused, s32 m, u32 f
    /*
     * If we have an infinity or NaN, the exponent must be 2047.
     */
-    if (tm & (VFP_INFINITY|VFP_NAN)) {
+    if (tm & (VFP_INFINITY | VFP_NAN)) {
        vdd.exponent = 2047;
        if (tm == VFP_QNAN)
            vdd.significand |= VFP_DOUBLE_SIGNIFICAND_QNAN;
@@ -543,8 +523,7 @@ pack_nan:
    return exceptions;
 }
-static u32 vfp_single_fuito(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr)
+static u32 vfp_single_fuito(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr) {
-{
    struct vfp_single vs;
    u32 exceptions = 0;
@@ -556,8 +535,7 @@ static u32 vfp_single_fuito(ARMul_State* state, int sd, int unused, s32 m, u32 f
    return exceptions;
 }
-static u32 vfp_single_fsito(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr)
+static u32 vfp_single_fsito(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr) {
-{
    struct vfp_single vs;
    u32 exceptions = 0;
@@ -569,8 +547,7 @@ static u32 vfp_single_fsito(ARMul_State* state, int sd, int unused, s32 m, u32 f
    return exceptions;
 }
-static u32 vfp_single_ftoui(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr)
+static u32 vfp_single_ftoui(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr) {
-{
    struct vfp_single vsm;
    u32 d, exceptions = 0;
    int rmode = fpscr & FPSCR_RMODE_MASK;
@@ -656,13 +633,11 @@ static u32 vfp_single_ftoui(ARMul_State* state, int sd, int unused, s32 m, u32 f
    return exceptions;
 }
-static u32 vfp_single_ftouiz(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr)
+static u32 vfp_single_ftouiz(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr) {
-{
    return vfp_single_ftoui(state, sd, unused, m, (fpscr & ~FPSCR_RMODE_MASK) | FPSCR_ROUND_TOZERO);
 }
-static u32 vfp_single_ftosi(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr)
+static u32 vfp_single_ftosi(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr) {
-{
    struct vfp_single vsm;
    u32 d, exceptions = 0;
    int rmode = fpscr & FPSCR_RMODE_MASK;
@@ -739,51 +714,44 @@ static u32 vfp_single_ftosi(ARMul_State* state, int sd, int unused, s32 m, u32 f
    return exceptions;
 }
-static u32 vfp_single_ftosiz(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr)
+static u32 vfp_single_ftosiz(ARMul_State* state, int sd, int unused, s32 m, u32 fpscr) {
-{
    return vfp_single_ftosi(state, sd, unused, m, (fpscr & ~FPSCR_RMODE_MASK) | FPSCR_ROUND_TOZERO);
 }
 static struct op fops_ext[] = {
-    { vfp_single_fcpy,   0 },                 //0x00000000 - FEXT_FCPY
+    {vfp_single_fcpy, 0},  // 0x00000000 - FEXT_FCPY
-    { vfp_single_fabs,   0 },                 //0x00000001 - FEXT_FABS
+    {vfp_single_fabs, 0},  // 0x00000001 - FEXT_FABS
-    { vfp_single_fneg,   0 },                 //0x00000002 - FEXT_FNEG
+    {vfp_single_fneg, 0},  // 0x00000002 - FEXT_FNEG
-    { vfp_single_fsqrt,  0 },                 //0x00000003 - FEXT_FSQRT
+    {vfp_single_fsqrt, 0}, // 0x00000003 - FEXT_FSQRT
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { vfp_single_fcmp,   OP_SCALAR },         //0x00000008 - FEXT_FCMP
+    {vfp_single_fcmp, OP_SCALAR},   // 0x00000008 - FEXT_FCMP
-    { vfp_single_fcmpe,  OP_SCALAR },         //0x00000009 - FEXT_FCMPE
+    {vfp_single_fcmpe, OP_SCALAR},  // 0x00000009 - FEXT_FCMPE
-    { vfp_single_fcmpz,  OP_SCALAR },         //0x0000000A - FEXT_FCMPZ
+    {vfp_single_fcmpz, OP_SCALAR},  // 0x0000000A - FEXT_FCMPZ
-    { vfp_single_fcmpez, OP_SCALAR },         //0x0000000B - FEXT_FCMPEZ
+    {vfp_single_fcmpez, OP_SCALAR}, // 0x0000000B - FEXT_FCMPEZ
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { vfp_single_fcvtd,  OP_SCALAR|OP_DD },   //0x0000000F - FEXT_FCVT
+    {vfp_single_fcvtd, OP_SCALAR | OP_DD}, // 0x0000000F - FEXT_FCVT
-    { vfp_single_fuito,  OP_SCALAR },         //0x00000010 - FEXT_FUITO
+    {vfp_single_fuito, OP_SCALAR},         // 0x00000010 - FEXT_FUITO
-    { vfp_single_fsito,  OP_SCALAR },         //0x00000011 - FEXT_FSITO
+    {vfp_single_fsito, OP_SCALAR},         // 0x00000011 - FEXT_FSITO
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { nullptr, 0 },
+    {nullptr, 0},
-    { vfp_single_ftoui,  OP_SCALAR },         //0x00000018 - FEXT_FTOUI
+    {vfp_single_ftoui, OP_SCALAR},  // 0x00000018 - FEXT_FTOUI
-    { vfp_single_ftouiz, OP_SCALAR },         //0x00000019 - FEXT_FTOUIZ
+    {vfp_single_ftouiz, OP_SCALAR}, // 0x00000019 - FEXT_FTOUIZ
-    { vfp_single_ftosi,  OP_SCALAR },         //0x0000001A - FEXT_FTOSI
+    {vfp_single_ftosi, OP_SCALAR},  // 0x0000001A - FEXT_FTOSI
-    { vfp_single_ftosiz, OP_SCALAR },         //0x0000001B - FEXT_FTOSIZ
+    {vfp_single_ftosiz, OP_SCALAR}, // 0x0000001B - FEXT_FTOSIZ
 };
+static u32 vfp_single_fadd_nonnumber(struct vfp_single* vsd, struct vfp_single* vsn,
+                                     struct vfp_single* vsm, u32 fpscr) {
+    struct vfp_single* vsp;
-static u32
-vfp_single_fadd_nonnumber(struct vfp_single *vsd, struct vfp_single *vsn,
-                          struct vfp_single *vsm, u32 fpscr)
-{
-    struct vfp_single *vsp;
    u32 exceptions = 0;
    int tn, tm;
@@ -821,14 +789,11 @@ vfp_single_fadd_nonnumber(struct vfp_single *vsd, struct vfp_single *vsn,
    return exceptions;
 }
-static u32
+static u32 vfp_single_add(struct vfp_single* vsd, struct vfp_single* vsn, struct vfp_single* vsm,
-vfp_single_add(struct vfp_single *vsd, struct vfp_single *vsn,
+                          u32 fpscr) {
-               struct vfp_single *vsm, u32 fpscr)
-{
    u32 exp_diff, m_sig;
-    if (vsn->significand & 0x80000000 ||
+    if (vsn->significand & 0x80000000 || vsm->significand & 0x80000000) {
-            vsm->significand & 0x80000000) {
        LOG_WARNING(Core_ARM11, "bad FP values");
        vfp_single_dump("VSN", vsn);
        vfp_single_dump("VSM", vsm);
@@ -872,8 +837,7 @@ vfp_single_add(struct vfp_single *vsd, struct vfp_single *vsn,
            vsd->sign = vfp_sign_negate(vsd->sign);
            m_sig = (~m_sig + 1);
        } else if (m_sig == 0) {
-            vsd->sign = (fpscr & FPSCR_RMODE_MASK) ==
+            vsd->sign = (fpscr & FPSCR_RMODE_MASK) == FPSCR_ROUND_MINUSINF ? 0x8000 : 0;
-                        FPSCR_ROUND_MINUSINF ? 0x8000 : 0;
        }
    } else {
        m_sig = vsn->significand + m_sig;
@@ -883,9 +847,8 @@ vfp_single_add(struct vfp_single *vsd, struct vfp_single *vsn,
    return 0;
 }
-static u32
+static u32 vfp_single_multiply(struct vfp_single* vsd, struct vfp_single* vsn,
-vfp_single_multiply(struct vfp_single *vsd, struct vfp_single *vsn, struct vfp_single *vsm, u32 fpscr)
+                               struct vfp_single* vsm, u32 fpscr) {
-{
    vfp_single_dump("VSN", vsn);
    vfp_single_dump("VSM", vsm);
@@ -938,12 +901,11 @@ vfp_single_multiply(struct vfp_single *vsd, struct vfp_single *vsn, struct vfp_s
    return 0;
 }
-#define NEG_MULTIPLY    (1 << 0)
+#define NEG_MULTIPLY (1 << 0)
-#define NEG_SUBTRACT    (1 << 1)
+#define NEG_SUBTRACT (1 << 1)
-static u32
+static u32 vfp_single_multiply_accumulate(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr,
-vfp_single_multiply_accumulate(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr, u32 negate, const char *func)
+                                          u32 negate, const char* func) {
-{
    vfp_single vsd, vsp, vsn, vsm;
    u32 exceptions = 0;
    s32 v;
@@ -985,8 +947,7 @@ vfp_single_multiply_accumulate(ARMul_State* state, int sd, int sn, s32 m, u32 fp
 /*
 * sd = sd + (sn * sm)
 */
-static u32 vfp_single_fmac(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr)
+static u32 vfp_single_fmac(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr) {
-{
    u32 exceptions = 0;
    LOG_TRACE(Core_ARM11, "s%u = %08x", sn, sd);
    exceptions |= vfp_single_multiply_accumulate(state, sd, sn, m, fpscr, 0, "fmac");
@@ -996,8 +957,7 @@ static u32 vfp_single_fmac(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr)
 /*
 * sd = sd - (sn * sm)
 */
-static u32 vfp_single_fnmac(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr)
+static u32 vfp_single_fnmac(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr) {
-{
    // TODO: this one has its arguments inverted, investigate.
    LOG_TRACE(Core_ARM11, "s%u = %08x", sd, sn);
    return vfp_single_multiply_accumulate(state, sd, sn, m, fpscr, NEG_MULTIPLY, "fnmac");
@@ -1006,8 +966,7 @@ static u32 vfp_single_fnmac(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr
 /*
 * sd = -sd + (sn * sm)
 */
-static u32 vfp_single_fmsc(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr)
+static u32 vfp_single_fmsc(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr) {
-{
    LOG_TRACE(Core_ARM11, "s%u = %08x", sn, sd);
    return vfp_single_multiply_accumulate(state, sd, sn, m, fpscr, NEG_SUBTRACT, "fmsc");
 }
@@ -1015,17 +974,16 @@ static u32 vfp_single_fmsc(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr)
 /*
 * sd = -sd - (sn * sm)
 */
-static u32 vfp_single_fnmsc(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr)
+static u32 vfp_single_fnmsc(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr) {
-{
    LOG_TRACE(Core_ARM11, "s%u = %08x", sn, sd);
-    return vfp_single_multiply_accumulate(state, sd, sn, m, fpscr, NEG_SUBTRACT | NEG_MULTIPLY, "fnmsc");
+    return vfp_single_multiply_accumulate(state, sd, sn, m, fpscr, NEG_SUBTRACT | NEG_MULTIPLY,
+                                          "fnmsc");
 }
 /*
 * sd = sn * sm
 */
-static u32 vfp_single_fmul(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr)
+static u32 vfp_single_fmul(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr) {
-{
    struct vfp_single vsd, vsn, vsm;
    u32 exceptions = 0;
    s32 n = vfp_get_float(state, sn);
@@ -1049,8 +1007,7 @@ static u32 vfp_single_fmul(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr)
 /*
 * sd = -(sn * sm)
 */
-static u32 vfp_single_fnmul(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr)
+static u32 vfp_single_fnmul(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr) {
-{
    struct vfp_single vsd, vsn, vsm;
    u32 exceptions = 0;
    s32 n = vfp_get_float(state, sn);
@@ -1075,8 +1032,7 @@ static u32 vfp_single_fnmul(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr
 /*
 * sd = sn + sm
 */
-static u32 vfp_single_fadd(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr)
+static u32 vfp_single_fadd(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr) {
-{
    struct vfp_single vsd, vsn, vsm;
    u32 exceptions = 0;
    s32 n = vfp_get_float(state, sn);
@@ -1103,8 +1059,7 @@ static u32 vfp_single_fadd(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr)
 /*
 * sd = sn - sm
 */
-static u32 vfp_single_fsub(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr)
+static u32 vfp_single_fsub(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr) {
-{
    LOG_TRACE(Core_ARM11, "s%u = %08x", sn, sd);
    /*
     * Subtraction is addition with one sign inverted.
@@ -1118,8 +1073,7 @@ static u32 vfp_single_fsub(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr)
 /*
 * sd = sn / sm
 */
-static u32 vfp_single_fdiv(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr)
+static u32 vfp_single_fdiv(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr) {
-{
    struct vfp_single vsd, vsn, vsm;
    u32 exceptions = 0;
    s32 n = vfp_get_float(state, sn);
@@ -1151,7 +1105,7 @@ static u32 vfp_single_fdiv(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr)
     * If n and m are infinity, the result is invalid
     * If n and m are zero, the result is invalid
     */
-    if (tm & tn & (VFP_INFINITY|VFP_ZERO))
+    if (tm & tn & (VFP_INFINITY | VFP_ZERO))
        goto invalid;
    /*
@@ -1226,29 +1180,22 @@ invalid:
 }
 static struct op fops[] = {
-        { vfp_single_fmac,  0 },
+    {vfp_single_fmac, 0},  {vfp_single_fmsc, 0},  {vfp_single_fmul, 0},
-        { vfp_single_fmsc,  0 },
+    {vfp_single_fadd, 0},  {vfp_single_fnmac, 0}, {vfp_single_fnmsc, 0},
-        { vfp_single_fmul,  0 },
+    {vfp_single_fnmul, 0}, {vfp_single_fsub, 0},  {vfp_single_fdiv, 0},
-        { vfp_single_fadd,  0 },
-        { vfp_single_fnmac, 0 },
-        { vfp_single_fnmsc, 0 },
-        { vfp_single_fnmul, 0 },
-        { vfp_single_fsub,  0 },
-        { vfp_single_fdiv,  0 },
 };
-#define FREG_BANK(x)    ((x) & 0x18)
+#define FREG_BANK(x) ((x)&0x18)
-#define FREG_IDX(x)     ((x) & 7)
+#define FREG_IDX(x) ((x)&7)
-u32 vfp_single_cpdo(ARMul_State* state, u32 inst, u32 fpscr)
+u32 vfp_single_cpdo(ARMul_State* state, u32 inst, u32 fpscr) {
-{
    u32 op = inst & FOP_MASK;
    u32 exceptions = 0;
    unsigned int dest;
    unsigned int sn = vfp_get_sn(inst);
    unsigned int sm = vfp_get_sm(inst);
    unsigned int vecitr, veclen, vecstride;
-    struct op *fop;
+    struct op* fop;
    vecstride = 1 + ((fpscr & FPSCR_STRIDE_MASK) == FPSCR_STRIDE_MASK);
@@ -1274,11 +1221,11 @@ u32 vfp_single_cpdo(ARMul_State* state, u32 inst, u32 fpscr)
    else
        veclen = fpscr & FPSCR_LENGTH_MASK;
-    LOG_TRACE(Core_ARM11, "vecstride=%u veclen=%u", vecstride,
+    LOG_TRACE(Core_ARM11, "vecstride=%u veclen=%u", vecstride, (veclen >> FPSCR_LENGTH_BIT) + 1);
-              (veclen >> FPSCR_LENGTH_BIT) + 1);
    if (!fop->fn) {
-        LOG_CRITICAL(Core_ARM11, "could not find single op %d, inst=0x%x@0x%x", FEXT_TO_IDX(inst), inst, state->Reg[15]);
+        LOG_CRITICAL(Core_ARM11, "could not find single op %d, inst=0x%x@0x%x", FEXT_TO_IDX(inst),
+                     inst, state->Reg[15]);
        Crash();
        goto invalid;
    }
@@ -1290,17 +1237,14 @@ u32 vfp_single_cpdo(ARMul_State* state, u32 inst, u32 fpscr)
        type = (fop->flags & OP_DD) ? 'd' : 's';
        if (op == FOP_EXT)
-            LOG_TRACE(Core_ARM11, "itr%d (%c%u) = op[%u] (s%u=%08x)",
+            LOG_TRACE(Core_ARM11, "itr%d (%c%u) = op[%u] (s%u=%08x)", vecitr >> FPSCR_LENGTH_BIT,
-                      vecitr >> FPSCR_LENGTH_BIT, type, dest, sn,
+                      type, dest, sn, sm, m);
-                      sm, m);
        else
            LOG_TRACE(Core_ARM11, "itr%d (%c%u) = (s%u) op[%u] (s%u=%08x)",
-                      vecitr >> FPSCR_LENGTH_BIT, type, dest, sn,
+                      vecitr >> FPSCR_LENGTH_BIT, type, dest, sn, FOP_TO_IDX(op), sm, m);
-                      FOP_TO_IDX(op), sm, m);
        except = fop->fn(state, dest, sn, m, fpscr);
-        LOG_TRACE(Core_ARM11, "itr%d: exceptions=%08x",
+        LOG_TRACE(Core_ARM11, "itr%d: exceptions=%08x", vecitr >> FPSCR_LENGTH_BIT, except);
-                  vecitr >> FPSCR_LENGTH_BIT, except);
        exceptions |= except;
diff --git a/src/core/core.cpp b/src/core/core.cpp
index a3834adae..4f9eca416 100644
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -27,7 +27,8 @@ void RunLoop(int tight_loop) {
    if (GDBStub::g_server_enabled) {
        GDBStub::HandlePacket();
-        // If the loop is halted and we want to step, use a tiny (1) number of instructions to execute.
+        // 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()) {
@@ -62,7 +63,7 @@ void SingleStep() {
 }
 /// Halt the core
-void Halt(const char *msg) {
+void Halt(const char* msg) {
    // TODO(ShizZy): ImplementMe
 }
diff --git a/src/core/core.h b/src/core/core.h
index ad26dca3f..ffbfa91c3 100644
--- a/src/core/core.h
+++ b/src/core/core.h
@@ -40,13 +40,13 @@ void Start();
 * is not guaranteed to run, as this will be interrupted preemptively if a hardware update is
 * requested (e.g. on a thread switch).
 */
-void RunLoop(int tight_loop=1000);
+void RunLoop(int tight_loop = 1000);
 /// Step the CPU one instruction
 void SingleStep();
 /// Halt the core
-void Halt(const char *msg);
+void Halt(const char* msg);
 /// Kill the core
 void Stop();
diff --git a/src/core/core_timing.cpp b/src/core/core_timing.cpp
index aba22cdd1..b7b988cf1 100644
--- a/src/core/core_timing.cpp
+++ b/src/core/core_timing.cpp
@@ -21,14 +21,13 @@ int g_clock_rate_arm11 = 268123480;
 #define INITIAL_SLICE_LENGTH 20000
 #define MAX_SLICE_LENGTH 100000000
-namespace CoreTiming
+namespace CoreTiming {
-{
+struct EventType {
-struct EventType
+    EventType() {
-{
+    }
-    EventType() {}
-    EventType(TimedCallback cb, const char* n)
+    EventType(TimedCallback cb, const char* n) : callback(cb), name(n) {
-        : callback(cb), name(n) {}
+    }
    TimedCallback callback;
    const char* name;
@@ -36,8 +35,7 @@ struct EventType
 static std::vector<EventType> event_types;
-struct BaseEvent
+struct BaseEvent {
-{
    s64 time;
    u64 userdata;
    int type;
@@ -200,7 +198,6 @@ u64 GetIdleTicks() {
    return (u64)idled_cycles;
 }
 // This is to be called when outside threads, such as the graphics thread, wants to
 // schedule things to be executed on the main thread.
 void ScheduleEvent_Threadsafe(s64 cycles_into_future, int event_type, u64 userdata) {
@@ -222,12 +219,11 @@ void ScheduleEvent_Threadsafe(s64 cycles_into_future, int event_type, u64 userda
 // Same as ScheduleEvent_Threadsafe(0, ...) EXCEPT if we are already on the CPU thread
 // in which case the event will get handled immediately, before returning.
 void ScheduleEvent_Threadsafe_Immediate(int event_type, u64 userdata) {
-    if (false) //Core::IsCPUThread())
+    if (false) // Core::IsCPUThread())
    {
        std::lock_guard<std::recursive_mutex> lock(external_event_section);
        event_types[event_type].callback(userdata, 0);
-    }
+    } else
-    else
        ScheduleEvent_Threadsafe(0, event_type, userdata);
 }
@@ -317,8 +313,7 @@ s64 UnscheduleThreadsafeEvent(int event_type, u64 userdata) {
        }
    }
-    if (!ts_first)
+    if (!ts_first) {
-    {
        ts_last = nullptr;
        return result;
    }
@@ -369,7 +364,7 @@ void RemoveEvent(int event_type) {
        return;
    while (first) {
        if (first->type == event_type) {
-            Event *next = first->next;
+            Event* next = first->next;
            FreeEvent(first);
            first = next;
        } else {
@@ -509,7 +504,8 @@ void Advance() {
 void LogPendingEvents() {
    Event* event = first;
    while (event) {
-        //LOG_TRACE(Core_Timing, "PENDING: Now: %lld Pending: %lld Type: %d", globalTimer, next->time, next->type);
+        // LOG_TRACE(Core_Timing, "PENDING: Now: %lld Pending: %lld Type: %d", globalTimer,
+        // next->time, next->type);
        event = event->next;
    }
 }
@@ -531,7 +527,8 @@ void Idle(int max_idle) {
        }
    }
-    LOG_TRACE(Core_Timing, "Idle for %" PRId64 " cycles! (%f ms)", cycles_down, cycles_down / (float)(g_clock_rate_arm11 * 0.001f));
+    LOG_TRACE(Core_Timing, "Idle for %" PRId64 " cycles! (%f ms)", cycles_down,
+              cycles_down / (float)(g_clock_rate_arm11 * 0.001f));
    idled_cycles += cycles_down;
    Core::g_app_core->down_count -= cycles_down;
@@ -551,7 +548,7 @@ std::string GetScheduledEventsSummary() {
        if (!name)
            name = "[unknown]";
        text += Common::StringFromFormat("%s : %i %08x%08x\n", name, (int)event->time,
-                (u32)(event->userdata >> 32), (u32)(event->userdata));
+                                         (u32)(event->userdata >> 32), (u32)(event->userdata));
        event = event->next;
    }
    return text;
diff --git a/src/core/core_timing.h b/src/core/core_timing.h
index 3d8a7d0c0..64fd8dcd0 100644
--- a/src/core/core_timing.h
+++ b/src/core/core_timing.h
@@ -61,12 +61,11 @@ inline u64 cyclesToMs(s64 cycles) {
    return cycles / (g_clock_rate_arm11 / 1000);
 }
-namespace CoreTiming
+namespace CoreTiming {
-{
 void Init();
 void Shutdown();
-typedef void(*MHzChangeCallback)();
+typedef void (*MHzChangeCallback)();
 typedef std::function<void(u64 userdata, int cycles_late)> TimedCallback;
 u64 GetTicks();
@@ -81,7 +80,7 @@ u64 GetGlobalTimeUs();
 */
 int RegisterEvent(const char* name, TimedCallback callback);
 /// For save states.
-void RestoreRegisterEvent(int event_type, const char *name, TimedCallback callback);
+void RestoreRegisterEvent(int event_type, const char* name, TimedCallback callback);
 void UnregisterAllEvents();
 /// userdata MAY NOT CONTAIN POINTERS. userdata might get written and reloaded from disk,
@@ -128,7 +127,7 @@ void ClearPendingEvents();
 void LogPendingEvents();
 /// Warning: not included in save states.
-void RegisterAdvanceCallback(void(*callback)(int cycles_executed));
+void RegisterAdvanceCallback(void (*callback)(int cycles_executed));
 void RegisterMHzChangeCallback(MHzChangeCallback callback);
 std::string GetScheduledEventsSummary();
diff --git a/src/core/file_sys/archive_backend.cpp b/src/core/file_sys/archive_backend.cpp
index cc0aa7022..6ea920ec1 100644
--- a/src/core/file_sys/archive_backend.cpp
+++ b/src/core/file_sys/archive_backend.cpp
@@ -12,27 +12,23 @@
 #include "core/file_sys/archive_backend.h"
 #include "core/memory.h"
 namespace FileSys {
 Path::Path(LowPathType type, u32 size, u32 pointer) : type(type) {
    switch (type) {
-    case Binary:
+    case Binary: {
-    {
        binary.resize(size);
        Memory::ReadBlock(pointer, binary.data(), binary.size());
        break;
    }
-    case Char:
+    case Char: {
-    {
        string.resize(size - 1); // Data is always null-terminated.
        Memory::ReadBlock(pointer, &string[0], string.size());
        break;
    }
-    case Wchar:
+    case Wchar: {
-    {
        u16str.resize(size / 2 - 1); // Data is always null-terminated.
        Memory::ReadBlock(pointer, &u16str[0], u16str.size() * sizeof(char16_t));
        break;
@@ -50,8 +46,7 @@ std::string Path::DebugStr() const {
        return "[Invalid]";
    case Empty:
        return "[Empty]";
-    case Binary:
+    case Binary: {
-    {
        std::stringstream res;
        res << "[Binary: ";
        for (unsigned byte : binary)
@@ -73,13 +68,13 @@ std::string Path::AsString() const {
    case Wchar:
        return Common::UTF16ToUTF8(u16str);
    case Empty:
-        return{};
+        return {};
    case Invalid:
    case Binary:
    default:
        // TODO(yuriks): Add assert
        LOG_ERROR(Service_FS, "LowPathType cannot be converted to string!");
-        return{};
+        return {};
    }
 }
@@ -90,12 +85,12 @@ std::u16string Path::AsU16Str() const {
    case Wchar:
        return u16str;
    case Empty:
-        return{};
+        return {};
    case Invalid:
    case Binary:
        // TODO(yuriks): Add assert
        LOG_ERROR(Service_FS, "LowPathType cannot be converted to u16string!");
-        return{};
+        return {};
    }
 }
@@ -105,25 +100,23 @@ std::vector<u8> Path::AsBinary() const {
        return binary;
    case Char:
        return std::vector<u8>(string.begin(), string.end());
-    case Wchar:
+    case Wchar: {
-    {
        // use two u8 for each character of u16str
        std::vector<u8> to_return(u16str.size() * 2);
        for (size_t i = 0; i < u16str.size(); ++i) {
            u16 tmp_char = u16str.at(i);
-            to_return[i*2] = (tmp_char & 0xFF00) >> 8;
+            to_return[i * 2] = (tmp_char & 0xFF00) >> 8;
-            to_return[i*2 + 1] = (tmp_char & 0x00FF);
+            to_return[i * 2 + 1] = (tmp_char & 0x00FF);
        }
        return to_return;
    }
    case Empty:
-        return{};
+        return {};
    case Invalid:
    default:
        // TODO(yuriks): Add assert
        LOG_ERROR(Service_FS, "LowPathType cannot be converted to binary!");
-        return{};
+        return {};
    }
 }
 }
diff --git a/src/core/file_sys/archive_backend.h b/src/core/file_sys/archive_backend.h
index 5d91e47f3..79fde9710 100644
--- a/src/core/file_sys/archive_backend.h
+++ b/src/core/file_sys/archive_backend.h
@@ -15,20 +15,13 @@
 #include "core/hle/result.h"
 namespace FileSys {
 class FileBackend;
 class DirectoryBackend;
 // Path string type
-enum LowPathType : u32 {
+enum LowPathType : u32 { Invalid = 0, Empty = 1, Binary = 2, Char = 3, Wchar = 4 };
-    Invalid = 0,
-    Empty   = 1,
-    Binary  = 2,
-    Char    = 3,
-    Wchar   = 4
-};
 union Mode {
    u32 hex;
@@ -39,12 +32,17 @@ union Mode {
 class Path {
 public:
-    Path() : type(Invalid) {}
+    Path() : type(Invalid) {
-    Path(const char* path) : type(Char), string(path) {}
+    }
-    Path(std::vector<u8> binary_data) : type(Binary), binary(std::move(binary_data)) {}
+    Path(const char* path) : type(Char), string(path) {
+    }
+    Path(std::vector<u8> binary_data) : type(Binary), binary(std::move(binary_data)) {
+    }
    Path(LowPathType type, u32 size, u32 pointer);
-    LowPathType GetType() const { return type; }
+    LowPathType GetType() const {
+        return type;
+    }
    /**
     * Gets the string representation of the path for debugging
@@ -64,10 +62,14 @@ private:
 };
 struct ArchiveFormatInfo {
-    u32_le total_size; ///< The pre-defined size of the archive, as specified in the Create or Format call
+    u32_le total_size; ///< The pre-defined size of the archive, as specified in the Create or
-    u32_le number_directories; ///< The pre-defined number of directories in the archive, as specified in the Create or Format call
+                       /// Format call
-    u32_le number_files; ///< The pre-defined number of files in the archive, as specified in the Create or Format call
+    u32_le number_directories; ///< The pre-defined number of directories in the archive, as
-    u8 duplicate_data; ///< Whether the archive should duplicate the data, as specified in the Create or Format call
+                               /// specified in the Create or Format call
+    u32_le number_files; ///< The pre-defined number of files in the archive, as specified in the
+                         /// Create or Format call
+    u8 duplicate_data;   ///< Whether the archive should duplicate the data, as specified in the
+                         /// Create or Format call
 };
 static_assert(std::is_pod<ArchiveFormatInfo>::value, "ArchiveFormatInfo is not POD");
@@ -87,7 +89,8 @@ public:
     * @param mode Mode to open the file with
     * @return Opened file, or error code
     */
-    virtual ResultVal<std::unique_ptr<FileBackend>> OpenFile(const Path& path, const Mode mode) const = 0;
+    virtual ResultVal<std::unique_ptr<FileBackend>> OpenFile(const Path& path,
+                                                             const Mode mode) const = 0;
    /**
     * Delete a file specified by its path
diff --git a/src/core/file_sys/archive_extsavedata.cpp b/src/core/file_sys/archive_extsavedata.cpp
index 1d9eaefcb..6b4af28bf 100644
--- a/src/core/file_sys/archive_extsavedata.cpp
+++ b/src/core/file_sys/archive_extsavedata.cpp
@@ -30,10 +30,11 @@ std::string GetExtSaveDataPath(const std::string& mount_point, const Path& path)
 std::string GetExtDataContainerPath(const std::string& mount_point, bool shared) {
    if (shared)
-        return Common::StringFromFormat("%sdata/%s/extdata/", mount_point.c_str(), SYSTEM_ID.c_str());
+        return Common::StringFromFormat("%sdata/%s/extdata/", mount_point.c_str(),
+                                        SYSTEM_ID.c_str());
    return Common::StringFromFormat("%sNintendo 3DS/%s/%s/extdata/", mount_point.c_str(),
-            SYSTEM_ID.c_str(), SDCARD_ID.c_str());
+                                    SYSTEM_ID.c_str(), SDCARD_ID.c_str());
 }
 Path ConstructExtDataBinaryPath(u32 media_type, u32 high, u32 low) {
@@ -54,11 +55,12 @@ Path ConstructExtDataBinaryPath(u32 media_type, u32 high, u32 low) {
    for (unsigned i = 0; i < 4; ++i)
        binary_path.push_back((high >> (8 * i)) & 0xFF);
-    return { binary_path };
+    return {binary_path};
 }
-ArchiveFactory_ExtSaveData::ArchiveFactory_ExtSaveData(const std::string& mount_location, bool shared)
+ArchiveFactory_ExtSaveData::ArchiveFactory_ExtSaveData(const std::string& mount_location,
-        : shared(shared), mount_point(GetExtDataContainerPath(mount_location, shared)) {
+                                                       bool shared)
+    : shared(shared), mount_point(GetExtDataContainerPath(mount_location, shared)) {
    LOG_INFO(Service_FS, "Directory %s set as base for ExtSaveData.", mount_point.c_str());
 }
@@ -88,7 +90,8 @@ ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_ExtSaveData::Open(cons
    return MakeResult<std::unique_ptr<ArchiveBackend>>(std::move(archive));
 }
-ResultCode ArchiveFactory_ExtSaveData::Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info) {
+ResultCode ArchiveFactory_ExtSaveData::Format(const Path& path,
+                                              const FileSys::ArchiveFormatInfo& format_info) {
    // These folders are always created with the ExtSaveData
    std::string user_path = GetExtSaveDataPath(mount_point, path) + "user/";
    std::string boss_path = GetExtSaveDataPath(mount_point, path) + "boss/";
@@ -115,7 +118,8 @@ ResultVal<ArchiveFormatInfo> ArchiveFactory_ExtSaveData::GetFormatInfo(const Pat
    if (!file.IsOpen()) {
        LOG_ERROR(Service_FS, "Could not open metadata information for archive");
        // TODO(Subv): Verify error code
-        return ResultCode(ErrorDescription::FS_NotFormatted, ErrorModule::FS, ErrorSummary::InvalidState, ErrorLevel::Status);
+        return ResultCode(ErrorDescription::FS_NotFormatted, ErrorModule::FS,
+                          ErrorSummary::InvalidState, ErrorLevel::Status);
    }
    ArchiveFormatInfo info = {};
@@ -123,7 +127,8 @@ ResultVal<ArchiveFormatInfo> ArchiveFactory_ExtSaveData::GetFormatInfo(const Pat
    return MakeResult<ArchiveFormatInfo>(info);
 }
-void ArchiveFactory_ExtSaveData::WriteIcon(const Path& path, const u8* icon_data, size_t icon_size) {
+void ArchiveFactory_ExtSaveData::WriteIcon(const Path& path, const u8* icon_data,
+                                           size_t icon_size) {
    std::string game_path = FileSys::GetExtSaveDataPath(GetMountPoint(), path);
    FileUtil::IOFile icon_file(game_path + "icon", "wb");
    icon_file.WriteBytes(icon_data, icon_size);
diff --git a/src/core/file_sys/archive_extsavedata.h b/src/core/file_sys/archive_extsavedata.h
index e9a72850d..2b942817e 100644
--- a/src/core/file_sys/archive_extsavedata.h
+++ b/src/core/file_sys/archive_extsavedata.h
@@ -28,13 +28,17 @@ public:
     */
    bool Initialize();
-    std::string GetName() const override { return "ExtSaveData"; }
+    std::string GetName() const override {
+        return "ExtSaveData";
+    }
    ResultVal<std::unique_ptr<ArchiveBackend>> Open(const Path& path) override;
    ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info) override;
    ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path) const override;
-    const std::string& GetMountPoint() const { return mount_point; }
+    const std::string& GetMountPoint() const {
+        return mount_point;
+    }
    /**
     * Writes the SMDH icon of the ExtSaveData to file
@@ -45,7 +49,8 @@ public:
    void WriteIcon(const Path& path, const u8* icon_data, size_t icon_size);
 private:
-    bool shared; ///< Whether this archive represents an ExtSaveData archive or a SharedExtSaveData archive
+    bool shared; ///< Whether this archive represents an ExtSaveData archive or a SharedExtSaveData
+                 /// archive
    /**
     * This holds the full directory path for this archive, it is only set after a successful call
@@ -65,7 +70,8 @@ private:
 std::string GetExtSaveDataPath(const std::string& mount_point, const Path& path);
 /**
- * Constructs a path to the base folder to hold concrete ExtSaveData archives in the host file system.
+ * Constructs a path to the base folder to hold concrete ExtSaveData archives in the host file
+ * system.
 * @param mount_point The base folder where this folder resides, ie. SDMC or NAND.
 * @param shared Whether this ExtSaveData container is for SharedExtSaveDatas or not.
 * @returns The path to the base ExtSaveData archives' folder in the host file system
diff --git a/src/core/file_sys/archive_romfs.cpp b/src/core/file_sys/archive_romfs.cpp
index 38828b546..87455eb95 100644
--- a/src/core/file_sys/archive_romfs.cpp
+++ b/src/core/file_sys/archive_romfs.cpp
@@ -28,11 +28,12 @@ ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_RomFS::Open(const Path
    return MakeResult<std::unique_ptr<ArchiveBackend>>(std::move(archive));
 }
-ResultCode ArchiveFactory_RomFS::Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info) {
+ResultCode ArchiveFactory_RomFS::Format(const Path& path,
+                                        const FileSys::ArchiveFormatInfo& format_info) {
    LOG_ERROR(Service_FS, "Attempted to format a RomFS archive.");
    // TODO: Verify error code
-    return ResultCode(ErrorDescription::NotAuthorized, ErrorModule::FS,
+    return ResultCode(ErrorDescription::NotAuthorized, ErrorModule::FS, ErrorSummary::NotSupported,
-            ErrorSummary::NotSupported, ErrorLevel::Permanent);
+                      ErrorLevel::Permanent);
 }
 ResultVal<ArchiveFormatInfo> ArchiveFactory_RomFS::GetFormatInfo(const Path& path) const {
diff --git a/src/core/file_sys/archive_romfs.h b/src/core/file_sys/archive_romfs.h
index c5a329122..3c68a6b1c 100644
--- a/src/core/file_sys/archive_romfs.h
+++ b/src/core/file_sys/archive_romfs.h
@@ -24,7 +24,9 @@ class ArchiveFactory_RomFS final : public ArchiveFactory {
 public:
    ArchiveFactory_RomFS(Loader::AppLoader& app_loader);
-    std::string GetName() const override { return "RomFS"; }
+    std::string GetName() const override {
+        return "RomFS";
+    }
    ResultVal<std::unique_ptr<ArchiveBackend>> Open(const Path& path) override;
    ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info) override;
    ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path) const override;
diff --git a/src/core/file_sys/archive_savedata.cpp b/src/core/file_sys/archive_savedata.cpp
index fd5711e14..9a264091f 100644
--- a/src/core/file_sys/archive_savedata.cpp
+++ b/src/core/file_sys/archive_savedata.cpp
@@ -22,48 +22,55 @@ namespace FileSys {
 static std::string GetSaveDataContainerPath(const std::string& sdmc_directory) {
    return Common::StringFromFormat("%sNintendo 3DS/%s/%s/title/", sdmc_directory.c_str(),
-            SYSTEM_ID.c_str(), SDCARD_ID.c_str());
+                                    SYSTEM_ID.c_str(), SDCARD_ID.c_str());
 }
 static std::string GetSaveDataPath(const std::string& mount_location, u64 program_id) {
    u32 high = (u32)(program_id >> 32);
    u32 low = (u32)(program_id & 0xFFFFFFFF);
-    return Common::StringFromFormat("%s%08x/%08x/data/00000001/", mount_location.c_str(), high, low);
+    return Common::StringFromFormat("%s%08x/%08x/data/00000001/", mount_location.c_str(), high,
+                                    low);
 }
 static std::string GetSaveDataMetadataPath(const std::string& mount_location, u64 program_id) {
    u32 high = (u32)(program_id >> 32);
    u32 low = (u32)(program_id & 0xFFFFFFFF);
-    return Common::StringFromFormat("%s%08x/%08x/data/00000001.metadata", mount_location.c_str(), high, low);
+    return Common::StringFromFormat("%s%08x/%08x/data/00000001.metadata", mount_location.c_str(),
+                                    high, low);
 }
 ArchiveFactory_SaveData::ArchiveFactory_SaveData(const std::string& sdmc_directory)
-        : mount_point(GetSaveDataContainerPath(sdmc_directory)) {
+    : mount_point(GetSaveDataContainerPath(sdmc_directory)) {
    LOG_INFO(Service_FS, "Directory %s set as SaveData.", this->mount_point.c_str());
 }
 ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_SaveData::Open(const Path& path) {
-    std::string concrete_mount_point = GetSaveDataPath(mount_point, Kernel::g_current_process->codeset->program_id);
+    std::string concrete_mount_point =
+        GetSaveDataPath(mount_point, Kernel::g_current_process->codeset->program_id);
    if (!FileUtil::Exists(concrete_mount_point)) {
        // When a SaveData archive is created for the first time, it is not yet formatted
        // and the save file/directory structure expected by the game has not yet been initialized.
-        // Returning the NotFormatted error code will signal the game to provision the SaveData archive
+        // Returning the NotFormatted error code will signal the game to provision the SaveData
+        // archive
        // with the files and folders that it expects.
        return ResultCode(ErrorDescription::FS_NotFormatted, ErrorModule::FS,
-            ErrorSummary::InvalidState, ErrorLevel::Status);
+                          ErrorSummary::InvalidState, ErrorLevel::Status);
    }
    auto archive = std::make_unique<DiskArchive>(std::move(concrete_mount_point));
    return MakeResult<std::unique_ptr<ArchiveBackend>>(std::move(archive));
 }
-ResultCode ArchiveFactory_SaveData::Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info) {
+ResultCode ArchiveFactory_SaveData::Format(const Path& path,
-    std::string concrete_mount_point = GetSaveDataPath(mount_point, Kernel::g_current_process->codeset->program_id);
+                                           const FileSys::ArchiveFormatInfo& format_info) {
+    std::string concrete_mount_point =
+        GetSaveDataPath(mount_point, Kernel::g_current_process->codeset->program_id);
    FileUtil::DeleteDirRecursively(concrete_mount_point);
    FileUtil::CreateFullPath(concrete_mount_point);
    // Write the format metadata
-    std::string metadata_path = GetSaveDataMetadataPath(mount_point, Kernel::g_current_process->codeset->program_id);
+    std::string metadata_path =
+        GetSaveDataMetadataPath(mount_point, Kernel::g_current_process->codeset->program_id);
    FileUtil::IOFile file(metadata_path, "wb");
    if (file.IsOpen()) {
@@ -74,13 +81,15 @@ ResultCode ArchiveFactory_SaveData::Format(const Path& path, const FileSys::Arch
 }
 ResultVal<ArchiveFormatInfo> ArchiveFactory_SaveData::GetFormatInfo(const Path& path) const {
-    std::string metadata_path = GetSaveDataMetadataPath(mount_point, Kernel::g_current_process->codeset->program_id);
+    std::string metadata_path =
+        GetSaveDataMetadataPath(mount_point, Kernel::g_current_process->codeset->program_id);
    FileUtil::IOFile file(metadata_path, "rb");
    if (!file.IsOpen()) {
        LOG_ERROR(Service_FS, "Could not open metadata information for archive");
        // TODO(Subv): Verify error code
-        return ResultCode(ErrorDescription::FS_NotFormatted, ErrorModule::FS, ErrorSummary::InvalidState, ErrorLevel::Status);
+        return ResultCode(ErrorDescription::FS_NotFormatted, ErrorModule::FS,
+                          ErrorSummary::InvalidState, ErrorLevel::Status);
    }
    ArchiveFormatInfo info = {};
diff --git a/src/core/file_sys/archive_savedata.h b/src/core/file_sys/archive_savedata.h
index 7a5a24089..4ac324985 100644
--- a/src/core/file_sys/archive_savedata.h
+++ b/src/core/file_sys/archive_savedata.h
@@ -20,7 +20,9 @@ class ArchiveFactory_SaveData final : public ArchiveFactory {
 public:
    ArchiveFactory_SaveData(const std::string& mount_point);
-    std::string GetName() const override { return "SaveData"; }
+    std::string GetName() const override {
+        return "SaveData";
+    }
    ResultVal<std::unique_ptr<ArchiveBackend>> Open(const Path& path) override;
    ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info) override;
diff --git a/src/core/file_sys/archive_savedatacheck.cpp b/src/core/file_sys/archive_savedatacheck.cpp
index 9f65e5455..fd9b84302 100644
--- a/src/core/file_sys/archive_savedatacheck.cpp
+++ b/src/core/file_sys/archive_savedatacheck.cpp
@@ -25,12 +25,12 @@ static std::string GetSaveDataCheckContainerPath(const std::string& nand_directo
 }
 static std::string GetSaveDataCheckPath(const std::string& mount_point, u32 high, u32 low) {
-    return Common::StringFromFormat("%s%08x/%08x/content/00000000.app.romfs",
+    return Common::StringFromFormat("%s%08x/%08x/content/00000000.app.romfs", mount_point.c_str(),
-            mount_point.c_str(), high, low);
+                                    high, low);
 }
-ArchiveFactory_SaveDataCheck::ArchiveFactory_SaveDataCheck(const std::string& nand_directory) :
+ArchiveFactory_SaveDataCheck::ArchiveFactory_SaveDataCheck(const std::string& nand_directory)
-        mount_point(GetSaveDataCheckContainerPath(nand_directory)) {
+    : mount_point(GetSaveDataCheckContainerPath(nand_directory)) {
 }
 ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_SaveDataCheck::Open(const Path& path) {
@@ -48,11 +48,12 @@ ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_SaveDataCheck::Open(co
    return MakeResult<std::unique_ptr<ArchiveBackend>>(std::move(archive));
 }
-ResultCode ArchiveFactory_SaveDataCheck::Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info) {
+ResultCode ArchiveFactory_SaveDataCheck::Format(const Path& path,
+                                                const FileSys::ArchiveFormatInfo& format_info) {
    LOG_ERROR(Service_FS, "Attempted to format a SaveDataCheck archive.");
    // TODO: Verify error code
-    return ResultCode(ErrorDescription::NotAuthorized, ErrorModule::FS,
+    return ResultCode(ErrorDescription::NotAuthorized, ErrorModule::FS, ErrorSummary::NotSupported,
-        ErrorSummary::NotSupported, ErrorLevel::Permanent);
+                      ErrorLevel::Permanent);
 }
 ResultVal<ArchiveFormatInfo> ArchiveFactory_SaveDataCheck::GetFormatInfo(const Path& path) const {
diff --git a/src/core/file_sys/archive_savedatacheck.h b/src/core/file_sys/archive_savedatacheck.h
index ea2624d64..4a4259260 100644
--- a/src/core/file_sys/archive_savedatacheck.h
+++ b/src/core/file_sys/archive_savedatacheck.h
@@ -20,7 +20,9 @@ class ArchiveFactory_SaveDataCheck final : public ArchiveFactory {
 public:
    ArchiveFactory_SaveDataCheck(const std::string& mount_point);
-    std::string GetName() const override { return "SaveDataCheck"; }
+    std::string GetName() const override {
+        return "SaveDataCheck";
+    }
    ResultVal<std::unique_ptr<ArchiveBackend>> Open(const Path& path) override;
    ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info) override;
diff --git a/src/core/file_sys/archive_sdmc.cpp b/src/core/file_sys/archive_sdmc.cpp
index 9b218af58..c1a28df6c 100644
--- a/src/core/file_sys/archive_sdmc.cpp
+++ b/src/core/file_sys/archive_sdmc.cpp
@@ -17,7 +17,8 @@
 namespace FileSys {
-ArchiveFactory_SDMC::ArchiveFactory_SDMC(const std::string& sdmc_directory) : sdmc_directory(sdmc_directory) {
+ArchiveFactory_SDMC::ArchiveFactory_SDMC(const std::string& sdmc_directory)
+    : sdmc_directory(sdmc_directory) {
    LOG_INFO(Service_FS, "Directory %s set as SDMC.", sdmc_directory.c_str());
 }
@@ -40,7 +41,8 @@ ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_SDMC::Open(const Path&
    return MakeResult<std::unique_ptr<ArchiveBackend>>(std::move(archive));
 }
-ResultCode ArchiveFactory_SDMC::Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info) {
+ResultCode ArchiveFactory_SDMC::Format(const Path& path,
+                                       const FileSys::ArchiveFormatInfo& format_info) {
    // This is kind of an undesirable operation, so let's just ignore it. :)
    return RESULT_SUCCESS;
 }
diff --git a/src/core/file_sys/archive_sdmc.h b/src/core/file_sys/archive_sdmc.h
index 35c0f3725..2523c3979 100644
--- a/src/core/file_sys/archive_sdmc.h
+++ b/src/core/file_sys/archive_sdmc.h
@@ -26,7 +26,9 @@ public:
     */
    bool Initialize();
-    std::string GetName() const override { return "SDMC"; }
+    std::string GetName() const override {
+        return "SDMC";
+    }
    ResultVal<std::unique_ptr<ArchiveBackend>> Open(const Path& path) override;
    ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info) override;
diff --git a/src/core/file_sys/archive_systemsavedata.cpp b/src/core/file_sys/archive_systemsavedata.cpp
index 1bcc228a1..1fb858247 100644
--- a/src/core/file_sys/archive_systemsavedata.cpp
+++ b/src/core/file_sys/archive_systemsavedata.cpp
@@ -45,11 +45,11 @@ Path ConstructSystemSaveDataBinaryPath(u32 high, u32 low) {
    for (unsigned i = 0; i < 4; ++i)
        binary_path.push_back((low >> (8 * i)) & 0xFF);
-    return { binary_path };
+    return {binary_path};
 }
 ArchiveFactory_SystemSaveData::ArchiveFactory_SystemSaveData(const std::string& nand_path)
-        : base_path(GetSystemSaveDataContainerPath(nand_path)) {
+    : base_path(GetSystemSaveDataContainerPath(nand_path)) {
 }
 ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_SystemSaveData::Open(const Path& path) {
@@ -57,13 +57,14 @@ ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_SystemSaveData::Open(c
    if (!FileUtil::Exists(fullpath)) {
        // TODO(Subv): Check error code, this one is probably wrong
        return ResultCode(ErrorDescription::FS_NotFormatted, ErrorModule::FS,
-            ErrorSummary::InvalidState, ErrorLevel::Status);
+                          ErrorSummary::InvalidState, ErrorLevel::Status);
    }
    auto archive = std::make_unique<DiskArchive>(fullpath);
    return MakeResult<std::unique_ptr<ArchiveBackend>>(std::move(archive));
 }
-ResultCode ArchiveFactory_SystemSaveData::Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info) {
+ResultCode ArchiveFactory_SystemSaveData::Format(const Path& path,
+                                                 const FileSys::ArchiveFormatInfo& format_info) {
    std::string fullpath = GetSystemSaveDataPath(base_path, path);
    FileUtil::DeleteDirRecursively(fullpath);
    FileUtil::CreateFullPath(fullpath);
diff --git a/src/core/file_sys/archive_systemsavedata.h b/src/core/file_sys/archive_systemsavedata.h
index 2bc13d4ee..61a002a7d 100644
--- a/src/core/file_sys/archive_systemsavedata.h
+++ b/src/core/file_sys/archive_systemsavedata.h
@@ -26,7 +26,9 @@ public:
    ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info) override;
    ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path) const override;
-    std::string GetName() const override { return "SystemSaveData"; }
+    std::string GetName() const override {
+        return "SystemSaveData";
+    }
 private:
    std::string base_path;
@@ -42,7 +44,8 @@ private:
 std::string GetSystemSaveDataPath(const std::string& mount_point, const Path& path);
 /**
- * Constructs a path to the base folder to hold concrete SystemSaveData archives in the host file system.
+ * Constructs a path to the base folder to hold concrete SystemSaveData archives in the host file
+ * system.
 * @param mount_point The base folder where this folder resides, ie. SDMC or NAND.
 * @returns The path to the base SystemSaveData archives' folder in the host file system
 */
diff --git a/src/core/file_sys/directory_backend.h b/src/core/file_sys/directory_backend.h
index a25dc0cfa..c402ee60b 100644
--- a/src/core/file_sys/directory_backend.h
+++ b/src/core/file_sys/directory_backend.h
@@ -19,15 +19,16 @@ const size_t FILENAME_LENGTH = 0x20C / 2;
 struct Entry {
    char16_t filename[FILENAME_LENGTH]; // Entry name (UTF-16, null-terminated)
    std::array<char, 9> short_name; // 8.3 file name ('longfilename' -> 'LONGFI~1', null-terminated)
-    char unknown1; // unknown (observed values: 0x0A, 0x70, 0xFD)
+    char unknown1;                  // unknown (observed values: 0x0A, 0x70, 0xFD)
-    std::array<char, 4> extension; // 8.3 file extension (set to spaces for directories, null-terminated)
+    std::array<char, 4>
-    char unknown2; // unknown (always 0x01)
+        extension;     // 8.3 file extension (set to spaces for directories, null-terminated)
-    char unknown3; // unknown (0x00 or 0x08)
+    char unknown2;     // unknown (always 0x01)
+    char unknown3;     // unknown (0x00 or 0x08)
    char is_directory; // directory flag
-    char is_hidden; // hidden flag
+    char is_hidden;    // hidden flag
-    char is_archive; // archive flag
+    char is_archive;   // archive flag
    char is_read_only; // read-only flag
-    u64 file_size; // file size (for files only)
+    u64 file_size;     // file size (for files only)
 };
 static_assert(sizeof(Entry) == 0x228, "Directory Entry struct isn't exactly 0x228 bytes long!");
 static_assert(offsetof(Entry, short_name) == 0x20C, "Wrong offset for short_name in Entry.");
@@ -37,8 +38,10 @@ static_assert(offsetof(Entry, file_size) == 0x220, "Wrong offset for file_size i
 class DirectoryBackend : NonCopyable {
 public:
-    DirectoryBackend() { }
+    DirectoryBackend() {
-    virtual ~DirectoryBackend() { }
+    }
+    virtual ~DirectoryBackend() {
+    }
    /**
    * Open the directory
diff --git a/src/core/file_sys/disk_archive.cpp b/src/core/file_sys/disk_archive.cpp
index 489cc96fb..c084303c1 100644
--- a/src/core/file_sys/disk_archive.cpp
+++ b/src/core/file_sys/disk_archive.cpp
@@ -17,7 +17,8 @@
 namespace FileSys {
-ResultVal<std::unique_ptr<FileBackend>> DiskArchive::OpenFile(const Path& path, const Mode mode) const {
+ResultVal<std::unique_ptr<FileBackend>> DiskArchive::OpenFile(const Path& path,
+                                                              const Mode mode) const {
    LOG_DEBUG(Service_FS, "called path=%s mode=%01X", path.DebugStr().c_str(), mode.hex);
    auto file = std::make_unique<DiskFile>(*this, path, mode);
    ResultCode result = file->Open();
@@ -30,15 +31,18 @@ ResultCode DiskArchive::DeleteFile(const Path& path) const {
    std::string file_path = mount_point + path.AsString();
    if (FileUtil::IsDirectory(file_path))
-        return ResultCode(ErrorDescription::FS_NotAFile, ErrorModule::FS, ErrorSummary::Canceled, ErrorLevel::Status);
+        return ResultCode(ErrorDescription::FS_NotAFile, ErrorModule::FS, ErrorSummary::Canceled,
+                          ErrorLevel::Status);
    if (!FileUtil::Exists(file_path))
-        return ResultCode(ErrorDescription::FS_NotFound, ErrorModule::FS, ErrorSummary::NotFound, ErrorLevel::Status);
+        return ResultCode(ErrorDescription::FS_NotFound, ErrorModule::FS, ErrorSummary::NotFound,
+                          ErrorLevel::Status);
    if (FileUtil::Delete(file_path))
        return RESULT_SUCCESS;
-    return ResultCode(ErrorDescription::FS_NotAFile, ErrorModule::FS, ErrorSummary::Canceled, ErrorLevel::Status);
+    return ResultCode(ErrorDescription::FS_NotAFile, ErrorModule::FS, ErrorSummary::Canceled,
+                      ErrorLevel::Status);
 }
 bool DiskArchive::RenameFile(const Path& src_path, const Path& dest_path) const {
@@ -53,10 +57,12 @@ ResultCode DiskArchive::CreateFile(const FileSys::Path& path, u64 size) const {
    std::string full_path = mount_point + path.AsString();
    if (FileUtil::IsDirectory(full_path))
-        return ResultCode(ErrorDescription::FS_NotAFile, ErrorModule::FS, ErrorSummary::Canceled, ErrorLevel::Status);
+        return ResultCode(ErrorDescription::FS_NotAFile, ErrorModule::FS, ErrorSummary::Canceled,
+                          ErrorLevel::Status);
    if (FileUtil::Exists(full_path))
-        return ResultCode(ErrorDescription::FS_AlreadyExists, ErrorModule::FS, ErrorSummary::NothingHappened, ErrorLevel::Status);
+        return ResultCode(ErrorDescription::FS_AlreadyExists, ErrorModule::FS,
+                          ErrorSummary::NothingHappened, ErrorLevel::Status);
    if (size == 0) {
        FileUtil::CreateEmptyFile(full_path);
@@ -69,10 +75,10 @@ ResultCode DiskArchive::CreateFile(const FileSys::Path& path, u64 size) const {
    if (file.Seek(size - 1, SEEK_SET) && file.WriteBytes("", 1) == 1)
        return RESULT_SUCCESS;
-    return ResultCode(ErrorDescription::TooLarge, ErrorModule::FS, ErrorSummary::OutOfResource, ErrorLevel::Info);
+    return ResultCode(ErrorDescription::TooLarge, ErrorModule::FS, ErrorSummary::OutOfResource,
+                      ErrorLevel::Info);
 }
 bool DiskArchive::CreateDirectory(const Path& path) const {
    return FileUtil::CreateDir(mount_point + path.AsString());
 }
@@ -106,17 +112,21 @@ DiskFile::DiskFile(const DiskArchive& archive, const Path& path, const Mode mode
 ResultCode DiskFile::Open() {
    if (FileUtil::IsDirectory(path))
-        return ResultCode(ErrorDescription::FS_NotAFile, ErrorModule::FS, ErrorSummary::Canceled, ErrorLevel::Status);
+        return ResultCode(ErrorDescription::FS_NotAFile, ErrorModule::FS, ErrorSummary::Canceled,
+                          ErrorLevel::Status);
    // Specifying only the Create flag is invalid
    if (mode.create_flag && !mode.read_flag && !mode.write_flag) {
-        return ResultCode(ErrorDescription::FS_InvalidOpenFlags, ErrorModule::FS, ErrorSummary::Canceled, ErrorLevel::Status);
+        return ResultCode(ErrorDescription::FS_InvalidOpenFlags, ErrorModule::FS,
+                          ErrorSummary::Canceled, ErrorLevel::Status);
    }
    if (!FileUtil::Exists(path)) {
        if (!mode.create_flag) {
-            LOG_ERROR(Service_FS, "Non-existing file %s can't be open without mode create.", path.c_str());
+            LOG_ERROR(Service_FS, "Non-existing file %s can't be open without mode create.",
-            return ResultCode(ErrorDescription::FS_NotFound, ErrorModule::FS, ErrorSummary::NotFound, ErrorLevel::Status);
+                      path.c_str());
+            return ResultCode(ErrorDescription::FS_NotFound, ErrorModule::FS,
+                              ErrorSummary::NotFound, ErrorLevel::Status);
        } else {
            // Create the file
            FileUtil::CreateEmptyFile(path);
@@ -135,20 +145,24 @@ ResultCode DiskFile::Open() {
    file = std::make_unique<FileUtil::IOFile>(path, mode_string.c_str());
    if (file->IsOpen())
        return RESULT_SUCCESS;
-    return ResultCode(ErrorDescription::FS_NotFound, ErrorModule::FS, ErrorSummary::NotFound, ErrorLevel::Status);
+    return ResultCode(ErrorDescription::FS_NotFound, ErrorModule::FS, ErrorSummary::NotFound,
+                      ErrorLevel::Status);
 }
 ResultVal<size_t> DiskFile::Read(const u64 offset, const size_t length, u8* buffer) const {
    if (!mode.read_flag && !mode.write_flag)
-        return ResultCode(ErrorDescription::FS_InvalidOpenFlags, ErrorModule::FS, ErrorSummary::Canceled, ErrorLevel::Status);
+        return ResultCode(ErrorDescription::FS_InvalidOpenFlags, ErrorModule::FS,
+                          ErrorSummary::Canceled, ErrorLevel::Status);
    file->Seek(offset, SEEK_SET);
    return MakeResult<size_t>(file->ReadBytes(buffer, length));
 }
-ResultVal<size_t> DiskFile::Write(const u64 offset, const size_t length, const bool flush, const u8* buffer) const {
+ResultVal<size_t> DiskFile::Write(const u64 offset, const size_t length, const bool flush,
+                                  const u8* buffer) const {
    if (!mode.write_flag)
-        return ResultCode(ErrorDescription::FS_InvalidOpenFlags, ErrorModule::FS, ErrorSummary::Canceled, ErrorLevel::Status);
+        return ResultCode(ErrorDescription::FS_InvalidOpenFlags, ErrorModule::FS,
+                          ErrorSummary::Canceled, ErrorLevel::Status);
    file->Seek(offset, SEEK_SET);
    size_t written = file->WriteBytes(buffer, length);
@@ -198,7 +212,8 @@ u32 DiskDirectory::Read(const u32 count, Entry* entries) {
        const std::string& filename = file.virtualName;
        Entry& entry = entries[entries_read];
-        LOG_TRACE(Service_FS, "File %s: size=%llu dir=%d", filename.c_str(), file.size, file.isDirectory);
+        LOG_TRACE(Service_FS, "File %s: size=%llu dir=%d", filename.c_str(), file.size,
+                  file.isDirectory);
        // TODO(Link Mauve): use a proper conversion to UTF-16.
        for (size_t j = 0; j < FILENAME_LENGTH; ++j) {
diff --git a/src/core/file_sys/disk_archive.h b/src/core/file_sys/disk_archive.h
index b4cc2f702..3f620128f 100644
--- a/src/core/file_sys/disk_archive.h
+++ b/src/core/file_sys/disk_archive.h
@@ -29,11 +29,15 @@ namespace FileSys {
 */
 class DiskArchive : public ArchiveBackend {
 public:
-    DiskArchive(const std::string& mount_point_) : mount_point(mount_point_) {}
+    DiskArchive(const std::string& mount_point_) : mount_point(mount_point_) {
+    }
-    virtual std::string GetName() const override { return "DiskArchive: " + mount_point; }
+    virtual std::string GetName() const override {
+        return "DiskArchive: " + mount_point;
+    }
-    ResultVal<std::unique_ptr<FileBackend>> OpenFile(const Path& path, const Mode mode) const override;
+    ResultVal<std::unique_ptr<FileBackend>> OpenFile(const Path& path,
+                                                     const Mode mode) const override;
    ResultCode DeleteFile(const Path& path) const override;
    bool RenameFile(const Path& src_path, const Path& dest_path) const override;
    bool DeleteDirectory(const Path& path) const override;
diff --git a/src/core/file_sys/file_backend.h b/src/core/file_sys/file_backend.h
index 9137bbbad..9eae697c2 100644
--- a/src/core/file_sys/file_backend.h
+++ b/src/core/file_sys/file_backend.h
@@ -16,8 +16,10 @@ namespace FileSys {
 class FileBackend : NonCopyable {
 public:
-    FileBackend() { }
+    FileBackend() {
-    virtual ~FileBackend() { }
+    }
+    virtual ~FileBackend() {
+    }
    /**
     * Open the file
@@ -42,7 +44,8 @@ public:
     * @param buffer Buffer to read data from
     * @return Number of bytes written, or error code
     */
-    virtual ResultVal<size_t> Write(u64 offset, size_t length, bool flush, const u8* buffer) const = 0;
+    virtual ResultVal<size_t> Write(u64 offset, size_t length, bool flush,
+                                    const u8* buffer) const = 0;
    /**
     * Get the size of the file in bytes
diff --git a/src/core/file_sys/ivfc_archive.cpp b/src/core/file_sys/ivfc_archive.cpp
index c61791ef7..235a962e9 100644
--- a/src/core/file_sys/ivfc_archive.cpp
+++ b/src/core/file_sys/ivfc_archive.cpp
@@ -19,40 +19,49 @@ std::string IVFCArchive::GetName() const {
    return "IVFC";
 }
-ResultVal<std::unique_ptr<FileBackend>> IVFCArchive::OpenFile(const Path& path, const Mode mode) const {
+ResultVal<std::unique_ptr<FileBackend>> IVFCArchive::OpenFile(const Path& path,
-    return MakeResult<std::unique_ptr<FileBackend>>(std::make_unique<IVFCFile>(romfs_file, data_offset, data_size));
+                                                              const Mode mode) const {
+    return MakeResult<std::unique_ptr<FileBackend>>(
+        std::make_unique<IVFCFile>(romfs_file, data_offset, data_size));
 }
 ResultCode IVFCArchive::DeleteFile(const Path& path) const {
-    LOG_CRITICAL(Service_FS, "Attempted to delete a file from an IVFC archive (%s).", GetName().c_str());
+    LOG_CRITICAL(Service_FS, "Attempted to delete a file from an IVFC archive (%s).",
+                 GetName().c_str());
    // TODO(Subv): Verify error code
-    return ResultCode(ErrorDescription::NoData, ErrorModule::FS,
+    return ResultCode(ErrorDescription::NoData, ErrorModule::FS, ErrorSummary::Canceled,
-                      ErrorSummary::Canceled, ErrorLevel::Status);
+                      ErrorLevel::Status);
 }
 bool IVFCArchive::RenameFile(const Path& src_path, const Path& dest_path) const {
-    LOG_CRITICAL(Service_FS, "Attempted to rename a file within an IVFC archive (%s).", GetName().c_str());
+    LOG_CRITICAL(Service_FS, "Attempted to rename a file within an IVFC archive (%s).",
+                 GetName().c_str());
    return false;
 }
 bool IVFCArchive::DeleteDirectory(const Path& path) const {
-    LOG_CRITICAL(Service_FS, "Attempted to delete a directory from an IVFC archive (%s).", GetName().c_str());
+    LOG_CRITICAL(Service_FS, "Attempted to delete a directory from an IVFC archive (%s).",
+                 GetName().c_str());
    return false;
 }
 ResultCode IVFCArchive::CreateFile(const Path& path, u64 size) const {
-    LOG_CRITICAL(Service_FS, "Attempted to create a file in an IVFC archive (%s).", GetName().c_str());
+    LOG_CRITICAL(Service_FS, "Attempted to create a file in an IVFC archive (%s).",
+                 GetName().c_str());
    // TODO: Verify error code
-    return ResultCode(ErrorDescription::NotAuthorized, ErrorModule::FS, ErrorSummary::NotSupported, ErrorLevel::Permanent);
+    return ResultCode(ErrorDescription::NotAuthorized, ErrorModule::FS, ErrorSummary::NotSupported,
+                      ErrorLevel::Permanent);
 }
 bool IVFCArchive::CreateDirectory(const Path& path) const {
-    LOG_CRITICAL(Service_FS, "Attempted to create a directory in an IVFC archive (%s).", GetName().c_str());
+    LOG_CRITICAL(Service_FS, "Attempted to create a directory in an IVFC archive (%s).",
+                 GetName().c_str());
    return false;
 }
 bool IVFCArchive::RenameDirectory(const Path& src_path, const Path& dest_path) const {
-    LOG_CRITICAL(Service_FS, "Attempted to rename a file within an IVFC archive (%s).", GetName().c_str());
+    LOG_CRITICAL(Service_FS, "Attempted to rename a file within an IVFC archive (%s).",
+                 GetName().c_str());
    return false;
 }
@@ -75,7 +84,8 @@ ResultVal<size_t> IVFCFile::Read(const u64 offset, const size_t length, u8* buff
    return MakeResult<size_t>(romfs_file->ReadBytes(buffer, read_length));
 }
-ResultVal<size_t> IVFCFile::Write(const u64 offset, const size_t length, const bool flush, const u8* buffer) const {
+ResultVal<size_t> IVFCFile::Write(const u64 offset, const size_t length, const bool flush,
+                                  const u8* buffer) const {
    LOG_ERROR(Service_FS, "Attempted to write to IVFC file");
    // TODO(Subv): Find error code
    return MakeResult<size_t>(0);
diff --git a/src/core/file_sys/ivfc_archive.h b/src/core/file_sys/ivfc_archive.h
index 19d32dcca..dab1958f6 100644
--- a/src/core/file_sys/ivfc_archive.h
+++ b/src/core/file_sys/ivfc_archive.h
@@ -30,11 +30,13 @@ namespace FileSys {
 class IVFCArchive : public ArchiveBackend {
 public:
    IVFCArchive(std::shared_ptr<FileUtil::IOFile> file, u64 offset, u64 size)
-        : romfs_file(file), data_offset(offset), data_size(size) {}
+        : romfs_file(file), data_offset(offset), data_size(size) {
+    }
    std::string GetName() const override;
-    ResultVal<std::unique_ptr<FileBackend>> OpenFile(const Path& path, const Mode mode) const override;
+    ResultVal<std::unique_ptr<FileBackend>> OpenFile(const Path& path,
+                                                     const Mode mode) const override;
    ResultCode DeleteFile(const Path& path) const override;
    bool RenameFile(const Path& src_path, const Path& dest_path) const override;
    bool DeleteDirectory(const Path& path) const override;
@@ -53,15 +55,21 @@ protected:
 class IVFCFile : public FileBackend {
 public:
    IVFCFile(std::shared_ptr<FileUtil::IOFile> file, u64 offset, u64 size)
-        : romfs_file(file), data_offset(offset), data_size(size) {}
+        : romfs_file(file), data_offset(offset), data_size(size) {
+    }
-    ResultCode Open() override { return RESULT_SUCCESS; }
+    ResultCode Open() override {
+        return RESULT_SUCCESS;
+    }
    ResultVal<size_t> Read(u64 offset, size_t length, u8* buffer) const override;
    ResultVal<size_t> Write(u64 offset, size_t length, bool flush, const u8* buffer) const override;
    u64 GetSize() const override;
    bool SetSize(u64 size) const override;
-    bool Close() const override { return false; }
+    bool Close() const override {
-    void Flush() const override { }
+        return false;
+    }
+    void Flush() const override {
+    }
 private:
    std::shared_ptr<FileUtil::IOFile> romfs_file;
@@ -71,9 +79,15 @@ private:
 class IVFCDirectory : public DirectoryBackend {
 public:
-    bool Open() override { return false; }
+    bool Open() override {
-    u32 Read(const u32 count, Entry* entries) override { return 0; }
+        return false;
-    bool Close() const override { return false; }
+    }
+    u32 Read(const u32 count, Entry* entries) override {
+        return 0;
+    }
+    bool Close() const override {
+        return false;
+    }
 };
 } // namespace FileSys
diff --git a/src/core/gdbstub/gdbstub.cpp b/src/core/gdbstub/gdbstub.cpp
index 28d403158..6d709bd15 100644
--- a/src/core/gdbstub/gdbstub.cpp
+++ b/src/core/gdbstub/gdbstub.cpp
@@ -16,25 +16,25 @@
 #ifdef _MSC_VER
 #include <WinSock2.h>
-#include <ws2tcpip.h>
 #include <common/x64/abi.h>
 #include <io.h>
 #include <iphlpapi.h>
+#include <ws2tcpip.h>
 #define SHUT_RDWR 2
 #else
-#include <unistd.h>
+#include <netinet/in.h>
 #include <sys/select.h>
 #include <sys/socket.h>
 #include <sys/un.h>
-#include <netinet/in.h>
+#include <unistd.h>
 #endif
 #include "common/logging/log.h"
 #include "common/string_util.h"
-#include "core/core.h"
-#include "core/memory.h"
 #include "core/arm/arm_interface.h"
+#include "core/core.h"
 #include "core/gdbstub/gdbstub.h"
+#include "core/memory.h"
 const int GDB_BUFFER_SIZE = 10000;
@@ -64,7 +64,7 @@ const u32 FPSCR_REGISTER = 58;
 // GDB also wants the l character at the start
 // This XML defines what the registers are for this specific ARM device
 static const char* target_xml =
-R"(l<?xml version="1.0"?>
+    R"(l<?xml version="1.0"?>
 <!DOCTYPE target SYSTEM "gdb-target.dtd">
 <target version="1.0">
  <feature name="org.gnu.gdb.arm.core">
@@ -297,7 +297,8 @@ static void RemoveBreakpoint(BreakpointType type, PAddr addr) {
    auto bp = p.find(addr);
    if (bp != p.end()) {
-        LOG_DEBUG(Debug_GDBStub, "gdb: removed a breakpoint: %08x bytes at %08x of type %d\n", bp->second.len, bp->second.addr, type);
+        LOG_DEBUG(Debug_GDBStub, "gdb: removed a breakpoint: %08x bytes at %08x of type %d\n",
+                  bp->second.len, bp->second.addr, type);
        p.erase(addr);
    }
 }
@@ -342,7 +343,9 @@ bool CheckBreakpoint(PAddr addr, BreakpointType type) {
        }
        if (bp->second.active && (addr >= bp->second.addr && addr < bp->second.addr + len)) {
-            LOG_DEBUG(Debug_GDBStub, "Found breakpoint type %d @ %08x, range: %08x - %08x (%d bytes)\n", type, addr, bp->second.addr, bp->second.addr + len, len);
+            LOG_DEBUG(Debug_GDBStub,
+                      "Found breakpoint type %d @ %08x, range: %08x - %08x (%d bytes)\n", type,
+                      addr, bp->second.addr, bp->second.addr + len, len);
            return true;
        }
    }
@@ -408,12 +411,13 @@ static void HandleQuery() {
    const char* query = reinterpret_cast<const char*>(command_buffer + 1);
-    if (strcmp(query, "TStatus") == 0 ) {
+    if (strcmp(query, "TStatus") == 0) {
        SendReply("T0");
    } else if (strncmp(query, "Supported:", strlen("Supported:")) == 0) {
        // PacketSize needs to be large enough for target xml
        SendReply("PacketSize=800;qXfer:features:read+");
-    } else if (strncmp(query, "Xfer:features:read:target.xml:", strlen("Xfer:features:read:target.xml:")) == 0) {
+    } else if (strncmp(query, "Xfer:features:read:target.xml:",
+                       strlen("Xfer:features:read:target.xml:")) == 0) {
        SendReply(target_xml);
    } else {
        SendReply("");
@@ -422,10 +426,8 @@ static void HandleQuery() {
 /// Handle set thread command from gdb client.
 static void HandleSetThread() {
-    if (memcmp(command_buffer, "Hg0", 3) == 0 ||
+    if (memcmp(command_buffer, "Hg0", 3) == 0 || memcmp(command_buffer, "Hc-1", 4) == 0 ||
-        memcmp(command_buffer, "Hc-1", 4) == 0 ||
+        memcmp(command_buffer, "Hc0", 4) == 0 || memcmp(command_buffer, "Hc1", 4) == 0) {
-        memcmp(command_buffer, "Hc0", 4) == 0 ||
-        memcmp(command_buffer, "Hc1", 4) == 0) {
        return SendReply("OK");
    }
@@ -444,7 +446,9 @@ static void SendSignal(u32 signal) {
    latest_signal = signal;
-    std::string buffer = Common::StringFromFormat("T%02x%02x:%08x;%02x:%08x;", latest_signal, 15, htonl(Core::g_app_core->GetPC()), 13, htonl(Core::g_app_core->GetReg(13)));
+    std::string buffer = Common::StringFromFormat("T%02x%02x:%08x;%02x:%08x;", latest_signal, 15,
+                                                  htonl(Core::g_app_core->GetPC()), 13,
+                                                  htonl(Core::g_app_core->GetReg(13)));
    LOG_DEBUG(Debug_GDBStub, "Response: %s", buffer.c_str());
    SendReply(buffer.c_str());
 }
@@ -456,7 +460,7 @@ static void ReadCommand() {
    u8 c = ReadByte();
    if (c == '+') {
-        //ignore ack
+        // ignore ack
        return;
    } else if (c == 0x03) {
        LOG_INFO(Debug_GDBStub, "gdb: found break command\n");
@@ -483,8 +487,9 @@ static void ReadCommand() {
    u8 checksum_calculated = CalculateChecksum(command_buffer, command_length);
    if (checksum_received != checksum_calculated) {
-        LOG_ERROR(Debug_GDBStub, "gdb: invalid checksum: calculated %02x and read %02x for $%s# (length: %d)\n",
+        LOG_ERROR(Debug_GDBStub,
-            checksum_calculated, checksum_received, command_buffer, command_length);
+                  "gdb: invalid checksum: calculated %02x and read %02x for $%s# (length: %d)\n",
+                  checksum_calculated, checksum_received, command_buffer, command_length);
        command_length = 0;
@@ -534,7 +539,9 @@ static void ReadRegister() {
    } else if (id == CPSR_REGISTER) {
        IntToGdbHex(reply, Core::g_app_core->GetCPSR());
    } else if (id > CPSR_REGISTER && id < FPSCR_REGISTER) {
-        IntToGdbHex(reply, Core::g_app_core->GetVFPReg(id - CPSR_REGISTER - 1)); // VFP registers should start at 26, so one after CSPR_REGISTER
+        IntToGdbHex(reply, Core::g_app_core->GetVFPReg(
+                               id - CPSR_REGISTER -
+                               1)); // VFP registers should start at 26, so one after CSPR_REGISTER
    } else if (id == FPSCR_REGISTER) {
        IntToGdbHex(reply, Core::g_app_core->GetVFPSystemReg(VFP_FPSCR)); // Get FPSCR
        IntToGdbHex(reply + 8, 0);
@@ -617,7 +624,8 @@ static void WriteRegisters() {
            // Dummy FPA registers, ignore
            i += 2;
        } else if (reg > CPSR_REGISTER && reg < FPSCR_REGISTER) {
-            Core::g_app_core->SetVFPReg(reg - CPSR_REGISTER - 1, GdbHexToInt(buffer_ptr + i * CHAR_BIT));
+            Core::g_app_core->SetVFPReg(reg - CPSR_REGISTER - 1,
+                                        GdbHexToInt(buffer_ptr + i * CHAR_BIT));
            i++; // Skip padding
        } else if (reg == FPSCR_REGISTER) {
            Core::g_app_core->SetVFPSystemReg(VFP_FPSCR, GdbHexToInt(buffer_ptr + i * CHAR_BIT));
@@ -631,12 +639,13 @@ static void WriteRegisters() {
 static void ReadMemory() {
    static u8 reply[GDB_BUFFER_SIZE - 4];
-    auto start_offset = command_buffer+1;
+    auto start_offset = command_buffer + 1;
-    auto addr_pos = std::find(start_offset, command_buffer+command_length, ',');
+    auto addr_pos = std::find(start_offset, command_buffer + command_length, ',');
    PAddr addr = HexToInt(start_offset, static_cast<u32>(addr_pos - start_offset));
-    start_offset = addr_pos+1;
+    start_offset = addr_pos + 1;
-    u32 len = HexToInt(start_offset, static_cast<u32>((command_buffer + command_length) - start_offset));
+    u32 len =
+        HexToInt(start_offset, static_cast<u32>((command_buffer + command_length) - start_offset));
    LOG_DEBUG(Debug_GDBStub, "gdb: addr: %08x len: %08x\n", addr, len);
@@ -656,12 +665,12 @@ static void ReadMemory() {
 /// Modify location in memory with data received from the gdb client.
 static void WriteMemory() {
-    auto start_offset = command_buffer+1;
+    auto start_offset = command_buffer + 1;
-    auto addr_pos = std::find(start_offset, command_buffer+command_length, ',');
+    auto addr_pos = std::find(start_offset, command_buffer + command_length, ',');
    PAddr addr = HexToInt(start_offset, static_cast<u32>(addr_pos - start_offset));
-    start_offset = addr_pos+1;
+    start_offset = addr_pos + 1;
-    auto len_pos = std::find(start_offset, command_buffer+command_length, ':');
+    auto len_pos = std::find(start_offset, command_buffer + command_length, ':');
    u32 len = HexToInt(start_offset, static_cast<u32>(len_pos - start_offset));
    u8* dst = Memory::GetPointer(addr);
@@ -720,9 +729,10 @@ static bool CommitBreakpoint(BreakpointType type, PAddr addr, u32 len) {
    breakpoint.active = true;
    breakpoint.addr = addr;
    breakpoint.len = len;
-    p.insert({ addr, breakpoint });
+    p.insert({addr, breakpoint});
-    LOG_DEBUG(Debug_GDBStub, "gdb: added %d breakpoint: %08x bytes at %08x\n", type, breakpoint.len, breakpoint.addr);
+    LOG_DEBUG(Debug_GDBStub, "gdb: added %d breakpoint: %08x bytes at %08x\n", type, breakpoint.len,
+              breakpoint.addr);
    return true;
 }
@@ -750,12 +760,13 @@ static void AddBreakpoint() {
        return SendReply("E01");
    }
-    auto start_offset = command_buffer+3;
+    auto start_offset = command_buffer + 3;
-    auto addr_pos = std::find(start_offset, command_buffer+command_length, ',');
+    auto addr_pos = std::find(start_offset, command_buffer + command_length, ',');
    PAddr addr = HexToInt(start_offset, static_cast<u32>(addr_pos - start_offset));
-    start_offset = addr_pos+1;
+    start_offset = addr_pos + 1;
-    u32 len = HexToInt(start_offset, static_cast<u32>((command_buffer + command_length) - start_offset));
+    u32 len =
+        HexToInt(start_offset, static_cast<u32>((command_buffer + command_length) - start_offset));
    if (type == BreakpointType::Access) {
        // Access is made up of Read and Write types, so add both breakpoints
@@ -798,12 +809,13 @@ static void RemoveBreakpoint() {
        return SendReply("E01");
    }
-    auto start_offset = command_buffer+3;
+    auto start_offset = command_buffer + 3;
-    auto addr_pos = std::find(start_offset, command_buffer+command_length, ',');
+    auto addr_pos = std::find(start_offset, command_buffer + command_length, ',');
    PAddr addr = HexToInt(start_offset, static_cast<u32>(addr_pos - start_offset));
-    start_offset = addr_pos+1;
+    start_offset = addr_pos + 1;
-    u32 len = HexToInt(start_offset, static_cast<u32>((command_buffer + command_length) - start_offset));
+    u32 len =
+        HexToInt(start_offset, static_cast<u32>((command_buffer + command_length) - start_offset));
    if (type == BreakpointType::Access) {
        // Access is made up of Read and Write types, so add both breakpoints
@@ -896,8 +908,7 @@ void ToggleServer(bool status) {
        if (!IsConnected() && Core::g_sys_core != nullptr) {
            Init();
        }
-    }
+    } else {
-    else {
        // Stop server
        if (IsConnected()) {
            Shutdown();
@@ -943,7 +954,8 @@ static void Init(u16 port) {
    // Set socket to SO_REUSEADDR so it can always bind on the same port
    int reuse_enabled = 1;
-    if (setsockopt(tmpsock, SOL_SOCKET, SO_REUSEADDR, (const char*)&reuse_enabled, sizeof(reuse_enabled)) < 0) {
+    if (setsockopt(tmpsock, SOL_SOCKET, SO_REUSEADDR, (const char*)&reuse_enabled,
+                   sizeof(reuse_enabled)) < 0) {
        LOG_ERROR(Debug_GDBStub, "Failed to set gdb socket option");
    }
@@ -964,13 +976,13 @@ static void Init(u16 port) {
    socklen_t client_addrlen = sizeof(saddr_client);
    gdbserver_socket = accept(tmpsock, client_addr, &client_addrlen);
    if (gdbserver_socket < 0) {
-        // In the case that we couldn't start the server for whatever reason, just start CPU execution like normal.
+        // In the case that we couldn't start the server for whatever reason, just start CPU
+        // execution like normal.
        halt_loop = false;
        step_loop = false;
        LOG_ERROR(Debug_GDBStub, "Failed to accept gdb client");
-    }
+    } else {
-    else {
        LOG_INFO(Debug_GDBStub, "Client connected.\n");
        saddr_client.sin_addr.s_addr = ntohl(saddr_client.sin_addr.s_addr);
    }
@@ -1018,5 +1030,4 @@ bool GetCpuStepFlag() {
 void SetCpuStepFlag(bool is_step) {
    step_loop = is_step;
 }
 };
diff --git a/src/core/gdbstub/gdbstub.h b/src/core/gdbstub/gdbstub.h
index 4f21da23b..fddc27a3e 100644
--- a/src/core/gdbstub/gdbstub.h
+++ b/src/core/gdbstub/gdbstub.h
@@ -13,11 +13,11 @@ namespace GDBStub {
 /// Breakpoint Method
 enum class BreakpointType {
-    None,     ///< None
+    None,    ///< None
-    Execute,  ///< Execution Breakpoint
+    Execute, ///< Execution Breakpoint
-    Read,     ///< Read Breakpoint
+    Read,    ///< Read Breakpoint
-    Write,    ///< Write Breakpoint
+    Write,   ///< Write Breakpoint
-    Access    ///< Access (R/W) Breakpoint
+    Access   ///< Access (R/W) Breakpoint
 };
 struct BreakpointAddress {
@@ -25,7 +25,8 @@ struct BreakpointAddress {
    BreakpointType type;
 };
-/// If set to false, the server will never be started and no gdbstub-related functions will be executed.
+/// If set to false, the server will never be started and no gdbstub-related functions will be
+/// executed.
 extern std::atomic<bool> g_server_enabled;
 /**
@@ -92,5 +93,4 @@ bool GetCpuStepFlag();
 * @param is_step
 */
 void SetCpuStepFlag(bool is_step);
 }
diff --git a/src/core/hle/applets/applet.cpp b/src/core/hle/applets/applet.cpp
index ccf35fa07..2b4bd939d 100644
--- a/src/core/hle/applets/applet.cpp
+++ b/src/core/hle/applets/applet.cpp
@@ -23,23 +23,24 @@
 // Specializes std::hash for AppletId, so that we can use it in std::unordered_map.
 // Workaround for libstdc++ bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60970
 namespace std {
-    template <>
+template <>
-    struct hash<Service::APT::AppletId> {
+struct hash<Service::APT::AppletId> {
-        typedef Service::APT::AppletId argument_type;
+    typedef Service::APT::AppletId argument_type;
-        typedef std::size_t result_type;
+    typedef std::size_t result_type;
-        result_type operator()(const argument_type& id_code) const {
+    result_type operator()(const argument_type& id_code) const {
-            typedef std::underlying_type<argument_type>::type Type;
+        typedef std::underlying_type<argument_type>::type Type;
-            return std::hash<Type>()(static_cast<Type>(id_code));
+        return std::hash<Type>()(static_cast<Type>(id_code));
-        }
+    }
-    };
+};
 }
 namespace HLE {
 namespace Applets {
 static std::unordered_map<Service::APT::AppletId, std::shared_ptr<Applet>> applets;
-static u32 applet_update_event = -1; ///< The CoreTiming event identifier for the Applet update callback.
+static u32 applet_update_event =
+    -1; ///< The CoreTiming event identifier for the Applet update callback.
 /// The interval at which the Applet update callback will be called, 16.6ms
 static const u64 applet_update_interval_us = 16666;
@@ -60,7 +61,8 @@ ResultCode Applet::Create(Service::APT::AppletId id) {
    default:
        LOG_ERROR(Service_APT, "Could not create applet %u", id);
        // TODO(Subv): Find the right error code
-        return ResultCode(ErrorDescription::NotFound, ErrorModule::Applet, ErrorSummary::NotSupported, ErrorLevel::Permanent);
+        return ResultCode(ErrorDescription::NotFound, ErrorModule::Applet,
+                          ErrorSummary::NotSupported, ErrorLevel::Permanent);
    }
    return RESULT_SUCCESS;
@@ -84,7 +86,7 @@ static void AppletUpdateEvent(u64 applet_id, int cycles_late) {
    // If the applet is still running after the last update, reschedule the event
    if (applet->IsRunning()) {
        CoreTiming::ScheduleEvent(usToCycles(applet_update_interval_us) - cycles_late,
-            applet_update_event, applet_id);
+                                  applet_update_event, applet_id);
    } else {
        // Otherwise the applet has terminated, in which case we should clean it up
        applets[id] = nullptr;
@@ -96,7 +98,8 @@ ResultCode Applet::Start(const Service::APT::AppletStartupParameter& parameter)
    if (result.IsError())
        return result;
    // Schedule the update event
-    CoreTiming::ScheduleEvent(usToCycles(applet_update_interval_us), applet_update_event, static_cast<u64>(id));
+    CoreTiming::ScheduleEvent(usToCycles(applet_update_interval_us), applet_update_event,
+                              static_cast<u64>(id));
    return result;
 }
@@ -116,6 +119,5 @@ void Init() {
 void Shutdown() {
    CoreTiming::RemoveEvent(applet_update_event);
 }
 }
 } // namespace
diff --git a/src/core/hle/applets/applet.h b/src/core/hle/applets/applet.h
index 754c6f7db..350a58594 100644
--- a/src/core/hle/applets/applet.h
+++ b/src/core/hle/applets/applet.h
@@ -14,8 +14,10 @@ namespace Applets {
 class Applet {
 public:
-    virtual ~Applet() { }
+    virtual ~Applet() {
-    Applet(Service::APT::AppletId id) : id(id) { }
+    }
+    Applet(Service::APT::AppletId id) : id(id) {
+    }
    /**
     * Creates an instance of the Applet subclass identified by the parameter.
@@ -64,7 +66,7 @@ protected:
     */
    virtual ResultCode StartImpl(const Service::APT::AppletStartupParameter& parameter) = 0;
-    Service::APT::AppletId id; ///< Id of this Applet
+    Service::APT::AppletId id;                    ///< Id of this Applet
    std::shared_ptr<std::vector<u8>> heap_memory; ///< Heap memory for this Applet
 };
@@ -76,6 +78,5 @@ void Init();
 /// Shuts down the HLE applets
 void Shutdown();
 }
 } // namespace
diff --git a/src/core/hle/applets/erreula.cpp b/src/core/hle/applets/erreula.cpp
index 92a4b2323..144d6a152 100644
--- a/src/core/hle/applets/erreula.cpp
+++ b/src/core/hle/applets/erreula.cpp
@@ -18,7 +18,8 @@ ResultCode ErrEula::ReceiveParameter(const Service::APT::MessageParameter& param
        return ResultCode(-1);
    }
-    // The LibAppJustStarted message contains a buffer with the size of the framebuffer shared memory.
+    // The LibAppJustStarted message contains a buffer with the size of the framebuffer shared
+    // memory.
    // Create the SharedMemory that will hold the framebuffer data
    Service::APT::CaptureBufferInfo capture_info;
    ASSERT(sizeof(capture_info) == parameter.buffer.size());
@@ -30,9 +31,9 @@ ResultCode ErrEula::ReceiveParameter(const Service::APT::MessageParameter& param
    // Allocate a heap block of the required size for this applet.
    heap_memory = std::make_shared<std::vector<u8>>(capture_info.size);
    // Create a SharedMemory that directly points to this heap block.
-    framebuffer_memory = Kernel::SharedMemory::CreateForApplet(heap_memory, 0, heap_memory->size(),
+    framebuffer_memory = Kernel::SharedMemory::CreateForApplet(
-                                                               MemoryPermission::ReadWrite, MemoryPermission::ReadWrite,
+        heap_memory, 0, heap_memory->size(), MemoryPermission::ReadWrite,
-                                                               "ErrEula Memory");
+        MemoryPermission::ReadWrite, "ErrEula Memory");
    // Send the response message with the newly created SharedMemory
    Service::APT::MessageParameter result;
@@ -49,7 +50,8 @@ ResultCode ErrEula::ReceiveParameter(const Service::APT::MessageParameter& param
 ResultCode ErrEula::StartImpl(const Service::APT::AppletStartupParameter& parameter) {
    started = true;
-    // TODO(Subv): Set the expected fields in the response buffer before resending it to the application.
+    // TODO(Subv): Set the expected fields in the response buffer before resending it to the
+    // application.
    // TODO(Subv): Reverse the parameter format for the ErrEula applet
    // Let the application know that we're closing
diff --git a/src/core/hle/applets/erreula.h b/src/core/hle/applets/erreula.h
index 9fe72ae07..dd1d1aee4 100644
--- a/src/core/hle/applets/erreula.h
+++ b/src/core/hle/applets/erreula.h
@@ -12,16 +12,21 @@ namespace Applets {
 class ErrEula final : public Applet {
 public:
-    explicit ErrEula(Service::APT::AppletId id): Applet(id) { }
+    explicit ErrEula(Service::APT::AppletId id) : Applet(id) {
+    }
    ResultCode ReceiveParameter(const Service::APT::MessageParameter& parameter) override;
    ResultCode StartImpl(const Service::APT::AppletStartupParameter& parameter) override;
    void Update() override;
-    bool IsRunning() const override { return started; }
+    bool IsRunning() const override {
+        return started;
+    }
    /// This SharedMemory will be created when we receive the LibAppJustStarted message.
-    /// It holds the framebuffer info retrieved by the application with GSPGPU::ImportDisplayCaptureInfo
+    /// It holds the framebuffer info retrieved by the application with
+    /// GSPGPU::ImportDisplayCaptureInfo
    Kernel::SharedPtr<Kernel::SharedMemory> framebuffer_memory;
 private:
    /// Whether this applet is currently running instead of the host application or not.
    bool started = false;
diff --git a/src/core/hle/applets/mii_selector.cpp b/src/core/hle/applets/mii_selector.cpp
index 77f01d208..19e603eda 100644
--- a/src/core/hle/applets/mii_selector.cpp
+++ b/src/core/hle/applets/mii_selector.cpp
@@ -29,7 +29,8 @@ ResultCode MiiSelector::ReceiveParameter(const Service::APT::MessageParameter& p
        return ResultCode(-1);
    }
-    // The LibAppJustStarted message contains a buffer with the size of the framebuffer shared memory.
+    // The LibAppJustStarted message contains a buffer with the size of the framebuffer shared
+    // memory.
    // Create the SharedMemory that will hold the framebuffer data
    Service::APT::CaptureBufferInfo capture_info;
    ASSERT(sizeof(capture_info) == parameter.buffer.size());
@@ -40,9 +41,9 @@ ResultCode MiiSelector::ReceiveParameter(const Service::APT::MessageParameter& p
    // Allocate a heap block of the required size for this applet.
    heap_memory = std::make_shared<std::vector<u8>>(capture_info.size);
    // Create a SharedMemory that directly points to this heap block.
-    framebuffer_memory = Kernel::SharedMemory::CreateForApplet(heap_memory, 0, heap_memory->size(),
+    framebuffer_memory = Kernel::SharedMemory::CreateForApplet(
-                                                               MemoryPermission::ReadWrite, MemoryPermission::ReadWrite,
+        heap_memory, 0, heap_memory->size(), MemoryPermission::ReadWrite,
-                                                               "MiiSelector Memory");
+        MemoryPermission::ReadWrite, "MiiSelector Memory");
    // Send the response message with the newly created SharedMemory
    Service::APT::MessageParameter result;
@@ -59,12 +60,14 @@ ResultCode MiiSelector::ReceiveParameter(const Service::APT::MessageParameter& p
 ResultCode MiiSelector::StartImpl(const Service::APT::AppletStartupParameter& parameter) {
    started = true;
-    // TODO(Subv): Set the expected fields in the response buffer before resending it to the application.
+    // TODO(Subv): Set the expected fields in the response buffer before resending it to the
+    // application.
    // TODO(Subv): Reverse the parameter format for the Mii Selector
    memcpy(&config, parameter.buffer.data(), parameter.buffer.size());
-    // TODO(Subv): Find more about this structure, result code 0 is enough to let most games continue.
+    // TODO(Subv): Find more about this structure, result code 0 is enough to let most games
+    // continue.
    MiiResult result;
    memset(&result, 0, sizeof(result));
    result.result_code = 0;
@@ -84,6 +87,5 @@ ResultCode MiiSelector::StartImpl(const Service::APT::AppletStartupParameter& pa
 void MiiSelector::Update() {
 }
 }
 } // namespace
diff --git a/src/core/hle/applets/mii_selector.h b/src/core/hle/applets/mii_selector.h
index 24e8e721d..dba4abc8d 100644
--- a/src/core/hle/applets/mii_selector.h
+++ b/src/core/hle/applets/mii_selector.h
@@ -4,8 +4,8 @@
 #pragma once
-#include "common/common_types.h"
 #include "common/common_funcs.h"
+#include "common/common_types.h"
 #include "core/hle/applets/applet.h"
 #include "core/hle/kernel/kernel.h"
@@ -17,28 +17,30 @@ namespace HLE {
 namespace Applets {
 struct MiiConfig {
-    u8  unk_000;
+    u8 unk_000;
-    u8  unk_001;
+    u8 unk_001;
-    u8  unk_002;
+    u8 unk_002;
-    u8  unk_003;
+    u8 unk_003;
-    u8  unk_004;
+    u8 unk_004;
    INSERT_PADDING_BYTES(3);
    u16 unk_008;
    INSERT_PADDING_BYTES(0x82);
-    u8  unk_08C;
+    u8 unk_08C;
    INSERT_PADDING_BYTES(3);
    u16 unk_090;
    INSERT_PADDING_BYTES(2);
    u32 unk_094;
    u16 unk_098;
-    u8  unk_09A[0x64];
+    u8 unk_09A[0x64];
-    u8  unk_0FE;
+    u8 unk_0FE;
-    u8  unk_0FF;
+    u8 unk_0FF;
    u32 unk_100;
 };
 static_assert(sizeof(MiiConfig) == 0x104, "MiiConfig structure has incorrect size");
-#define ASSERT_REG_POSITION(field_name, position) static_assert(offsetof(MiiConfig, field_name) == position, "Field "#field_name" has invalid position")
+#define ASSERT_REG_POSITION(field_name, position)                                                  \
+    static_assert(offsetof(MiiConfig, field_name) == position,                                     \
+                  "Field " #field_name " has invalid position")
 ASSERT_REG_POSITION(unk_008, 0x08);
 ASSERT_REG_POSITION(unk_08C, 0x8C);
 ASSERT_REG_POSITION(unk_090, 0x90);
@@ -55,22 +57,28 @@ struct MiiResult {
    INSERT_PADDING_BYTES(2);
 };
 static_assert(sizeof(MiiResult) == 0x84, "MiiResult structure has incorrect size");
-#define ASSERT_REG_POSITION(field_name, position) static_assert(offsetof(MiiResult, field_name) == position, "Field "#field_name" has invalid position")
+#define ASSERT_REG_POSITION(field_name, position)                                                  \
+    static_assert(offsetof(MiiResult, field_name) == position,                                     \
+                  "Field " #field_name " has invalid position")
 ASSERT_REG_POSITION(unk_0C, 0x0C);
 ASSERT_REG_POSITION(unk_6C, 0x6C);
 #undef ASSERT_REG_POSITION
 class MiiSelector final : public Applet {
 public:
-    MiiSelector(Service::APT::AppletId id) : Applet(id), started(false) { }
+    MiiSelector(Service::APT::AppletId id) : Applet(id), started(false) {
+    }
    ResultCode ReceiveParameter(const Service::APT::MessageParameter& parameter) override;
    ResultCode StartImpl(const Service::APT::AppletStartupParameter& parameter) override;
    void Update() override;
-    bool IsRunning() const override { return started; }
+    bool IsRunning() const override {
+        return started;
+    }
    /// This SharedMemory will be created when we receive the LibAppJustStarted message.
-    /// It holds the framebuffer info retrieved by the application with GSPGPU::ImportDisplayCaptureInfo
+    /// It holds the framebuffer info retrieved by the application with
+    /// GSPGPU::ImportDisplayCaptureInfo
    Kernel::SharedPtr<Kernel::SharedMemory> framebuffer_memory;
    /// Whether this applet is currently running instead of the host application or not.
@@ -78,6 +86,5 @@ public:
    MiiConfig config;
 };
 }
 } // namespace
diff --git a/src/core/hle/applets/swkbd.cpp b/src/core/hle/applets/swkbd.cpp
index d87bf3d57..cf2775968 100644
--- a/src/core/hle/applets/swkbd.cpp
+++ b/src/core/hle/applets/swkbd.cpp
@@ -12,9 +12,9 @@
 #include "core/hle/applets/swkbd.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/shared_memory.h"
-#include "core/hle/service/hid/hid.h"
-#include "core/hle/service/gsp_gpu.h"
 #include "core/hle/result.h"
+#include "core/hle/service/gsp_gpu.h"
+#include "core/hle/service/hid/hid.h"
 #include "core/memory.h"
 #include "video_core/video_core.h"
@@ -32,7 +32,8 @@ ResultCode SoftwareKeyboard::ReceiveParameter(Service::APT::MessageParameter con
        return ResultCode(-1);
    }
-    // The LibAppJustStarted message contains a buffer with the size of the framebuffer shared memory.
+    // The LibAppJustStarted message contains a buffer with the size of the framebuffer shared
+    // memory.
    // Create the SharedMemory that will hold the framebuffer data
    Service::APT::CaptureBufferInfo capture_info;
    ASSERT(sizeof(capture_info) == parameter.buffer.size());
@@ -43,9 +44,9 @@ ResultCode SoftwareKeyboard::ReceiveParameter(Service::APT::MessageParameter con
    // Allocate a heap block of the required size for this applet.
    heap_memory = std::make_shared<std::vector<u8>>(capture_info.size);
    // Create a SharedMemory that directly points to this heap block.
-    framebuffer_memory = Kernel::SharedMemory::CreateForApplet(heap_memory, 0, heap_memory->size(),
+    framebuffer_memory = Kernel::SharedMemory::CreateForApplet(
-                                                               MemoryPermission::ReadWrite, MemoryPermission::ReadWrite,
+        heap_memory, 0, heap_memory->size(), MemoryPermission::ReadWrite,
-                                                               "SoftwareKeyboard Memory");
+        MemoryPermission::ReadWrite, "SoftwareKeyboard Memory");
    // Send the response message with the newly created SharedMemory
    Service::APT::MessageParameter result;
@@ -60,10 +61,12 @@ ResultCode SoftwareKeyboard::ReceiveParameter(Service::APT::MessageParameter con
 }
 ResultCode SoftwareKeyboard::StartImpl(Service::APT::AppletStartupParameter const& parameter) {
-    ASSERT_MSG(parameter.buffer.size() == sizeof(config), "The size of the parameter (SoftwareKeyboardConfig) is wrong");
+    ASSERT_MSG(parameter.buffer.size() == sizeof(config),
+               "The size of the parameter (SoftwareKeyboardConfig) is wrong");
    memcpy(&config, parameter.buffer.data(), parameter.buffer.size());
-    text_memory = boost::static_pointer_cast<Kernel::SharedMemory, Kernel::Object>(parameter.object);
+    text_memory =
+        boost::static_pointer_cast<Kernel::SharedMemory, Kernel::Object>(parameter.object);
    // TODO(Subv): Verify if this is the correct behavior
    memset(text_memory->GetPointer(), 0, text_memory->size);
@@ -115,6 +118,5 @@ void SoftwareKeyboard::Finalize() {
    started = false;
 }
 }
 } // namespace
diff --git a/src/core/hle/applets/swkbd.h b/src/core/hle/applets/swkbd.h
index cf26a8fb7..f50673912 100644
--- a/src/core/hle/applets/swkbd.h
+++ b/src/core/hle/applets/swkbd.h
@@ -4,8 +4,8 @@
 #pragma once
-#include "common/common_types.h"
 #include "common/common_funcs.h"
+#include "common/common_types.h"
 #include "core/hle/applets/applet.h"
 #include "core/hle/kernel/kernel.h"
@@ -53,12 +53,15 @@ static_assert(sizeof(SoftwareKeyboardConfig) == 0x400, "Software Keyboard Config
 class SoftwareKeyboard final : public Applet {
 public:
-    SoftwareKeyboard(Service::APT::AppletId id) : Applet(id), started(false) { }
+    SoftwareKeyboard(Service::APT::AppletId id) : Applet(id), started(false) {
+    }
    ResultCode ReceiveParameter(const Service::APT::MessageParameter& parameter) override;
    ResultCode StartImpl(const Service::APT::AppletStartupParameter& parameter) override;
    void Update() override;
-    bool IsRunning() const override { return started; }
+    bool IsRunning() const override {
+        return started;
+    }
    /**
     * Draws a keyboard to the current bottom screen framebuffer.
@@ -72,7 +75,8 @@ public:
    void Finalize();
    /// This SharedMemory will be created when we receive the LibAppJustStarted message.
-    /// It holds the framebuffer info retrieved by the application with GSPGPU::ImportDisplayCaptureInfo
+    /// It holds the framebuffer info retrieved by the application with
+    /// GSPGPU::ImportDisplayCaptureInfo
    Kernel::SharedPtr<Kernel::SharedMemory> framebuffer_memory;
    /// SharedMemory where the output text will be stored
@@ -84,6 +88,5 @@ public:
    /// Whether this applet is currently running instead of the host application or not.
    bool started;
 };
 }
 } // namespace
diff --git a/src/core/hle/config_mem.cpp b/src/core/hle/config_mem.cpp
index ccd73cfcb..00efc179e 100644
--- a/src/core/hle/config_mem.cpp
+++ b/src/core/hle/config_mem.cpp
@@ -2,8 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
-#include <cstring>
 #include "core/hle/config_mem.h"
+#include <cstring>
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/config_mem.h b/src/core/hle/config_mem.h
index 24a1254f2..50664dac6 100644
--- a/src/core/hle/config_mem.h
+++ b/src/core/hle/config_mem.h
@@ -20,16 +20,16 @@
 namespace ConfigMem {
 struct ConfigMemDef {
-    u8     kernel_unk;                   // 0
+    u8 kernel_unk;                       // 0
-    u8     kernel_version_rev;           // 1
+    u8 kernel_version_rev;               // 1
-    u8     kernel_version_min;           // 2
+    u8 kernel_version_min;               // 2
-    u8     kernel_version_maj;           // 3
+    u8 kernel_version_maj;               // 3
    u32_le update_flag;                  // 4
    u64_le ns_tid;                       // 8
    u32_le sys_core_ver;                 // 10
-    u8     unit_info;                    // 14
+    u8 unit_info;                        // 14
-    u8     boot_firm;                    // 15
+    u8 boot_firm;                        // 15
-    u8     prev_firm;                    // 16
+    u8 prev_firm;                        // 16
    INSERT_PADDING_BYTES(0x1);           // 17
    u32_le ctr_sdk_ver;                  // 18
    INSERT_PADDING_BYTES(0x30 - 0x1C);   // 1C
@@ -39,15 +39,16 @@ struct ConfigMemDef {
    u32_le sys_mem_alloc;                // 44
    u32_le base_mem_alloc;               // 48
    INSERT_PADDING_BYTES(0x60 - 0x4C);   // 4C
-    u8     firm_unk;                     // 60
+    u8 firm_unk;                         // 60
-    u8     firm_version_rev;             // 61
+    u8 firm_version_rev;                 // 61
-    u8     firm_version_min;             // 62
+    u8 firm_version_min;                 // 62
-    u8     firm_version_maj;             // 63
+    u8 firm_version_maj;                 // 63
    u32_le firm_sys_core_ver;            // 64
    u32_le firm_ctr_sdk_ver;             // 68
    INSERT_PADDING_BYTES(0x1000 - 0x6C); // 6C
 };
-static_assert(sizeof(ConfigMemDef) == Memory::CONFIG_MEMORY_SIZE, "Config Memory structure size is wrong");
+static_assert(sizeof(ConfigMemDef) == Memory::CONFIG_MEMORY_SIZE,
+              "Config Memory structure size is wrong");
 extern ConfigMemDef config_mem;
diff --git a/src/core/hle/function_wrappers.h b/src/core/hle/function_wrappers.h
index 8839ce482..d5d989c29 100644
--- a/src/core/hle/function_wrappers.h
+++ b/src/core/hle/function_wrappers.h
@@ -7,14 +7,14 @@
 #include "common/common_types.h"
 #include "core/arm/arm_interface.h"
-#include "core/memory.h"
 #include "core/hle/hle.h"
 #include "core/hle/result.h"
 #include "core/hle/svc.h"
+#include "core/memory.h"
 namespace HLE {
-#define PARAM(n)    Core::g_app_core->GetReg(n)
+#define PARAM(n) Core::g_app_core->GetReg(n)
 /// An invalid result code that is meant to be overwritten when a thread resumes from waiting
 static const ResultCode RESULT_INVALID(0xDEADC0DE);
@@ -40,28 +40,33 @@ static inline void FuncReturn64(u64 res) {
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Function wrappers that return type ResultCode
-template<ResultCode func(u32, u32, u32, u32)> void Wrap() {
+template <ResultCode func(u32, u32, u32, u32)>
+void Wrap() {
    FuncReturn(func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)).raw);
 }
-template<ResultCode func(u32*, u32, u32, u32, u32, u32)> void Wrap(){
+template <ResultCode func(u32*, u32, u32, u32, u32, u32)>
+void Wrap() {
    u32 param_1 = 0;
    u32 retval = func(&param_1, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)).raw;
    Core::g_app_core->SetReg(1, param_1);
    FuncReturn(retval);
 }
-template<ResultCode func(u32*, s32, u32, u32, u32, s32)> void Wrap() {
+template <ResultCode func(u32*, s32, u32, u32, u32, s32)>
+void Wrap() {
    u32 param_1 = 0;
    u32 retval = func(&param_1, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)).raw;
    Core::g_app_core->SetReg(1, param_1);
    FuncReturn(retval);
 }
-template<ResultCode func(s32*, u32*, s32, bool, s64)> void Wrap() {
+template <ResultCode func(s32*, u32*, s32, bool, s64)>
+void Wrap() {
    s32 param_1 = 0;
    s32 retval = func(&param_1, (Handle*)Memory::GetPointer(PARAM(1)), (s32)PARAM(2),
-        (PARAM(3) != 0), (((s64)PARAM(4) << 32) | PARAM(0))).raw;
+                      (PARAM(3) != 0), (((s64)PARAM(4) << 32) | PARAM(0)))
+                     .raw;
    if (retval != RESULT_INVALID.raw) {
        Core::g_app_core->SetReg(1, (u32)param_1);
@@ -69,18 +74,22 @@ template<ResultCode func(s32*, u32*, s32, bool, s64)> void Wrap() {
    }
 }
-template<ResultCode func(u32, u32, u32, u32, s64)> void Wrap() {
+template <ResultCode func(u32, u32, u32, u32, s64)>
-    FuncReturn(func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), (((s64)PARAM(5) << 32) | PARAM(4))).raw);
+void Wrap() {
+    FuncReturn(
+        func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), (((s64)PARAM(5) << 32) | PARAM(4))).raw);
 }
-template<ResultCode func(u32*)> void Wrap(){
+template <ResultCode func(u32*)>
+void Wrap() {
    u32 param_1 = 0;
    u32 retval = func(&param_1).raw;
    Core::g_app_core->SetReg(1, param_1);
    FuncReturn(retval);
 }
-template<ResultCode func(u32, s64)> void Wrap() {
+template <ResultCode func(u32, s64)>
+void Wrap() {
    s32 retval = func(PARAM(0), (((s64)PARAM(3) << 32) | PARAM(2))).raw;
    if (retval != RESULT_INVALID.raw) {
@@ -88,7 +97,8 @@ template<ResultCode func(u32, s64)> void Wrap() {
    }
 }
-template<ResultCode func(MemoryInfo*, PageInfo*, u32)> void Wrap() {
+template <ResultCode func(MemoryInfo*, PageInfo*, u32)>
+void Wrap() {
    MemoryInfo memory_info = {};
    PageInfo page_info = {};
    u32 retval = func(&memory_info, &page_info, PARAM(2)).raw;
@@ -100,7 +110,8 @@ template<ResultCode func(MemoryInfo*, PageInfo*, u32)> void Wrap() {
    FuncReturn(retval);
 }
-template<ResultCode func(MemoryInfo*, PageInfo*, Handle, u32)> void Wrap() {
+template <ResultCode func(MemoryInfo*, PageInfo*, Handle, u32)>
+void Wrap() {
    MemoryInfo memory_info = {};
    PageInfo page_info = {};
    u32 retval = func(&memory_info, &page_info, PARAM(2), PARAM(3)).raw;
@@ -112,55 +123,65 @@ template<ResultCode func(MemoryInfo*, PageInfo*, Handle, u32)> void Wrap() {
    FuncReturn(retval);
 }
-template<ResultCode func(s32*, u32)> void Wrap(){
+template <ResultCode func(s32*, u32)>
+void Wrap() {
    s32 param_1 = 0;
    u32 retval = func(&param_1, PARAM(1)).raw;
    Core::g_app_core->SetReg(1, param_1);
    FuncReturn(retval);
 }
-template<ResultCode func(u32, s32)> void Wrap() {
+template <ResultCode func(u32, s32)>
+void Wrap() {
    FuncReturn(func(PARAM(0), (s32)PARAM(1)).raw);
 }
-template<ResultCode func(u32*, u32)> void Wrap(){
+template <ResultCode func(u32*, u32)>
+void Wrap() {
    u32 param_1 = 0;
    u32 retval = func(&param_1, PARAM(1)).raw;
    Core::g_app_core->SetReg(1, param_1);
    FuncReturn(retval);
 }
-template<ResultCode func(u32)> void Wrap() {
+template <ResultCode func(u32)>
+void Wrap() {
    FuncReturn(func(PARAM(0)).raw);
 }
-template<ResultCode func(s64*, u32, u32*, u32)> void Wrap(){
+template <ResultCode func(s64*, u32, u32*, u32)>
-    FuncReturn(func((s64*)Memory::GetPointer(PARAM(0)), PARAM(1), (u32*)Memory::GetPointer(PARAM(2)),
+void Wrap() {
-        (s32)PARAM(3)).raw);
+    FuncReturn(func((s64*)Memory::GetPointer(PARAM(0)), PARAM(1),
+                    (u32*)Memory::GetPointer(PARAM(2)), (s32)PARAM(3))
+                   .raw);
 }
-template<ResultCode func(u32*, const char*)> void Wrap() {
+template <ResultCode func(u32*, const char*)>
+void Wrap() {
    u32 param_1 = 0;
    u32 retval = func(&param_1, (char*)Memory::GetPointer(PARAM(1))).raw;
    Core::g_app_core->SetReg(1, param_1);
    FuncReturn(retval);
 }
-template<ResultCode func(u32*, s32, s32)> void Wrap() {
+template <ResultCode func(u32*, s32, s32)>
+void Wrap() {
    u32 param_1 = 0;
    u32 retval = func(&param_1, PARAM(1), PARAM(2)).raw;
    Core::g_app_core->SetReg(1, param_1);
    FuncReturn(retval);
 }
-template<ResultCode func(s32*, u32, s32)> void Wrap() {
+template <ResultCode func(s32*, u32, s32)>
+void Wrap() {
    s32 param_1 = 0;
    u32 retval = func(&param_1, PARAM(1), PARAM(2)).raw;
    Core::g_app_core->SetReg(1, param_1);
    FuncReturn(retval);
 }
-template<ResultCode func(s64*, u32, s32)> void Wrap() {
+template <ResultCode func(s64*, u32, s32)>
+void Wrap() {
    s64 param_1 = 0;
    u32 retval = func(&param_1, PARAM(1), PARAM(2)).raw;
    Core::g_app_core->SetReg(1, (u32)param_1);
@@ -168,7 +189,8 @@ template<ResultCode func(s64*, u32, s32)> void Wrap() {
    FuncReturn(retval);
 }
-template<ResultCode func(u32*, u32, u32, u32, u32)> void Wrap() {
+template <ResultCode func(u32*, u32, u32, u32, u32)>
+void Wrap() {
    u32 param_1 = 0;
    // The last parameter is passed in R0 instead of R4
    u32 retval = func(&param_1, PARAM(1), PARAM(2), PARAM(3), PARAM(0)).raw;
@@ -176,13 +198,15 @@ template<ResultCode func(u32*, u32, u32, u32, u32)> void Wrap() {
    FuncReturn(retval);
 }
-template<ResultCode func(u32, s64, s64)> void Wrap() {
+template <ResultCode func(u32, s64, s64)>
+void Wrap() {
    s64 param1 = ((u64)PARAM(3) << 32) | PARAM(2);
    s64 param2 = ((u64)PARAM(4) << 32) | PARAM(1);
    FuncReturn(func(PARAM(0), param1, param2).raw);
 }
-template<ResultCode func(s64*, Handle, u32)> void Wrap() {
+template <ResultCode func(s64*, Handle, u32)>
+void Wrap() {
    s64 param_1 = 0;
    u32 retval = func(&param_1, PARAM(1), PARAM(2)).raw;
    Core::g_app_core->SetReg(1, (u32)param_1);
@@ -190,14 +214,18 @@ template<ResultCode func(s64*, Handle, u32)> void Wrap() {
    FuncReturn(retval);
 }
-template<ResultCode func(Handle, u32)> void Wrap() {
+template <ResultCode func(Handle, u32)>
+void Wrap() {
    FuncReturn(func(PARAM(0), PARAM(1)).raw);
 }
-template<ResultCode func(Handle*, Handle*, const char*, u32)> void Wrap() {
+template <ResultCode func(Handle*, Handle*, const char*, u32)>
+void Wrap() {
    Handle param_1 = 0;
    Handle param_2 = 0;
-    u32 retval = func(&param_1, &param_2, reinterpret_cast<const char*>(Memory::GetPointer(PARAM(2))), PARAM(3)).raw;
+    u32 retval = func(&param_1, &param_2,
+                      reinterpret_cast<const char*>(Memory::GetPointer(PARAM(2))), PARAM(3))
+                     .raw;
    // The first out parameter is moved into R2 and the second is moved into R1.
    Core::g_app_core->SetReg(1, param_2);
    Core::g_app_core->SetReg(2, param_1);
@@ -207,29 +235,34 @@ template<ResultCode func(Handle*, Handle*, const char*, u32)> void Wrap() {
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Function wrappers that return type u32
-template<u32 func()> void Wrap() {
+template <u32 func()>
+void Wrap() {
    FuncReturn(func());
 }
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Function wrappers that return type s64
-template<s64 func()> void Wrap() {
+template <s64 func()>
+void Wrap() {
    FuncReturn64(func());
 }
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 /// Function wrappers that return type void
-template<void func(s64)> void Wrap() {
+template <void func(s64)>
+void Wrap() {
    func(((s64)PARAM(1) << 32) | PARAM(0));
 }
-template<void func(const char*)> void Wrap() {
+template <void func(const char*)>
+void Wrap() {
    func((char*)Memory::GetPointer(PARAM(0)));
 }
-template<void func(u8)> void Wrap() {
+template <void func(u8)>
+void Wrap() {
    func((u8)PARAM(0));
 }
diff --git a/src/core/hle/hle.cpp b/src/core/hle/hle.cpp
index 5c5373517..480a73e80 100644
--- a/src/core/hle/hle.cpp
+++ b/src/core/hle/hle.cpp
@@ -15,13 +15,13 @@
 namespace {
 bool reschedule; ///< If true, immediately reschedules the CPU to a new thread
 }
 namespace HLE {
-void Reschedule(const char *reason) {
+void Reschedule(const char* reason) {
-    DEBUG_ASSERT_MSG(reason != nullptr && strlen(reason) < 256, "Reschedule: Invalid or too long reason.");
+    DEBUG_ASSERT_MSG(reason != nullptr && strlen(reason) < 256,
+                     "Reschedule: Invalid or too long reason.");
    // TODO(bunnei): It seems that games depend on some CPU execution time elapsing during HLE
    // routines. This simulates that time by artificially advancing the number of CPU "ticks".
diff --git a/src/core/hle/hle.h b/src/core/hle/hle.h
index 69ac0ade6..23859e129 100644
--- a/src/core/hle/hle.h
+++ b/src/core/hle/hle.h
@@ -13,7 +13,7 @@ const Handle INVALID_HANDLE = 0;
 namespace HLE {
-void Reschedule(const char *reason);
+void Reschedule(const char* reason);
 bool IsReschedulePending();
 void DoneRescheduling();
diff --git a/src/core/hle/kernel/address_arbiter.cpp b/src/core/hle/kernel/address_arbiter.cpp
index 5c3c47acf..2ff652f13 100644
--- a/src/core/hle/kernel/address_arbiter.cpp
+++ b/src/core/hle/kernel/address_arbiter.cpp
@@ -16,8 +16,10 @@
 namespace Kernel {
-AddressArbiter::AddressArbiter() {}
+AddressArbiter::AddressArbiter() {
-AddressArbiter::~AddressArbiter() {}
+}
+AddressArbiter::~AddressArbiter() {
+}
 SharedPtr<AddressArbiter> AddressArbiter::Create(std::string name) {
    SharedPtr<AddressArbiter> address_arbiter(new AddressArbiter);
@@ -28,7 +30,7 @@ SharedPtr<AddressArbiter> AddressArbiter::Create(std::string name) {
 }
 ResultCode AddressArbiter::ArbitrateAddress(ArbitrationType type, VAddr address, s32 value,
-        u64 nanoseconds) {
+                                            u64 nanoseconds) {
    switch (type) {
    // Signal thread(s) waiting for arbitrate address...
@@ -38,7 +40,7 @@ ResultCode AddressArbiter::ArbitrateAddress(ArbitrationType type, VAddr address,
            ArbitrateAllThreads(address);
        } else {
            // Resume first N threads
-            for(int i = 0; i < value; i++)
+            for (int i = 0; i < value; i++)
                ArbitrateHighestPriorityThread(address);
        }
        break;
@@ -55,8 +57,7 @@ ResultCode AddressArbiter::ArbitrateAddress(ArbitrationType type, VAddr address,
            GetCurrentThread()->WakeAfterDelay(nanoseconds);
        }
        break;
-    case ArbitrationType::DecrementAndWaitIfLessThan:
+    case ArbitrationType::DecrementAndWaitIfLessThan: {
-    {
        s32 memory_value = Memory::Read32(address);
        if (memory_value < value) {
            // Only change the memory value if the thread should wait
@@ -65,8 +66,7 @@ ResultCode AddressArbiter::ArbitrateAddress(ArbitrationType type, VAddr address,
        }
        break;
    }
-    case ArbitrationType::DecrementAndWaitIfLessThanWithTimeout:
+    case ArbitrationType::DecrementAndWaitIfLessThanWithTimeout: {
-    {
        s32 memory_value = Memory::Read32(address);
        if (memory_value < value) {
            // Only change the memory value if the thread should wait
@@ -79,17 +79,19 @@ ResultCode AddressArbiter::ArbitrateAddress(ArbitrationType type, VAddr address,
    default:
        LOG_ERROR(Kernel, "unknown type=%d", type);
-        return ResultCode(ErrorDescription::InvalidEnumValue, ErrorModule::Kernel, ErrorSummary::WrongArgument, ErrorLevel::Usage);
+        return ResultCode(ErrorDescription::InvalidEnumValue, ErrorModule::Kernel,
+                          ErrorSummary::WrongArgument, ErrorLevel::Usage);
    }
    HLE::Reschedule(__func__);
-    // The calls that use a timeout seem to always return a Timeout error even if they did not put the thread to sleep
+    // The calls that use a timeout seem to always return a Timeout error even if they did not put
+    // the thread to sleep
    if (type == ArbitrationType::WaitIfLessThanWithTimeout ||
        type == ArbitrationType::DecrementAndWaitIfLessThanWithTimeout) {
-        return ResultCode(ErrorDescription::Timeout, ErrorModule::OS,
+        return ResultCode(ErrorDescription::Timeout, ErrorModule::OS, ErrorSummary::StatusChanged,
-                          ErrorSummary::StatusChanged, ErrorLevel::Info);
+                          ErrorLevel::Info);
    }
    return RESULT_SUCCESS;
 }
diff --git a/src/core/hle/kernel/address_arbiter.h b/src/core/hle/kernel/address_arbiter.h
index 8f6a1a8df..1a03993b2 100644
--- a/src/core/hle/kernel/address_arbiter.h
+++ b/src/core/hle/kernel/address_arbiter.h
@@ -36,13 +36,19 @@ public:
     */
    static SharedPtr<AddressArbiter> Create(std::string name = "Unknown");
-    std::string GetTypeName() const override { return "Arbiter"; }
+    std::string GetTypeName() const override {
-    std::string GetName() const override { return name; }
+        return "Arbiter";
+    }
+    std::string GetName() const override {
+        return name;
+    }
    static const HandleType HANDLE_TYPE = HandleType::AddressArbiter;
-    HandleType GetHandleType() const override { return HANDLE_TYPE; }
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
-    std::string name;   ///< Name of address arbiter object (optional)
+    std::string name; ///< Name of address arbiter object (optional)
    ResultCode ArbitrateAddress(ArbitrationType type, VAddr address, s32 value, u64 nanoseconds);
diff --git a/src/core/hle/kernel/client_port.cpp b/src/core/hle/kernel/client_port.cpp
index 444ce8d45..5df769c6a 100644
--- a/src/core/hle/kernel/client_port.cpp
+++ b/src/core/hle/kernel/client_port.cpp
@@ -10,7 +10,9 @@
 namespace Kernel {
-ClientPort::ClientPort() {}
+ClientPort::ClientPort() {
-ClientPort::~ClientPort() {}
+}
+ClientPort::~ClientPort() {
+}
 } // namespace
diff --git a/src/core/hle/kernel/client_port.h b/src/core/hle/kernel/client_port.h
index 480b6ddae..70e0d56cc 100644
--- a/src/core/hle/kernel/client_port.h
+++ b/src/core/hle/kernel/client_port.h
@@ -17,16 +17,22 @@ class ServerPort;
 class ClientPort : public Object {
 public:
    friend class ServerPort;
-    std::string GetTypeName() const override { return "ClientPort"; }
+    std::string GetTypeName() const override {
-    std::string GetName() const override { return name; }
+        return "ClientPort";
+    }
+    std::string GetName() const override {
+        return name;
+    }
    static const HandleType HANDLE_TYPE = HandleType::ClientPort;
-    HandleType GetHandleType() const override { return HANDLE_TYPE; }
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
-    SharedPtr<ServerPort> server_port;          ///< ServerPort associated with this client port.
+    }
-    u32 max_sessions;                           ///< Maximum number of simultaneous sessions the port can have
-    u32 active_sessions;                        ///< Number of currently open sessions to this port
+    SharedPtr<ServerPort> server_port; ///< ServerPort associated with this client port.
-    std::string name;                           ///< Name of client port (optional)
+    u32 max_sessions;    ///< Maximum number of simultaneous sessions the port can have
+    u32 active_sessions; ///< Number of currently open sessions to this port
+    std::string name;    ///< Name of client port (optional)
 protected:
    ClientPort();
diff --git a/src/core/hle/kernel/event.cpp b/src/core/hle/kernel/event.cpp
index 2b7c6992a..63375818d 100644
--- a/src/core/hle/kernel/event.cpp
+++ b/src/core/hle/kernel/event.cpp
@@ -2,20 +2,22 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
-#include <map>
 #include <algorithm>
+#include <map>
 #include <vector>
 #include "common/assert.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/event.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/thread.h"
 namespace Kernel {
-Event::Event() {}
+Event::Event() {
-Event::~Event() {}
+}
+Event::~Event() {
+}
 SharedPtr<Event> Event::Create(ResetType reset_type, std::string name) {
    SharedPtr<Event> evt(new Event);
diff --git a/src/core/hle/kernel/event.h b/src/core/hle/kernel/event.h
index 73d0da419..e333a46ce 100644
--- a/src/core/hle/kernel/event.h
+++ b/src/core/hle/kernel/event.h
@@ -16,7 +16,6 @@ enum class ResetType {
    Pulse,
 };
 class Event final : public WaitObject {
 public:
    /**
@@ -26,16 +25,22 @@ public:
     */
    static SharedPtr<Event> Create(ResetType reset_type, std::string name = "Unknown");
-    std::string GetTypeName() const override { return "Event"; }
+    std::string GetTypeName() const override {
-    std::string GetName() const override { return name; }
+        return "Event";
+    }
+    std::string GetName() const override {
+        return name;
+    }
    static const HandleType HANDLE_TYPE = HandleType::Event;
-    HandleType GetHandleType() const override { return HANDLE_TYPE; }
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
-    ResetType reset_type;                   ///< Current ResetType
+    ResetType reset_type; ///< Current ResetType
-    bool signaled;                          ///< Whether the event has already been signaled
+    bool signaled;    ///< Whether the event has already been signaled
-    std::string name;                       ///< Name of event (optional)
+    std::string name; ///< Name of event (optional)
    bool ShouldWait() override;
    void Acquire() override;
diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index 7a401a965..1fd7c0326 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -61,7 +61,8 @@ ResultVal<Handle> HandleTable::Create(SharedPtr<Object> obj) {
    // Overflow count so it fits in the 15 bits dedicated to the generation in the handle.
    // CTR-OS doesn't use generation 0, so skip straight to 1.
-    if (next_generation >= (1 << 15)) next_generation = 1;
+    if (next_generation >= (1 << 15))
+        next_generation = 1;
    generations[slot] = generation;
    objects[slot] = std::move(obj);
diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h
index 27ba3f912..cc39652d5 100644
--- a/src/core/hle/kernel/kernel.h
+++ b/src/core/hle/kernel/kernel.h
@@ -23,48 +23,55 @@ class Thread;
 // TODO: Verify code
 const ResultCode ERR_OUT_OF_HANDLES(ErrorDescription::OutOfMemory, ErrorModule::Kernel,
-        ErrorSummary::OutOfResource, ErrorLevel::Temporary);
+                                    ErrorSummary::OutOfResource, ErrorLevel::Temporary);
 // TOOD: Verify code
 const ResultCode ERR_INVALID_HANDLE(ErrorDescription::InvalidHandle, ErrorModule::Kernel,
-        ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
+                                    ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
 enum KernelHandle : Handle {
-    CurrentThread   = 0xFFFF8000,
+    CurrentThread = 0xFFFF8000,
-    CurrentProcess  = 0xFFFF8001,
+    CurrentProcess = 0xFFFF8001,
 };
 enum class HandleType : u32 {
-    Unknown         = 0,
+    Unknown = 0,
-    Session         = 2,
+    Session = 2,
-    Event           = 3,
+    Event = 3,
-    Mutex           = 4,
+    Mutex = 4,
-    SharedMemory    = 5,
+    SharedMemory = 5,
-    Redirection     = 6,
+    Redirection = 6,
-    Thread          = 7,
+    Thread = 7,
-    Process         = 8,
+    Process = 8,
-    AddressArbiter  = 9,
+    AddressArbiter = 9,
-    Semaphore       = 10,
+    Semaphore = 10,
-    Timer           = 11,
+    Timer = 11,
-    ResourceLimit   = 12,
+    ResourceLimit = 12,
-    CodeSet         = 13,
+    CodeSet = 13,
-    ClientPort      = 14,
+    ClientPort = 14,
-    ServerPort      = 15,
+    ServerPort = 15,
 };
 enum {
-    DEFAULT_STACK_SIZE  = 0x4000,
+    DEFAULT_STACK_SIZE = 0x4000,
 };
 class Object : NonCopyable {
 public:
-    virtual ~Object() {}
+    virtual ~Object() {
+    }
    /// Returns a unique identifier for the object. For debugging purposes only.
-    unsigned int GetObjectId() const { return object_id; }
+    unsigned int GetObjectId() const {
+        return object_id;
+    }
-    virtual std::string GetTypeName() const { return "[BAD KERNEL OBJECT TYPE]"; }
+    virtual std::string GetTypeName() const {
-    virtual std::string GetName() const { return "[UNKNOWN KERNEL OBJECT]"; }
+        return "[BAD KERNEL OBJECT TYPE]";
+    }
+    virtual std::string GetName() const {
+        return "[UNKNOWN KERNEL OBJECT]";
+    }
    virtual Kernel::HandleType GetHandleType() const = 0;
    /**
@@ -122,7 +129,6 @@ using SharedPtr = boost::intrusive_ptr<T>;
 /// Class that represents a Kernel object that a thread can be waiting on
 class WaitObject : public Object {
 public:
    /**
     * Check if the current thread should wait until the object is available
     * @return True if the current thread should wait due to this object being unavailable
@@ -247,8 +253,12 @@ private:
     */
    static const size_t MAX_COUNT = 4096;
-    static u16 GetSlot(Handle handle)    { return handle >> 15; }
+    static u16 GetSlot(Handle handle) {
-    static u16 GetGeneration(Handle handle) { return handle & 0x7FFF; }
+        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/memory.cpp b/src/core/hle/kernel/memory.cpp
index 17ae87aef..89a72808a 100644
--- a/src/core/hle/kernel/memory.cpp
+++ b/src/core/hle/kernel/memory.cpp
@@ -31,7 +31,7 @@ static MemoryRegionInfo memory_regions[3];
 static const u32 memory_region_sizes[8][3] = {
    // Old 3DS layouts
    {0x04000000, 0x02C00000, 0x01400000}, // 0
-    { /* This appears to be unused. */ }, // 1
+    {/* This appears to be unused. */},   // 1
    {0x06000000, 0x00C00000, 0x01400000}, // 2
    {0x05000000, 0x01C00000, 0x01400000}, // 3
    {0x04800000, 0x02400000, 0x01400000}, // 4
@@ -95,7 +95,6 @@ MemoryRegionInfo* GetMemoryRegion(MemoryRegion region) {
        UNREACHABLE();
    }
 }
 }
 namespace Memory {
@@ -110,9 +109,8 @@ struct MemoryArea {
 // We don't declare the IO regions in here since its handled by other means.
 static MemoryArea memory_areas[] = {
-    {VRAM_VADDR,          VRAM_SIZE,              "VRAM"},          // Video memory (VRAM)
+    {VRAM_VADDR, VRAM_SIZE, "VRAM"}, // Video memory (VRAM)
 };
 }
 void Init() {
@@ -125,15 +123,21 @@ void InitLegacyAddressSpace(Kernel::VMManager& address_space) {
    for (MemoryArea& area : memory_areas) {
        auto block = std::make_shared<std::vector<u8>>(area.size);
-        address_space.MapMemoryBlock(area.base, std::move(block), 0, area.size, MemoryState::Private).Unwrap();
+        address_space
+            .MapMemoryBlock(area.base, std::move(block), 0, area.size, MemoryState::Private)
+            .Unwrap();
    }
-    auto cfg_mem_vma = address_space.MapBackingMemory(CONFIG_MEMORY_VADDR,
+    auto cfg_mem_vma = address_space
-            (u8*)&ConfigMem::config_mem, CONFIG_MEMORY_SIZE, MemoryState::Shared).MoveFrom();
+                           .MapBackingMemory(CONFIG_MEMORY_VADDR, (u8*)&ConfigMem::config_mem,
+                                             CONFIG_MEMORY_SIZE, MemoryState::Shared)
+                           .MoveFrom();
    address_space.Reprotect(cfg_mem_vma, VMAPermission::Read);
-    auto shared_page_vma = address_space.MapBackingMemory(SHARED_PAGE_VADDR,
+    auto shared_page_vma = address_space
-            (u8*)&SharedPage::shared_page, SHARED_PAGE_SIZE, MemoryState::Shared).MoveFrom();
+                               .MapBackingMemory(SHARED_PAGE_VADDR, (u8*)&SharedPage::shared_page,
+                                                 SHARED_PAGE_SIZE, MemoryState::Shared)
+                               .MoveFrom();
    address_space.Reprotect(shared_page_vma, VMAPermission::Read);
    AudioCore::AddAddressSpace(address_space);
diff --git a/src/core/hle/kernel/memory.h b/src/core/hle/kernel/memory.h
index 091c1f89f..b941c24b6 100644
--- a/src/core/hle/kernel/memory.h
+++ b/src/core/hle/kernel/memory.h
@@ -25,7 +25,6 @@ struct MemoryRegionInfo {
 void MemoryInit(u32 mem_type);
 void MemoryShutdown();
 MemoryRegionInfo* GetMemoryRegion(MemoryRegion region);
 }
 namespace Memory {
diff --git a/src/core/hle/kernel/mutex.cpp b/src/core/hle/kernel/mutex.cpp
index edb97d324..f92810804 100644
--- a/src/core/hle/kernel/mutex.cpp
+++ b/src/core/hle/kernel/mutex.cpp
@@ -33,8 +33,10 @@ void ReleaseThreadMutexes(Thread* thread) {
    thread->held_mutexes.clear();
 }
-Mutex::Mutex() {}
+Mutex::Mutex() {
-Mutex::~Mutex() {}
+}
+Mutex::~Mutex() {
+}
 SharedPtr<Mutex> Mutex::Create(bool initial_locked, std::string name) {
    SharedPtr<Mutex> mutex(new Mutex);
diff --git a/src/core/hle/kernel/mutex.h b/src/core/hle/kernel/mutex.h
index 1746360e4..cf6a51fdf 100644
--- a/src/core/hle/kernel/mutex.h
+++ b/src/core/hle/kernel/mutex.h
@@ -24,15 +24,21 @@ public:
     */
    static SharedPtr<Mutex> Create(bool initial_locked, std::string name = "Unknown");
-    std::string GetTypeName() const override { return "Mutex"; }
+    std::string GetTypeName() const override {
-    std::string GetName() const override { return name; }
+        return "Mutex";
+    }
+    std::string GetName() const override {
+        return name;
+    }
    static const HandleType HANDLE_TYPE = HandleType::Mutex;
-    HandleType GetHandleType() const override { return HANDLE_TYPE; }
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
-    int lock_count;                             ///< Number of times the mutex has been acquired
+    int lock_count;                   ///< Number of times the mutex has been acquired
-    std::string name;                           ///< Name of mutex (optional)
+    std::string name;                 ///< Name of mutex (optional)
-    SharedPtr<Thread> holding_thread;           ///< Thread that has acquired the mutex
+    SharedPtr<Thread> holding_thread; ///< Thread that has acquired the mutex
    bool ShouldWait() override;
    void Acquire() override;
diff --git a/src/core/hle/kernel/process.cpp b/src/core/hle/kernel/process.cpp
index 69302cc82..cc37e574c 100644
--- a/src/core/hle/kernel/process.cpp
+++ b/src/core/hle/kernel/process.cpp
@@ -26,8 +26,10 @@ SharedPtr<CodeSet> CodeSet::Create(std::string name, u64 program_id) {
    return codeset;
 }
-CodeSet::CodeSet() {}
+CodeSet::CodeSet() {
-CodeSet::~CodeSet() {}
+}
+CodeSet::~CodeSet() {
+}
 u32 Process::next_process_id;
@@ -60,7 +62,8 @@ void Process::ParseKernelCaps(const u32* kernel_caps, size_t len) {
            while (bits && index < svc_access_mask.size()) {
                svc_access_mask.set(index, bits & 1);
-                ++index; bits >>= 1;
+                ++index;
+                bits >>= 1;
            }
        } else if ((type & 0xFF0) == 0xFE0) { // 0x00FF
            // Handle table size
@@ -70,11 +73,11 @@ void Process::ParseKernelCaps(const u32* kernel_caps, size_t len) {
            flags.raw = descriptor & 0xFFFF;
        } else if ((type & 0xFFE) == 0xFF8) { // 0x001F
            // Mapped memory range
-            if (i+1 >= len || ((kernel_caps[i+1] >> 20) & 0xFFE) != 0xFF8) {
+            if (i + 1 >= len || ((kernel_caps[i + 1] >> 20) & 0xFFE) != 0xFF8) {
                LOG_WARNING(Loader, "Incomplete exheader memory range descriptor ignored.");
                continue;
            }
-            u32 end_desc = kernel_caps[i+1];
+            u32 end_desc = kernel_caps[i + 1];
            ++i; // Skip over the second descriptor on the next iteration
            AddressMapping mapping;
@@ -107,23 +110,28 @@ void Process::ParseKernelCaps(const u32* kernel_caps, size_t len) {
 void Process::Run(s32 main_thread_priority, u32 stack_size) {
    memory_region = GetMemoryRegion(flags.memory_region);
-    auto MapSegment = [&](CodeSet::Segment& segment, VMAPermission permissions, MemoryState memory_state) {
+    auto MapSegment = [&](CodeSet::Segment& segment, VMAPermission permissions,
-        auto vma = vm_manager.MapMemoryBlock(segment.addr, codeset->memory,
+                          MemoryState memory_state) {
-                segment.offset, segment.size, memory_state).Unwrap();
+        auto vma = vm_manager
+                       .MapMemoryBlock(segment.addr, codeset->memory, segment.offset, segment.size,
+                                       memory_state)
+                       .Unwrap();
        vm_manager.Reprotect(vma, permissions);
        misc_memory_used += segment.size;
        memory_region->used += segment.size;
    };
    // Map CodeSet segments
-    MapSegment(codeset->code,   VMAPermission::ReadExecute, MemoryState::Code);
+    MapSegment(codeset->code, VMAPermission::ReadExecute, MemoryState::Code);
-    MapSegment(codeset->rodata, VMAPermission::Read,        MemoryState::Code);
+    MapSegment(codeset->rodata, VMAPermission::Read, MemoryState::Code);
-    MapSegment(codeset->data,   VMAPermission::ReadWrite,   MemoryState::Private);
+    MapSegment(codeset->data, VMAPermission::ReadWrite, MemoryState::Private);
    // Allocate and map stack
-    vm_manager.MapMemoryBlock(Memory::HEAP_VADDR_END - stack_size,
+    vm_manager
-            std::make_shared<std::vector<u8>>(stack_size, 0), 0, stack_size, MemoryState::Locked
+        .MapMemoryBlock(Memory::HEAP_VADDR_END - stack_size,
-            ).Unwrap();
+                        std::make_shared<std::vector<u8>>(stack_size, 0), 0, stack_size,
+                        MemoryState::Locked)
+        .Unwrap();
    misc_memory_used += stack_size;
    memory_region->used += stack_size;
@@ -143,7 +151,8 @@ VAddr Process::GetLinearHeapLimit() const {
 }
 ResultVal<VAddr> Process::HeapAllocate(VAddr target, u32 size, VMAPermission perms) {
-    if (target < Memory::HEAP_VADDR || target + size > Memory::HEAP_VADDR_END || target + size < target) {
+    if (target < Memory::HEAP_VADDR || target + size > Memory::HEAP_VADDR_END ||
+        target + size < target) {
        return ERR_INVALID_ADDRESS;
    }
@@ -166,7 +175,8 @@ ResultVal<VAddr> Process::HeapAllocate(VAddr target, u32 size, VMAPermission per
    }
    ASSERT(heap_end - heap_start == heap_memory->size());
-    CASCADE_RESULT(auto vma, vm_manager.MapMemoryBlock(target, heap_memory, target - heap_start, size, MemoryState::Private));
+    CASCADE_RESULT(auto vma, vm_manager.MapMemoryBlock(target, heap_memory, target - heap_start,
+                                                       size, MemoryState::Private));
    vm_manager.Reprotect(vma, perms);
    heap_used += size;
@@ -176,7 +186,8 @@ ResultVal<VAddr> Process::HeapAllocate(VAddr target, u32 size, VMAPermission per
 }
 ResultCode Process::HeapFree(VAddr target, u32 size) {
-    if (target < Memory::HEAP_VADDR || target + size > Memory::HEAP_VADDR_END || target + size < target) {
+    if (target < Memory::HEAP_VADDR || target + size > Memory::HEAP_VADDR_END ||
+        target + size < target) {
        return ERR_INVALID_ADDRESS;
    }
@@ -185,7 +196,8 @@ ResultCode Process::HeapFree(VAddr target, u32 size) {
    }
    ResultCode result = vm_manager.UnmapRange(target, size);
-    if (result.IsError()) return result;
+    if (result.IsError())
+        return result;
    heap_used -= size;
    memory_region->used -= size;
@@ -203,8 +215,8 @@ ResultVal<VAddr> Process::LinearAllocate(VAddr target, u32 size, VMAPermission p
        target = heap_end;
    }
-    if (target < GetLinearHeapBase() || target + size > GetLinearHeapLimit() ||
+    if (target < GetLinearHeapBase() || target + size > GetLinearHeapLimit() || target > heap_end ||
-        target > heap_end || target + size < target) {
+        target + size < target) {
        return ERR_INVALID_ADDRESS;
    }
@@ -220,7 +232,8 @@ ResultVal<VAddr> Process::LinearAllocate(VAddr target, u32 size, VMAPermission p
    // TODO(yuriks): As is, this lets processes map memory allocated by other processes from the
    // same region. It is unknown if or how the 3DS kernel checks against this.
    size_t offset = target - GetLinearHeapBase();
-    CASCADE_RESULT(auto vma, vm_manager.MapMemoryBlock(target, linheap_memory, offset, size, MemoryState::Continuous));
+    CASCADE_RESULT(auto vma, vm_manager.MapMemoryBlock(target, linheap_memory, offset, size,
+                                                       MemoryState::Continuous));
    vm_manager.Reprotect(vma, perms);
    linear_heap_used += size;
@@ -248,7 +261,8 @@ ResultCode Process::LinearFree(VAddr target, u32 size) {
    }
    ResultCode result = vm_manager.UnmapRange(target, size);
-    if (result.IsError()) return result;
+    if (result.IsError())
+        return result;
    linear_heap_used -= size;
    memory_region->used -= size;
@@ -268,9 +282,10 @@ ResultCode Process::LinearFree(VAddr target, u32 size) {
    return RESULT_SUCCESS;
 }
-Kernel::Process::Process() {}
+Kernel::Process::Process() {
-Kernel::Process::~Process() {}
+}
+Kernel::Process::~Process() {
+}
 SharedPtr<Process> g_current_process;
 }
diff --git a/src/core/hle/kernel/process.h b/src/core/hle/kernel/process.h
index d781ef32c..070b2b558 100644
--- a/src/core/hle/kernel/process.h
+++ b/src/core/hle/kernel/process.h
@@ -36,15 +36,18 @@ enum class MemoryRegion : u16 {
 union ProcessFlags {
    u16 raw;
-    BitField< 0, 1, u16> allow_debug; ///< Allows other processes to attach to and debug this process.
+    BitField<0, 1, u16>
-    BitField< 1, 1, u16> force_debug; ///< Allows this process to attach to processes even if they don't have allow_debug set.
+        allow_debug; ///< Allows other processes to attach to and debug this process.
-    BitField< 2, 1, u16> allow_nonalphanum;
+    BitField<1, 1, u16> force_debug; ///< Allows this process to attach to processes even if they
-    BitField< 3, 1, u16> shared_page_writable; ///< Shared page is mapped with write permissions.
+                                     /// don't have allow_debug set.
-    BitField< 4, 1, u16> privileged_priority; ///< Can use priority levels higher than 24.
+    BitField<2, 1, u16> allow_nonalphanum;
-    BitField< 5, 1, u16> allow_main_args;
+    BitField<3, 1, u16> shared_page_writable; ///< Shared page is mapped with write permissions.
-    BitField< 6, 1, u16> shared_device_mem;
+    BitField<4, 1, u16> privileged_priority;  ///< Can use priority levels higher than 24.
-    BitField< 7, 1, u16> runnable_on_sleep;
+    BitField<5, 1, u16> allow_main_args;
-    BitField< 8, 4, MemoryRegion> memory_region; ///< Default region for memory allocations for this process
+    BitField<6, 1, u16> shared_device_mem;
+    BitField<7, 1, u16> runnable_on_sleep;
+    BitField<8, 4, MemoryRegion>
+        memory_region;                ///< Default region for memory allocations for this process
    BitField<12, 1, u16> loaded_high; ///< Application loaded high (not at 0x00100000).
 };
@@ -54,11 +57,17 @@ struct MemoryRegionInfo;
 struct CodeSet final : public Object {
    static SharedPtr<CodeSet> Create(std::string name, u64 program_id);
-    std::string GetTypeName() const override { return "CodeSet"; }
+    std::string GetTypeName() const override {
-    std::string GetName() const override { return name; }
+        return "CodeSet";
+    }
+    std::string GetName() const override {
+        return name;
+    }
    static const HandleType HANDLE_TYPE = HandleType::CodeSet;
-    HandleType GetHandleType() const override { return HANDLE_TYPE; }
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
    /// Name of the process
    std::string name;
@@ -85,11 +94,17 @@ class Process final : public Object {
 public:
    static SharedPtr<Process> Create(SharedPtr<CodeSet> code_set);
-    std::string GetTypeName() const override { return "Process"; }
+    std::string GetTypeName() const override {
-    std::string GetName() const override { return codeset->name; }
+        return "Process";
+    }
+    std::string GetName() const override {
+        return codeset->name;
+    }
    static const HandleType HANDLE_TYPE = HandleType::Process;
-    HandleType GetHandleType() const override { return HANDLE_TYPE; }
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
    static u32 next_process_id;
@@ -124,7 +139,6 @@ public:
     */
    void Run(s32 main_thread_priority, u32 stack_size);
    ///////////////////////////////////////////////////////////////////////////////////////////////
    // Memory Management
@@ -144,7 +158,8 @@ public:
    /// The Thread Local Storage area is allocated as processes create threads,
    /// each TLS area is 0x200 bytes, so one page (0x1000) is split up in 8 parts, and each part
-    /// holds the TLS for a specific thread. This vector contains which parts are in use for each page as a bitmask.
+    /// holds the TLS for a specific thread. This vector contains which parts are in use for each
+    /// page as a bitmask.
    /// This vector will grow as more pages are allocated for new threads.
    std::vector<std::bitset<8>> tls_slots;
@@ -164,5 +179,4 @@ private:
 };
 extern SharedPtr<Process> g_current_process;
 }
diff --git a/src/core/hle/kernel/resource_limit.cpp b/src/core/hle/kernel/resource_limit.cpp
index 67dde08c2..7bd1c1e08 100644
--- a/src/core/hle/kernel/resource_limit.cpp
+++ b/src/core/hle/kernel/resource_limit.cpp
@@ -12,8 +12,10 @@ namespace Kernel {
 static SharedPtr<ResourceLimit> resource_limits[4];
-ResourceLimit::ResourceLimit() {}
+ResourceLimit::ResourceLimit() {
-ResourceLimit::~ResourceLimit() {}
+}
+ResourceLimit::~ResourceLimit() {
+}
 SharedPtr<ResourceLimit> ResourceLimit::Create(std::string name) {
    SharedPtr<ResourceLimit> resource_limit(new ResourceLimit);
@@ -23,70 +25,69 @@ SharedPtr<ResourceLimit> ResourceLimit::Create(std::string name) {
 }
 SharedPtr<ResourceLimit> ResourceLimit::GetForCategory(ResourceLimitCategory category) {
-    switch (category)
+    switch (category) {
-    {
+    case ResourceLimitCategory::APPLICATION:
-        case ResourceLimitCategory::APPLICATION:
+    case ResourceLimitCategory::SYS_APPLET:
-        case ResourceLimitCategory::SYS_APPLET:
+    case ResourceLimitCategory::LIB_APPLET:
-        case ResourceLimitCategory::LIB_APPLET:
+    case ResourceLimitCategory::OTHER:
-        case ResourceLimitCategory::OTHER:
+        return resource_limits[static_cast<u8>(category)];
-            return resource_limits[static_cast<u8>(category)];
+    default:
-        default:
+        LOG_CRITICAL(Kernel, "Unknown resource limit category");
-            LOG_CRITICAL(Kernel, "Unknown resource limit category");
+        UNREACHABLE();
-            UNREACHABLE();
    }
 }
 s32 ResourceLimit::GetCurrentResourceValue(u32 resource) const {
    switch (resource) {
-        case COMMIT:
+    case COMMIT:
-            return current_commit;
+        return current_commit;
-        case THREAD:
+    case THREAD:
-            return current_threads;
+        return current_threads;
-        case EVENT:
+    case EVENT:
-            return current_events;
+        return current_events;
-        case MUTEX:
+    case MUTEX:
-            return current_mutexes;
+        return current_mutexes;
-        case SEMAPHORE:
+    case SEMAPHORE:
-            return current_semaphores;
+        return current_semaphores;
-        case TIMER:
+    case TIMER:
-            return current_timers;
+        return current_timers;
-        case SHARED_MEMORY:
+    case SHARED_MEMORY:
-            return current_shared_mems;
+        return current_shared_mems;
-        case ADDRESS_ARBITER:
+    case ADDRESS_ARBITER:
-            return current_address_arbiters;
+        return current_address_arbiters;
-        case CPU_TIME:
+    case CPU_TIME:
-            return current_cpu_time;
+        return current_cpu_time;
-        default:
+    default:
-            LOG_ERROR(Kernel, "Unknown resource type=%08X", resource);
+        LOG_ERROR(Kernel, "Unknown resource type=%08X", resource);
-            UNIMPLEMENTED();
+        UNIMPLEMENTED();
-            return 0;
+        return 0;
    }
 }
 s32 ResourceLimit::GetMaxResourceValue(u32 resource) const {
    switch (resource) {
-        case COMMIT:
+    case COMMIT:
-            return max_commit;
+        return max_commit;
-        case THREAD:
+    case THREAD:
-            return max_threads;
+        return max_threads;
-        case EVENT:
+    case EVENT:
-            return max_events;
+        return max_events;
-        case MUTEX:
+    case MUTEX:
-            return max_mutexes;
+        return max_mutexes;
-        case SEMAPHORE:
+    case SEMAPHORE:
-            return max_semaphores;
+        return max_semaphores;
-        case TIMER:
+    case TIMER:
-            return max_timers;
+        return max_timers;
-        case SHARED_MEMORY:
+    case SHARED_MEMORY:
-            return max_shared_mems;
+        return max_shared_mems;
-        case ADDRESS_ARBITER:
+    case ADDRESS_ARBITER:
-            return max_address_arbiters;
+        return max_address_arbiters;
-        case CPU_TIME:
+    case CPU_TIME:
-            return max_cpu_time;
+        return max_cpu_time;
-        default:
+    default:
-            LOG_ERROR(Kernel, "Unknown resource type=%08X", resource);
+        LOG_ERROR(Kernel, "Unknown resource type=%08X", resource);
-            UNIMPLEMENTED();
+        UNIMPLEMENTED();
-            return 0;
+        return 0;
    }
 }
@@ -150,7 +151,6 @@ void ResourceLimitsInit() {
 }
 void ResourceLimitsShutdown() {
 }
 } // namespace
diff --git a/src/core/hle/kernel/resource_limit.h b/src/core/hle/kernel/resource_limit.h
index 1b8249c74..c08e744e6 100644
--- a/src/core/hle/kernel/resource_limit.h
+++ b/src/core/hle/kernel/resource_limit.h
@@ -12,22 +12,22 @@ namespace Kernel {
 enum class ResourceLimitCategory : u8 {
    APPLICATION = 0,
-    SYS_APPLET  = 1,
+    SYS_APPLET = 1,
-    LIB_APPLET  = 2,
+    LIB_APPLET = 2,
-    OTHER       = 3
+    OTHER = 3
 };
 enum ResourceTypes {
-    PRIORITY            = 0,
+    PRIORITY = 0,
-    COMMIT              = 1,
+    COMMIT = 1,
-    THREAD              = 2,
+    THREAD = 2,
-    EVENT               = 3,
+    EVENT = 3,
-    MUTEX               = 4,
+    MUTEX = 4,
-    SEMAPHORE           = 5,
+    SEMAPHORE = 5,
-    TIMER               = 6,
+    TIMER = 6,
-    SHARED_MEMORY       = 7,
+    SHARED_MEMORY = 7,
-    ADDRESS_ARBITER     = 8,
+    ADDRESS_ARBITER = 8,
-    CPU_TIME            = 9,
+    CPU_TIME = 9,
 };
 class ResourceLimit final : public Object {
@@ -44,11 +44,17 @@ public:
     */
    static SharedPtr<ResourceLimit> GetForCategory(ResourceLimitCategory category);
-    std::string GetTypeName() const override { return "ResourceLimit"; }
+    std::string GetTypeName() const override {
-    std::string GetName() const override { return name; }
+        return "ResourceLimit";
+    }
+    std::string GetName() const override {
+        return name;
+    }
    static const HandleType HANDLE_TYPE = HandleType::ResourceLimit;
-    HandleType GetHandleType() const override { return HANDLE_TYPE; }
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
    /**
     * Gets the current value for the specified resource.
@@ -85,10 +91,12 @@ public:
    /// Max CPU time that the processes in this category can utilize
    s32 max_cpu_time = 0;
-    // TODO(Subv): Increment these in their respective Kernel::T::Create functions, keeping in mind that
+    // TODO(Subv): Increment these in their respective Kernel::T::Create functions, keeping in mind
+    // that
    // APPLICATION resource limits should not be affected by the objects created by service modules.
    // Currently we have no way of distinguishing if a Create was called by the running application,
-    // or by a service module. Approach this once we have separated the service modules into their own processes
+    // or by a service module. Approach this once we have separated the service modules into their
+    // own processes
    /// Current memory that the processes in this category are using
    s32 current_commit = 0;
diff --git a/src/core/hle/kernel/semaphore.cpp b/src/core/hle/kernel/semaphore.cpp
index 4b359ed07..71e41079b 100644
--- a/src/core/hle/kernel/semaphore.cpp
+++ b/src/core/hle/kernel/semaphore.cpp
@@ -10,11 +10,13 @@
 namespace Kernel {
-Semaphore::Semaphore() {}
+Semaphore::Semaphore() {
-Semaphore::~Semaphore() {}
+}
+Semaphore::~Semaphore() {
+}
 ResultVal<SharedPtr<Semaphore>> Semaphore::Create(s32 initial_count, s32 max_count,
-        std::string name) {
+                                                  std::string name) {
    if (initial_count > max_count)
        return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::Kernel,
diff --git a/src/core/hle/kernel/semaphore.h b/src/core/hle/kernel/semaphore.h
index 390f5e495..ed7d9a85c 100644
--- a/src/core/hle/kernel/semaphore.h
+++ b/src/core/hle/kernel/semaphore.h
@@ -23,17 +23,23 @@ public:
     * @return The created semaphore
     */
    static ResultVal<SharedPtr<Semaphore>> Create(s32 initial_count, s32 max_count,
-            std::string name = "Unknown");
+                                                  std::string name = "Unknown");
-    std::string GetTypeName() const override { return "Semaphore"; }
+    std::string GetTypeName() const override {
-    std::string GetName() const override { return name; }
+        return "Semaphore";
+    }
+    std::string GetName() const override {
+        return name;
+    }
    static const HandleType HANDLE_TYPE = HandleType::Semaphore;
-    HandleType GetHandleType() const override { return HANDLE_TYPE; }
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
-    s32 max_count;                              ///< Maximum number of simultaneous holders the semaphore can have
+    s32 max_count;       ///< Maximum number of simultaneous holders the semaphore can have
-    s32 available_count;                        ///< Number of free slots left in the semaphore
+    s32 available_count; ///< Number of free slots left in the semaphore
-    std::string name;                           ///< Name of semaphore (optional)
+    std::string name;    ///< Name of semaphore (optional)
    bool ShouldWait() override;
    void Acquire() override;
diff --git a/src/core/hle/kernel/server_port.cpp b/src/core/hle/kernel/server_port.cpp
index fcc684a20..7c690fa7f 100644
--- a/src/core/hle/kernel/server_port.cpp
+++ b/src/core/hle/kernel/server_port.cpp
@@ -13,8 +13,10 @@
 namespace Kernel {
-ServerPort::ServerPort() {}
+ServerPort::ServerPort() {
-ServerPort::~ServerPort() {}
+}
+ServerPort::~ServerPort() {
+}
 bool ServerPort::ShouldWait() {
    // If there are no pending sessions, we wait until a new one is added.
@@ -25,7 +27,8 @@ void ServerPort::Acquire() {
    ASSERT_MSG(!ShouldWait(), "object unavailable!");
 }
-std::tuple<SharedPtr<ServerPort>, SharedPtr<ClientPort>> ServerPort::CreatePortPair(u32 max_sessions, std::string name) {
+std::tuple<SharedPtr<ServerPort>, SharedPtr<ClientPort>>
+ServerPort::CreatePortPair(u32 max_sessions, std::string name) {
    SharedPtr<ServerPort> server_port(new ServerPort);
    SharedPtr<ClientPort> client_port(new ClientPort);
diff --git a/src/core/hle/kernel/server_port.h b/src/core/hle/kernel/server_port.h
index e9c972ce6..e43d48674 100644
--- a/src/core/hle/kernel/server_port.h
+++ b/src/core/hle/kernel/server_port.h
@@ -23,17 +23,25 @@ public:
     * @param name Optional name of the ports
     * @return The created port tuple
     */
-    static std::tuple<SharedPtr<ServerPort>, SharedPtr<ClientPort>> CreatePortPair(u32 max_sessions, std::string name = "UnknownPort");
+    static std::tuple<SharedPtr<ServerPort>, SharedPtr<ClientPort>>
+    CreatePortPair(u32 max_sessions, std::string name = "UnknownPort");
-    std::string GetTypeName() const override { return "ServerPort"; }
+    std::string GetTypeName() const override {
-    std::string GetName() const override { return name; }
+        return "ServerPort";
+    }
+    std::string GetName() const override {
+        return name;
+    }
    static const HandleType HANDLE_TYPE = HandleType::ServerPort;
-    HandleType GetHandleType() const override { return HANDLE_TYPE; }
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
-    std::string name;                           ///< Name of port (optional)
+    std::string name; ///< Name of port (optional)
-    std::vector<SharedPtr<WaitObject>> pending_sessions; ///< ServerSessions waiting to be accepted by the port
+    std::vector<SharedPtr<WaitObject>>
+        pending_sessions; ///< ServerSessions waiting to be accepted by the port
    bool ShouldWait() override;
    void Acquire() override;
diff --git a/src/core/hle/kernel/session.cpp b/src/core/hle/kernel/session.cpp
index 0594967f8..61457845a 100644
--- a/src/core/hle/kernel/session.cpp
+++ b/src/core/hle/kernel/session.cpp
@@ -7,7 +7,8 @@
 namespace Kernel {
-Session::Session() {}
+Session::Session() {
-Session::~Session() {}
+}
+Session::~Session() {
+}
 }
diff --git a/src/core/hle/kernel/session.h b/src/core/hle/kernel/session.h
index 8ec889967..8e4e010b8 100644
--- a/src/core/hle/kernel/session.h
+++ b/src/core/hle/kernel/session.h
@@ -19,12 +19,13 @@ namespace IPC {
 enum DescriptorType : u32 {
    // Buffer related desciptors types (mask : 0x0F)
    StaticBuffer = 0x02,
-    PXIBuffer    = 0x04,
+    PXIBuffer = 0x04,
    MappedBuffer = 0x08,
-    // Handle related descriptors types (mask : 0x30, but need to check for buffer related descriptors first )
+    // Handle related descriptors types (mask : 0x30, but need to check for buffer related
-    CopyHandle   = 0x00,
+    // descriptors first )
-    MoveHandle   = 0x10,
+    CopyHandle = 0x00,
-    CallingPid   = 0x20,
+    MoveHandle = 0x10,
+    CallingPid = 0x20,
 };
 /**
@@ -34,24 +35,28 @@ enum DescriptorType : u32 {
 * @param translate_params_size Size of the translate parameters in words. Up to 63.
 * @return The created IPC header.
 *
- * Normal parameters are sent directly to the process while the translate parameters might go through modifications and checks by the kernel.
+ * Normal parameters are sent directly to the process while the translate parameters might go
+ * through modifications and checks by the kernel.
 * The translate parameters are described by headers generated with the IPC::*Desc functions.
 *
- * @note While #normal_params is equivalent to the number of normal parameters, #translate_params_size includes the size occupied by the translate parameters headers.
+ * @note While #normal_params is equivalent to the number of normal parameters,
+ * #translate_params_size includes the size occupied by the translate parameters headers.
 */
-constexpr u32 MakeHeader(u16 command_id, unsigned int normal_params, unsigned int translate_params_size) {
+constexpr u32 MakeHeader(u16 command_id, unsigned int normal_params,
-    return (u32(command_id) << 16) | ((u32(normal_params) & 0x3F) << 6) | (u32(translate_params_size) & 0x3F);
+                         unsigned int translate_params_size) {
+    return (u32(command_id) << 16) | ((u32(normal_params) & 0x3F) << 6) |
+           (u32(translate_params_size) & 0x3F);
 }
 union Header {
    u32 raw;
-    BitField< 0, 6, u32> translate_params_size;
+    BitField<0, 6, u32> translate_params_size;
-    BitField< 6, 6, u32> normal_params;
+    BitField<6, 6, u32> normal_params;
    BitField<16, 16, u32> command_id;
 };
 inline Header ParseHeader(u32 header) {
-    return{ header };
+    return {header};
 }
 constexpr u32 MoveHandleDesc(u32 num_handles = 1) {
@@ -80,27 +85,29 @@ constexpr u32 StaticBufferDesc(u32 size, u8 buffer_id) {
 union StaticBufferDescInfo {
    u32 raw;
-    BitField< 10, 4, u32> buffer_id;
+    BitField<10, 4, u32> buffer_id;
-    BitField< 14, 18, u32> size;
+    BitField<14, 18, u32> size;
 };
 inline StaticBufferDescInfo ParseStaticBufferDesc(const u32 desc) {
-    return{ desc };
+    return {desc};
 }
 /**
 * @brief Creates a header describing a buffer to be sent over PXI.
 * @param size         Size of the buffer. Max 0x00FFFFFF.
 * @param buffer_id    The Id of the buffer. Max 0xF.
- * @param is_read_only true if the buffer is read-only. If false, the buffer is considered to have read-write access.
+ * @param is_read_only true if the buffer is read-only. If false, the buffer is considered to have
+ * read-write access.
 * @return The created PXI buffer header.
 *
 * The next value is a phys-address of a table located in the BASE memregion.
 */
 inline u32 PXIBufferDesc(u32 size, unsigned buffer_id, bool is_read_only) {
    u32 type = PXIBuffer;
-    if (is_read_only) type |= 0x2;
+    if (is_read_only)
-    return  type | (size << 8) | ((buffer_id & 0xF) << 4);
+        type |= 0x2;
+    return type | (size << 8) | ((buffer_id & 0xF) << 4);
 }
 enum MappedBufferPermissions {
@@ -115,12 +122,12 @@ constexpr u32 MappedBufferDesc(u32 size, MappedBufferPermissions perms) {
 union MappedBufferDescInfo {
    u32 raw;
-    BitField< 4, 28, u32> size;
+    BitField<4, 28, u32> size;
-    BitField< 1, 2, MappedBufferPermissions> perms;
+    BitField<1, 2, MappedBufferPermissions> perms;
 };
 inline MappedBufferDescInfo ParseMappedBufferDesc(const u32 desc) {
-    return{ desc };
+    return {desc};
 }
 inline DescriptorType GetDescriptorType(u32 descriptor) {
@@ -153,7 +160,8 @@ static const int kCommandHeaderOffset = 0x80; ///< Offset into command buffer of
 * @return Pointer to command buffer
 */
 inline u32* GetCommandBuffer(const int offset = 0) {
-    return (u32*)Memory::GetPointer(GetCurrentThread()->GetTLSAddress() + kCommandHeaderOffset + offset);
+    return (u32*)Memory::GetPointer(GetCurrentThread()->GetTLSAddress() + kCommandHeaderOffset +
+                                    offset);
 }
 /**
@@ -183,10 +191,14 @@ public:
    Session();
    ~Session() override;
-    std::string GetTypeName() const override { return "Session"; }
+    std::string GetTypeName() const override {
+        return "Session";
+    }
    static const HandleType HANDLE_TYPE = HandleType::Session;
-    HandleType GetHandleType() const override { return HANDLE_TYPE; }
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
    /**
     * Handles a synchronous call to this session using HLE emulation. Emulated <-> emulated calls
@@ -205,5 +217,4 @@ public:
        ASSERT_MSG(!ShouldWait(), "object unavailable!");
    }
 };
 }
diff --git a/src/core/hle/kernel/shared_memory.cpp b/src/core/hle/kernel/shared_memory.cpp
index 6a22c8986..74f40930c 100644
--- a/src/core/hle/kernel/shared_memory.cpp
+++ b/src/core/hle/kernel/shared_memory.cpp
@@ -6,17 +6,21 @@
 #include "common/logging/log.h"
-#include "core/memory.h"
 #include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/shared_memory.h"
+#include "core/memory.h"
 namespace Kernel {
-SharedMemory::SharedMemory() {}
+SharedMemory::SharedMemory() {
-SharedMemory::~SharedMemory() {}
+}
+SharedMemory::~SharedMemory() {
+}
-SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u32 size, MemoryPermission permissions,
+SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u32 size,
-        MemoryPermission other_permissions, VAddr address, MemoryRegion region, std::string name) {
+                                             MemoryPermission permissions,
+                                             MemoryPermission other_permissions, VAddr address,
+                                             MemoryRegion region, std::string name) {
    SharedPtr<SharedMemory> shared_memory(new SharedMemory);
    shared_memory->owner_process = owner_process;
@@ -31,7 +35,8 @@ SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u
        MemoryRegionInfo* memory_region = GetMemoryRegion(region);
        auto& linheap_memory = memory_region->linear_heap_memory;
-        ASSERT_MSG(linheap_memory->size() + size <= memory_region->size, "Not enough space in region to allocate shared memory!");
+        ASSERT_MSG(linheap_memory->size() + size <= memory_region->size,
+                   "Not enough space in region to allocate shared memory!");
        shared_memory->backing_block = linheap_memory;
        shared_memory->backing_block_offset = linheap_memory->size();
@@ -39,7 +44,8 @@ SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u
        linheap_memory->insert(linheap_memory->end(), size, 0);
        memory_region->used += size;
-        shared_memory->linear_heap_phys_address = Memory::FCRAM_PADDR + memory_region->base + shared_memory->backing_block_offset;
+        shared_memory->linear_heap_phys_address =
+            Memory::FCRAM_PADDR + memory_region->base + shared_memory->backing_block_offset;
        // Increase the amount of used linear heap memory for the owner process.
        if (shared_memory->owner_process != nullptr) {
@@ -51,18 +57,20 @@ SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u
            Kernel::g_current_process->vm_manager.RefreshMemoryBlockMappings(linheap_memory.get());
        }
    } else {
-        // TODO(Subv): What happens if an application tries to create multiple memory blocks pointing to the same address?
+        // TODO(Subv): What happens if an application tries to create multiple memory blocks
+        // pointing to the same address?
        auto& vm_manager = shared_memory->owner_process->vm_manager;
        // The memory is already available and mapped in the owner process.
        auto vma = vm_manager.FindVMA(address)->second;
        // Copy it over to our own storage
-        shared_memory->backing_block = std::make_shared<std::vector<u8>>(vma.backing_block->data() + vma.offset,
+        shared_memory->backing_block = std::make_shared<std::vector<u8>>(
-                                                                         vma.backing_block->data() + vma.offset + size);
+            vma.backing_block->data() + vma.offset, vma.backing_block->data() + vma.offset + size);
        shared_memory->backing_block_offset = 0;
        // Unmap the existing pages
        vm_manager.UnmapRange(address, size);
        // Map our own block into the address space
-        vm_manager.MapMemoryBlock(address, shared_memory->backing_block, 0, size, MemoryState::Shared);
+        vm_manager.MapMemoryBlock(address, shared_memory->backing_block, 0, size,
+                                  MemoryState::Shared);
        // Reprotect the block with the new permissions
        vm_manager.ReprotectRange(address, size, ConvertPermissions(permissions));
    }
@@ -71,8 +79,11 @@ SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u
    return shared_memory;
 }
-SharedPtr<SharedMemory> SharedMemory::CreateForApplet(std::shared_ptr<std::vector<u8>> heap_block, u32 offset, u32 size,
+SharedPtr<SharedMemory> SharedMemory::CreateForApplet(std::shared_ptr<std::vector<u8>> heap_block,
-                                                      MemoryPermission permissions, MemoryPermission other_permissions, std::string name) {
+                                                      u32 offset, u32 size,
+                                                      MemoryPermission permissions,
+                                                      MemoryPermission other_permissions,
+                                                      std::string name) {
    SharedPtr<SharedMemory> shared_memory(new SharedMemory);
    shared_memory->owner_process = nullptr;
@@ -88,27 +99,31 @@ SharedPtr<SharedMemory> SharedMemory::CreateForApplet(std::shared_ptr<std::vecto
 }
 ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermission permissions,
-        MemoryPermission other_permissions) {
+                             MemoryPermission other_permissions) {
-    MemoryPermission own_other_permissions = target_process == owner_process ? this->permissions : this->other_permissions;
+    MemoryPermission own_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) {
-        return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::OS, ErrorSummary::InvalidArgument, ErrorLevel::Usage);
+        return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::OS,
+                          ErrorSummary::InvalidArgument, ErrorLevel::Usage);
    }
    // Error out if the requested permissions don't match what the creator process allows.
    if (static_cast<u32>(permissions) & ~static_cast<u32>(own_other_permissions)) {
        LOG_ERROR(Kernel, "cannot map id=%u, address=0x%08X name=%s, permissions don't match",
                  GetObjectId(), address, name.c_str());
-        return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::OS, ErrorSummary::InvalidArgument, ErrorLevel::Usage);
+        return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::OS,
+                          ErrorSummary::InvalidArgument, ErrorLevel::Usage);
    }
    // Heap-backed memory blocks can not be mapped with other_permissions = DontCare
    if (base_address != 0 && other_permissions == MemoryPermission::DontCare) {
        LOG_ERROR(Kernel, "cannot map id=%u, address=0x%08X name=%s, permissions don't match",
                  GetObjectId(), address, name.c_str());
-        return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::OS, ErrorSummary::InvalidArgument, ErrorLevel::Usage);
+        return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::OS,
+                          ErrorSummary::InvalidArgument, ErrorLevel::Usage);
    }
    // Error out if the provided permissions are not compatible with what the creator process needs.
@@ -116,12 +131,14 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
        static_cast<u32>(this->permissions) & ~static_cast<u32>(other_permissions)) {
        LOG_ERROR(Kernel, "cannot map id=%u, address=0x%08X name=%s, permissions don't match",
                  GetObjectId(), address, name.c_str());
-        return ResultCode(ErrorDescription::WrongPermission, ErrorModule::OS, ErrorSummary::WrongArgument, ErrorLevel::Permanent);
+        return ResultCode(ErrorDescription::WrongPermission, ErrorModule::OS,
+                          ErrorSummary::WrongArgument, ErrorLevel::Permanent);
    }
    // TODO(Subv): Check for the Shared Device Mem flag in the creator process.
    /*if (was_created_with_shared_device_mem && address != 0) {
-        return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::OS, ErrorSummary::InvalidArgument, ErrorLevel::Usage);
+        return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::OS,
+    ErrorSummary::InvalidArgument, ErrorLevel::Usage);
    }*/
    // TODO(Subv): The same process that created a SharedMemory object
@@ -144,23 +161,29 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
    }
    // Map the memory block into the target process
-    auto result = target_process->vm_manager.MapMemoryBlock(target_address, backing_block, backing_block_offset, size, MemoryState::Shared);
+    auto result = target_process->vm_manager.MapMemoryBlock(
+        target_address, backing_block, backing_block_offset, size, MemoryState::Shared);
    if (result.Failed()) {
-        LOG_ERROR(Kernel, "cannot map id=%u, target_address=0x%08X name=%s, error mapping to virtual memory",
+        LOG_ERROR(
-                  GetObjectId(), target_address, name.c_str());
+            Kernel,
+            "cannot map id=%u, target_address=0x%08X name=%s, error mapping to virtual memory",
+            GetObjectId(), target_address, name.c_str());
        return result.Code();
    }
-    return target_process->vm_manager.ReprotectRange(target_address, size, ConvertPermissions(permissions));
+    return target_process->vm_manager.ReprotectRange(target_address, size,
+                                                     ConvertPermissions(permissions));
 }
 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.
+    // TODO(Subv): Verify what happens if the application tries to unmap an address that is not
+    // mapped to a SharedMemory.
    return target_process->vm_manager.UnmapRange(address, size);
 }
 VMAPermission SharedMemory::ConvertPermissions(MemoryPermission permission) {
-    u32 masked_permissions = static_cast<u32>(permission) & static_cast<u32>(MemoryPermission::ReadWriteExecute);
+    u32 masked_permissions =
+        static_cast<u32>(permission) & static_cast<u32>(MemoryPermission::ReadWriteExecute);
    return static_cast<VMAPermission>(masked_permissions);
 };
diff --git a/src/core/hle/kernel/shared_memory.h b/src/core/hle/kernel/shared_memory.h
index 0c404a9f8..afb142380 100644
--- a/src/core/hle/kernel/shared_memory.h
+++ b/src/core/hle/kernel/shared_memory.h
@@ -16,15 +16,15 @@ namespace Kernel {
 /// Permissions for mapped shared memory blocks
 enum class MemoryPermission : u32 {
-    None             = 0,
+    None = 0,
-    Read             = (1u <<  0),
+    Read = (1u << 0),
-    Write            = (1u <<  1),
+    Write = (1u << 1),
-    ReadWrite        = (Read | Write),
+    ReadWrite = (Read | Write),
-    Execute          = (1u <<  2),
+    Execute = (1u << 2),
-    ReadExecute      = (Read | Execute),
+    ReadExecute = (Read | Execute),
-    WriteExecute     = (Write | Execute),
+    WriteExecute = (Write | Execute),
    ReadWriteExecute = (Read | Write | Execute),
-    DontCare         = (1u << 28)
+    DontCare = (1u << 28)
 };
 class SharedMemory final : public Object {
@@ -34,13 +34,18 @@ public:
     * @param owner_process Process that created this shared memory object.
     * @param size Size of the memory block. Must be page-aligned.
     * @param permissions Permission restrictions applied to the process which created the block.
-     * @param other_permissions Permission restrictions applied to other processes mapping the block.
+     * @param other_permissions Permission restrictions applied to other processes mapping the
+     * block.
     * @param address The address from which to map the Shared Memory.
-     * @param region If the address is 0, the shared memory will be allocated in this region of the linear heap.
+     * @param region If the address is 0, the shared memory will be allocated in this region of the
+     * linear heap.
     * @param name Optional object name, used for debugging purposes.
     */
-    static SharedPtr<SharedMemory> Create(SharedPtr<Process> owner_process, u32 size, MemoryPermission permissions,
+    static SharedPtr<SharedMemory> Create(SharedPtr<Process> owner_process, u32 size,
-            MemoryPermission other_permissions, VAddr address = 0, MemoryRegion region = MemoryRegion::BASE, std::string name = "Unknown");
+                                          MemoryPermission permissions,
+                                          MemoryPermission other_permissions, VAddr address = 0,
+                                          MemoryRegion region = MemoryRegion::BASE,
+                                          std::string name = "Unknown");
    /**
     * Creates a shared memory object from a block of memory managed by an HLE applet.
@@ -48,17 +53,27 @@ public:
     * @param offset The offset into the heap block that the SharedMemory will map.
     * @param size Size of the memory block. Must be page-aligned.
     * @param permissions Permission restrictions applied to the process which created the block.
-     * @param other_permissions Permission restrictions applied to other processes mapping the block.
+     * @param other_permissions Permission restrictions applied to other processes mapping the
+     * block.
     * @param name Optional object name, used for debugging purposes.
     */
-    static SharedPtr<SharedMemory> CreateForApplet(std::shared_ptr<std::vector<u8>> heap_block, u32 offset, u32 size,
+    static SharedPtr<SharedMemory> CreateForApplet(std::shared_ptr<std::vector<u8>> heap_block,
-                                                   MemoryPermission permissions, MemoryPermission other_permissions, std::string name = "Unknown Applet");
+                                                   u32 offset, u32 size,
+                                                   MemoryPermission permissions,
-    std::string GetTypeName() const override { return "SharedMemory"; }
+                                                   MemoryPermission other_permissions,
-    std::string GetName() const override { return name; }
+                                                   std::string name = "Unknown Applet");
+    std::string GetTypeName() const override {
+        return "SharedMemory";
+    }
+    std::string GetName() const override {
+        return name;
+    }
    static const HandleType HANDLE_TYPE = HandleType::SharedMemory;
-    HandleType GetHandleType() const override { return HANDLE_TYPE; }
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
    /**
     * Converts the specified MemoryPermission into the equivalent VMAPermission.
@@ -73,7 +88,8 @@ 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, MemoryPermission other_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
@@ -94,7 +110,8 @@ public:
    SharedPtr<Process> owner_process;
    /// Address of shared memory block in the owner process if specified.
    VAddr base_address;
-    /// Physical address of the shared memory block in the linear heap if no address was specified during creation.
+    /// Physical address of the shared memory block in the linear heap if no address was specified
+    /// during creation.
    PAddr linear_heap_phys_address;
    /// Backing memory for this shared memory block.
    std::shared_ptr<std::vector<u8>> backing_block;
diff --git a/src/core/hle/kernel/thread.cpp b/src/core/hle/kernel/thread.cpp
index f1e5cf3cb..59272715f 100644
--- a/src/core/hle/kernel/thread.cpp
+++ b/src/core/hle/kernel/thread.cpp
@@ -18,10 +18,10 @@
 #include "core/core_timing.h"
 #include "core/hle/hle.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/process.h"
-#include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/mutex.h"
+#include "core/hle/kernel/process.h"
+#include "core/hle/kernel/thread.h"
 #include "core/hle/result.h"
 #include "core/memory.h"
@@ -46,7 +46,7 @@ static Kernel::HandleTable wakeup_callback_handle_table;
 static std::vector<SharedPtr<Thread>> thread_list;
 // Lists only ready thread ids.
-static Common::ThreadQueueList<Thread*, THREADPRIO_LOWEST+1> ready_queue;
+static Common::ThreadQueueList<Thread*, THREADPRIO_LOWEST + 1> ready_queue;
 static Thread* current_thread;
@@ -61,8 +61,10 @@ inline static u32 const NewThreadId() {
    return next_thread_id++;
 }
-Thread::Thread() {}
+Thread::Thread() {
-Thread::~Thread() {}
+}
+Thread::~Thread() {
+}
 Thread* GetCurrentThread() {
    return current_thread;
@@ -103,7 +105,7 @@ void Thread::Stop() {
    // Clean up thread from ready queue
    // This is only needed when the thread is termintated forcefully (SVC TerminateProcess)
-    if (status == THREADSTATUS_READY){
+    if (status == THREADSTATUS_READY) {
        ready_queue.remove(current_priority, this);
    }
@@ -119,7 +121,8 @@ void Thread::Stop() {
    // Mark the TLS slot in the thread's page as free.
    u32 tls_page = (tls_address - Memory::TLS_AREA_VADDR) / Memory::PAGE_SIZE;
-    u32 tls_slot = ((tls_address - Memory::TLS_AREA_VADDR) % Memory::PAGE_SIZE) / Memory::TLS_ENTRY_SIZE;
+    u32 tls_slot =
+        ((tls_address - Memory::TLS_AREA_VADDR) % Memory::PAGE_SIZE) / Memory::TLS_ENTRY_SIZE;
    Kernel::g_current_process->tls_slots[tls_page].reset(tls_slot);
    HLE::Reschedule(__func__);
@@ -137,7 +140,7 @@ Thread* ArbitrateHighestPriorityThread(u32 address) {
        if (thread == nullptr)
            continue;
-        if(thread->current_priority <= priority) {
+        if (thread->current_priority <= priority) {
            highest_priority_thread = thread.get();
            priority = thread->current_priority;
        }
@@ -170,7 +173,7 @@ static void PriorityBoostStarvedThreads() {
        // on hardware. However, this is almost certainly not perfect, and the real CTR OS scheduler
        // should probably be reversed to verify this.
-        const u64 boost_timeout = 2000000;  // Boost threads that have been ready for > this long
+        const u64 boost_timeout = 2000000; // Boost threads that have been ready for > this long
        u64 delta = current_ticks - thread->last_running_ticks;
@@ -193,10 +196,12 @@ static std::tuple<u32*, u32*> GetWaitSynchTimeoutParameterRegister(Thread* threa
    if ((thumb_mode && thumb_inst == 0xDF24) || (!thumb_mode && inst == 0x0F000024)) {
        // svc #0x24 (WaitSynchronization1)
-        return std::make_tuple(&thread->context.cpu_registers[2], &thread->context.cpu_registers[3]);
+        return std::make_tuple(&thread->context.cpu_registers[2],
+                               &thread->context.cpu_registers[3]);
    } else if ((thumb_mode && thumb_inst == 0xDF25) || (!thumb_mode && inst == 0x0F000025)) {
        // svc #0x25 (WaitSynchronizationN)
-        return std::make_tuple(&thread->context.cpu_registers[0], &thread->context.cpu_registers[4]);
+        return std::make_tuple(&thread->context.cpu_registers[0],
+                               &thread->context.cpu_registers[4]);
    }
    UNREACHABLE();
@@ -245,7 +250,8 @@ static void SwitchContext(Thread* new_thread) {
    // Load context of new thread
    if (new_thread) {
-        DEBUG_ASSERT_MSG(new_thread->status == THREADSTATUS_READY, "Thread must be ready to become running.");
+        DEBUG_ASSERT_MSG(new_thread->status == THREADSTATUS_READY,
+                         "Thread must be ready to become running.");
        // Cancel any outstanding wakeup events for this thread
        CoreTiming::UnscheduleEvent(ThreadWakeupEventType, new_thread->callback_handle);
@@ -263,7 +269,7 @@ static void SwitchContext(Thread* new_thread) {
            new_thread->context.pc -= thumb_mode ? 2 : 4;
            // Get the register for timeout parameter
-            u32* timeout_low, *timeout_high;
+            u32 *timeout_low, *timeout_high;
            std::tie(timeout_low, timeout_high) = GetWaitSynchTimeoutParameterRegister(new_thread);
            // Update the timeout parameter
@@ -307,7 +313,7 @@ static Thread* PopNextReadyThread() {
            // Otherwise just keep going with the current thread
            next = thread;
        }
-    } else  {
+    } else {
        next = ready_queue.pop_first();
    }
@@ -321,7 +327,8 @@ void WaitCurrentThread_Sleep() {
    HLE::Reschedule(__func__);
 }
-void WaitCurrentThread_WaitSynchronization(std::vector<SharedPtr<WaitObject>> wait_objects, bool wait_set_output, bool wait_all) {
+void WaitCurrentThread_WaitSynchronization(std::vector<SharedPtr<WaitObject>> wait_objects,
+                                           bool wait_set_output, bool wait_all) {
    Thread* thread = GetCurrentThread();
    thread->wait_set_output = wait_set_output;
    thread->wait_all = wait_all;
@@ -352,7 +359,8 @@ static void ThreadWakeupCallback(u64 thread_handle, int cycles_late) {
    if (thread->status == THREADSTATUS_WAIT_SYNCH || thread->status == THREADSTATUS_WAIT_ARB) {
        thread->SetWaitSynchronizationResult(ResultCode(ErrorDescription::Timeout, ErrorModule::OS,
-                                                        ErrorSummary::StatusChanged, ErrorLevel::Info));
+                                                        ErrorSummary::StatusChanged,
+                                                        ErrorLevel::Info));
        if (thread->wait_set_output)
            thread->SetWaitSynchronizationOutput(-1);
@@ -372,25 +380,25 @@ void Thread::WakeAfterDelay(s64 nanoseconds) {
 void Thread::ResumeFromWait() {
    switch (status) {
-        case THREADSTATUS_WAIT_SYNCH:
+    case THREADSTATUS_WAIT_SYNCH:
-        case THREADSTATUS_WAIT_ARB:
+    case THREADSTATUS_WAIT_ARB:
-        case THREADSTATUS_WAIT_SLEEP:
+    case THREADSTATUS_WAIT_SLEEP:
-            break;
+        break;
-        case THREADSTATUS_READY:
+    case THREADSTATUS_READY:
-            // If the thread is waiting on multiple wait objects, it might be awoken more than once
+        // If the thread is waiting on multiple wait objects, it might be awoken more than once
-            // before actually resuming. We can ignore subsequent wakeups if the thread status has
+        // before actually resuming. We can ignore subsequent wakeups if the thread status has
-            // already been set to THREADSTATUS_READY.
+        // already been set to THREADSTATUS_READY.
-            return;
+        return;
-        case THREADSTATUS_RUNNING:
+    case THREADSTATUS_RUNNING:
-            DEBUG_ASSERT_MSG(false, "Thread with object id %u has already resumed.", GetObjectId());
+        DEBUG_ASSERT_MSG(false, "Thread with object id %u has already resumed.", GetObjectId());
-            return;
+        return;
-        case THREADSTATUS_DEAD:
+    case THREADSTATUS_DEAD:
-            // This should never happen, as threads must complete before being stopped.
+        // This should never happen, as threads must complete before being stopped.
-            DEBUG_ASSERT_MSG(false, "Thread with object id %u cannot be resumed because it's DEAD.",
+        DEBUG_ASSERT_MSG(false, "Thread with object id %u cannot be resumed because it's DEAD.",
-                GetObjectId());
+                         GetObjectId());
-            return;
+        return;
    }
    ready_queue.push_back(current_priority, this);
@@ -405,7 +413,8 @@ static void DebugThreadQueue() {
    if (!thread) {
        LOG_DEBUG(Kernel, "Current: NO CURRENT THREAD");
    } else {
-        LOG_DEBUG(Kernel, "0x%02X %u (current)", thread->current_priority, GetCurrentThread()->GetObjectId());
+        LOG_DEBUG(Kernel, "0x%02X %u (current)", thread->current_priority,
+                  GetCurrentThread()->GetObjectId());
    }
    for (auto& t : thread_list) {
@@ -448,7 +457,8 @@ std::tuple<u32, u32, bool> GetFreeThreadLocalSlot(std::vector<std::bitset<8>>& t
 * @param entry_point Address of entry point for execution
 * @param arg User argument for thread
 */
-static void ResetThreadContext(Core::ThreadContext& context, u32 stack_top, u32 entry_point, u32 arg) {
+static void ResetThreadContext(Core::ThreadContext& context, u32 stack_top, u32 entry_point,
+                               u32 arg) {
    memset(&context, 0, sizeof(Core::ThreadContext));
    context.cpu_registers[0] = arg;
@@ -458,11 +468,11 @@ static void ResetThreadContext(Core::ThreadContext& context, u32 stack_top, u32
 }
 ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point, s32 priority,
-        u32 arg, s32 processor_id, VAddr stack_top) {
+                                            u32 arg, s32 processor_id, VAddr stack_top) {
    if (priority < THREADPRIO_HIGHEST || priority > THREADPRIO_LOWEST) {
        s32 new_priority = MathUtil::Clamp<s32>(priority, THREADPRIO_HIGHEST, THREADPRIO_LOWEST);
-        LOG_WARNING(Kernel_SVC, "(name=%s): invalid priority=%d, clamping to %d",
+        LOG_WARNING(Kernel_SVC, "(name=%s): invalid priority=%d, clamping to %d", name.c_str(),
-            name.c_str(), priority, new_priority);
+                    priority, new_priority);
        // TODO(bunnei): Clamping to a valid priority is not necessarily correct behavior... Confirm
        // validity of this
        priority = new_priority;
@@ -472,7 +482,7 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
        LOG_ERROR(Kernel_SVC, "(name=%s): invalid entry %08x", name.c_str(), entry_point);
        // TODO: Verify error
        return ResultCode(ErrorDescription::InvalidAddress, ErrorModule::Kernel,
-                ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
+                          ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
    }
    SharedPtr<Thread> thread(new Thread);
@@ -511,8 +521,10 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
        auto& linheap_memory = memory_region->linear_heap_memory;
        if (linheap_memory->size() + Memory::PAGE_SIZE > memory_region->size) {
-            LOG_ERROR(Kernel_SVC, "Not enough space in region to allocate a new TLS page for thread");
+            LOG_ERROR(Kernel_SVC,
-            return ResultCode(ErrorDescription::OutOfMemory, ErrorModule::Kernel, ErrorSummary::OutOfResource, ErrorLevel::Permanent);
+                      "Not enough space in region to allocate a new TLS page for thread");
+            return ResultCode(ErrorDescription::OutOfMemory, ErrorModule::Kernel,
+                              ErrorSummary::OutOfResource, ErrorLevel::Permanent);
        }
        u32 offset = linheap_memory->size();
@@ -537,7 +549,8 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
    // Mark the slot as used
    tls_slots[available_page].set(available_slot);
-    thread->tls_address = Memory::TLS_AREA_VADDR + available_page * Memory::PAGE_SIZE + available_slot * Memory::TLS_ENTRY_SIZE;
+    thread->tls_address = Memory::TLS_AREA_VADDR + available_page * Memory::PAGE_SIZE +
+                          available_slot * Memory::TLS_ENTRY_SIZE;
    // TODO(peachum): move to ScheduleThread() when scheduler is added so selected core is used
    // to initialize the context
@@ -551,10 +564,12 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
    return MakeResult<SharedPtr<Thread>>(std::move(thread));
 }
-// TODO(peachum): Remove this. Range checking should be done, and an appropriate error should be returned.
+// TODO(peachum): Remove this. Range checking should be done, and an appropriate error should be
+// returned.
 static void ClampPriority(const Thread* thread, s32* priority) {
    if (*priority < THREADPRIO_HIGHEST || *priority > THREADPRIO_LOWEST) {
-        DEBUG_ASSERT_MSG(false, "Application passed an out of range priority. An error should be returned.");
+        DEBUG_ASSERT_MSG(
+            false, "Application passed an out of range priority. An error should be returned.");
        s32 new_priority = MathUtil::Clamp<s32>(*priority, THREADPRIO_HIGHEST, THREADPRIO_LOWEST);
        LOG_WARNING(Kernel_SVC, "(name=%s): invalid priority=%d, clamping to %d",
@@ -586,12 +601,13 @@ SharedPtr<Thread> SetupMainThread(u32 entry_point, s32 priority) {
    DEBUG_ASSERT(!GetCurrentThread());
    // Initialize new "main" thread
-    auto thread_res = Thread::Create("main", entry_point, priority, 0,
+    auto thread_res = Thread::Create("main", entry_point, priority, 0, THREADPROCESSORID_0,
-            THREADPROCESSORID_0, Memory::HEAP_VADDR_END);
+                                     Memory::HEAP_VADDR_END);
    SharedPtr<Thread> thread = thread_res.MoveFrom();
-    thread->context.fpscr = FPSCR_DEFAULT_NAN | FPSCR_FLUSH_TO_ZERO | FPSCR_ROUND_TOZERO | FPSCR_IXC; // 0x03C00010
+    thread->context.fpscr =
+        FPSCR_DEFAULT_NAN | FPSCR_FLUSH_TO_ZERO | FPSCR_ROUND_TOZERO | FPSCR_IXC; // 0x03C00010
    // Run new "main" thread
    SwitchContext(thread.get());
diff --git a/src/core/hle/kernel/thread.h b/src/core/hle/kernel/thread.h
index deab5d5a6..2ed5cf74e 100644
--- a/src/core/hle/kernel/thread.h
+++ b/src/core/hle/kernel/thread.h
@@ -17,29 +17,29 @@
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/result.h"
-enum ThreadPriority : s32{
+enum ThreadPriority : s32 {
-    THREADPRIO_HIGHEST          = 0,  ///< Highest thread priority
+    THREADPRIO_HIGHEST = 0,       ///< Highest thread priority
-    THREADPRIO_USERLAND_MAX     = 24, ///< Highest thread priority for userland apps
+    THREADPRIO_USERLAND_MAX = 24, ///< Highest thread priority for userland apps
-    THREADPRIO_DEFAULT          = 48, ///< Default thread priority for userland apps
+    THREADPRIO_DEFAULT = 48,      ///< Default thread priority for userland apps
-    THREADPRIO_LOWEST           = 63, ///< Lowest thread priority
+    THREADPRIO_LOWEST = 63,       ///< Lowest thread priority
 };
 enum ThreadProcessorId : s32 {
-    THREADPROCESSORID_DEFAULT   = -2, ///< Run thread on default core specified by exheader
+    THREADPROCESSORID_DEFAULT = -2, ///< Run thread on default core specified by exheader
-    THREADPROCESSORID_ALL       = -1, ///< Run thread on either core
+    THREADPROCESSORID_ALL = -1,     ///< Run thread on either core
-    THREADPROCESSORID_0         =  0, ///< Run thread on core 0 (AppCore)
+    THREADPROCESSORID_0 = 0,        ///< Run thread on core 0 (AppCore)
-    THREADPROCESSORID_1         =  1, ///< Run thread on core 1 (SysCore)
+    THREADPROCESSORID_1 = 1,        ///< Run thread on core 1 (SysCore)
-    THREADPROCESSORID_MAX       =  2, ///< Processor ID must be less than this
+    THREADPROCESSORID_MAX = 2,      ///< Processor ID must be less than this
 };
 enum ThreadStatus {
-    THREADSTATUS_RUNNING,       ///< Currently running
+    THREADSTATUS_RUNNING,    ///< Currently running
-    THREADSTATUS_READY,         ///< Ready to run
+    THREADSTATUS_READY,      ///< Ready to run
-    THREADSTATUS_WAIT_ARB,      ///< Waiting on an address arbiter
+    THREADSTATUS_WAIT_ARB,   ///< Waiting on an address arbiter
-    THREADSTATUS_WAIT_SLEEP,    ///< Waiting due to a SleepThread SVC
+    THREADSTATUS_WAIT_SLEEP, ///< Waiting due to a SleepThread SVC
-    THREADSTATUS_WAIT_SYNCH,    ///< Waiting due to a WaitSynchronization SVC
+    THREADSTATUS_WAIT_SYNCH, ///< Waiting due to a WaitSynchronization SVC
-    THREADSTATUS_DORMANT,       ///< Created but not yet made ready
+    THREADSTATUS_DORMANT,    ///< Created but not yet made ready
-    THREADSTATUS_DEAD           ///< Run to completion, or forcefully terminated
+    THREADSTATUS_DEAD        ///< Run to completion, or forcefully terminated
 };
 namespace Kernel {
@@ -60,13 +60,19 @@ public:
     * @return A shared pointer to the newly created thread
     */
    static ResultVal<SharedPtr<Thread>> Create(std::string name, VAddr entry_point, s32 priority,
-        u32 arg, s32 processor_id, VAddr stack_top);
+                                               u32 arg, s32 processor_id, VAddr stack_top);
-    std::string GetName() const override { return name; }
+    std::string GetName() const override {
-    std::string GetTypeName() const override { return "Thread"; }
+        return name;
+    }
+    std::string GetTypeName() const override {
+        return "Thread";
+    }
    static const HandleType HANDLE_TYPE = HandleType::Thread;
-    HandleType GetHandleType() const override { return HANDLE_TYPE; }
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
    bool ShouldWait() override;
    void Acquire() override;
@@ -75,7 +81,9 @@ public:
     * Gets the thread's current priority
     * @return The current thread's priority
     */
-    s32 GetPriority() const { return current_priority; }
+    s32 GetPriority() const {
+        return current_priority;
+    }
    /**
     * Sets the thread's current priority
@@ -93,7 +101,9 @@ public:
     * Gets the thread's thread ID
     * @return The thread's ID
     */
-    u32 GetThreadId() const { return thread_id; }
+    u32 GetThreadId() const {
+        return thread_id;
+    }
    /**
     * Resumes a thread from waiting
@@ -127,7 +137,9 @@ public:
     * Returns the Thread Local Storage address of the current thread
     * @returns VAddr of the thread's TLS
     */
-    VAddr GetTLSAddress() const { return tls_address; }
+    VAddr GetTLSAddress() const {
+        return tls_address;
+    }
    Core::ThreadContext context;
@@ -137,8 +149,8 @@ public:
    u32 entry_point;
    u32 stack_top;
-    s32 nominal_priority;   ///< Nominal thread priority, as set by the emulated application
+    s32 nominal_priority; ///< Nominal thread priority, as set by the emulated application
-    s32 current_priority;   ///< Current thread priority, can be temporarily changed
+    s32 current_priority; ///< Current thread priority, can be temporarily changed
    u64 last_running_ticks; ///< CPU tick when thread was last running
@@ -151,11 +163,11 @@ public:
    /// Mutexes currently held by this thread, which will be released when it exits.
    boost::container::flat_set<SharedPtr<Mutex>> held_mutexes;
-    SharedPtr<Process> owner_process; ///< Process that owns this thread
+    SharedPtr<Process> owner_process;                ///< Process that owns this thread
    std::vector<SharedPtr<WaitObject>> wait_objects; ///< Objects that the thread is waiting on
-    VAddr wait_address;     ///< If waiting on an AddressArbiter, this is the arbitration address
+    VAddr wait_address;   ///< If waiting on an AddressArbiter, this is the arbitration address
-    bool wait_all;          ///< True if the thread is waiting on all objects before resuming
+    bool wait_all;        ///< True if the thread is waiting on all objects before resuming
-    bool wait_set_output;   ///< True if the output parameter should be set on thread wakeup
+    bool wait_set_output; ///< True if the output parameter should be set on thread wakeup
    std::string name;
@@ -205,10 +217,12 @@ void WaitCurrentThread_Sleep();
 /**
 * Waits the current thread from a WaitSynchronization call
 * @param wait_objects Kernel objects that we are waiting on
- * @param wait_set_output If true, set the output parameter on thread wakeup (for WaitSynchronizationN only)
+ * @param wait_set_output If true, set the output parameter on thread wakeup (for
+ * WaitSynchronizationN only)
 * @param wait_all If true, wait on all objects before resuming (for WaitSynchronizationN only)
 */
-void WaitCurrentThread_WaitSynchronization(std::vector<SharedPtr<WaitObject>> wait_objects, bool wait_set_output, bool wait_all);
+void WaitCurrentThread_WaitSynchronization(std::vector<SharedPtr<WaitObject>> wait_objects,
+                                           bool wait_set_output, bool wait_all);
 /**
 * Waits the current thread from an ArbitrateAddress call
diff --git a/src/core/hle/kernel/timer.cpp b/src/core/hle/kernel/timer.cpp
index b8daaeede..255cb1aca 100644
--- a/src/core/hle/kernel/timer.cpp
+++ b/src/core/hle/kernel/timer.cpp
@@ -9,8 +9,8 @@
 #include "core/core_timing.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/timer.h"
 #include "core/hle/kernel/thread.h"
+#include "core/hle/kernel/timer.h"
 namespace Kernel {
@@ -20,8 +20,10 @@ static int timer_callback_event_type;
 //               us to simply use a pool index or similar.
 static Kernel::HandleTable timer_callback_handle_table;
-Timer::Timer() {}
+Timer::Timer() {
-Timer::~Timer() {}
+}
+Timer::~Timer() {
+}
 SharedPtr<Timer> Timer::Create(ResetType reset_type, std::string name) {
    SharedPtr<Timer> timer(new Timer);
@@ -41,7 +43,7 @@ bool Timer::ShouldWait() {
 }
 void Timer::Acquire() {
-    ASSERT_MSG( !ShouldWait(), "object unavailable!");
+    ASSERT_MSG(!ShouldWait(), "object unavailable!");
    if (reset_type == ResetType::OneShot)
        signaled = false;
@@ -55,8 +57,8 @@ void Timer::Set(s64 initial, s64 interval) {
    interval_delay = interval;
    u64 initial_microseconds = initial / 1000;
-    CoreTiming::ScheduleEvent(usToCycles(initial_microseconds),
+    CoreTiming::ScheduleEvent(usToCycles(initial_microseconds), timer_callback_event_type,
-            timer_callback_event_type, callback_handle);
+                              callback_handle);
    HLE::Reschedule(__func__);
 }
@@ -73,7 +75,8 @@ void Timer::Clear() {
 /// The timer callback event, called when a timer is fired
 static void TimerCallback(u64 timer_handle, int cycles_late) {
-    SharedPtr<Timer> timer = timer_callback_handle_table.Get<Timer>(static_cast<Handle>(timer_handle));
+    SharedPtr<Timer> timer =
+        timer_callback_handle_table.Get<Timer>(static_cast<Handle>(timer_handle));
    if (timer == nullptr) {
        LOG_CRITICAL(Kernel, "Callback fired for invalid timer %08" PRIx64, timer_handle);
@@ -91,7 +94,7 @@ static void TimerCallback(u64 timer_handle, int cycles_late) {
        // Reschedule the timer with the interval delay
        u64 interval_microseconds = timer->interval_delay / 1000;
        CoreTiming::ScheduleEvent(usToCycles(interval_microseconds) - cycles_late,
-                timer_callback_event_type, timer_handle);
+                                  timer_callback_event_type, timer_handle);
    }
 }
diff --git a/src/core/hle/kernel/timer.h b/src/core/hle/kernel/timer.h
index b1db60e8f..97cd0d63c 100644
--- a/src/core/hle/kernel/timer.h
+++ b/src/core/hle/kernel/timer.h
@@ -21,19 +21,25 @@ public:
     */
    static SharedPtr<Timer> Create(ResetType reset_type, std::string name = "Unknown");
-    std::string GetTypeName() const override { return "Timer"; }
+    std::string GetTypeName() const override {
-    std::string GetName() const override { return name; }
+        return "Timer";
+    }
+    std::string GetName() const override {
+        return name;
+    }
    static const HandleType HANDLE_TYPE = HandleType::Timer;
-    HandleType GetHandleType() const override { return HANDLE_TYPE; }
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
-    ResetType reset_type;                   ///< The ResetType of this timer
+    ResetType reset_type; ///< The ResetType of this timer
-    bool signaled;                          ///< Whether the timer has been signaled or not
+    bool signaled;    ///< Whether the timer has been signaled or not
-    std::string name;                       ///< Name of timer (optional)
+    std::string name; ///< Name of timer (optional)
-    u64 initial_delay;                      ///< The delay until the timer fires for the first time
+    u64 initial_delay;  ///< The delay until the timer fires for the first time
-    u64 interval_delay;                     ///< The delay until the timer fires after the first time
+    u64 interval_delay; ///< The delay until the timer fires after the first time
    bool ShouldWait() override;
    void Acquire() override;
diff --git a/src/core/hle/kernel/vm_manager.cpp b/src/core/hle/kernel/vm_manager.cpp
index 066146cff..4ad86cf48 100644
--- a/src/core/hle/kernel/vm_manager.cpp
+++ b/src/core/hle/kernel/vm_manager.cpp
@@ -15,8 +15,8 @@ namespace Kernel {
 static const char* GetMemoryStateName(MemoryState state) {
    static const char* names[] = {
-        "Free", "Reserved", "IO", "Static", "Code", "Private", "Shared", "Continuous", "Aliased",
+        "Free",   "Reserved",   "IO",      "Static", "Code",      "Private",
-        "Alias", "AliasCode", "Locked",
+        "Shared", "Continuous", "Aliased", "Alias",  "AliasCode", "Locked",
    };
    return names[(int)state];
@@ -24,13 +24,12 @@ static const char* GetMemoryStateName(MemoryState state) {
 bool VirtualMemoryArea::CanBeMergedWith(const VirtualMemoryArea& next) const {
    ASSERT(base + size == next.base);
-    if (permissions != next.permissions ||
+    if (permissions != next.permissions || meminfo_state != next.meminfo_state ||
-            meminfo_state != next.meminfo_state ||
+        type != next.type) {
-            type != next.type) {
        return false;
    }
    if (type == VMAType::AllocatedMemoryBlock &&
-            (backing_block != next.backing_block || offset + size != next.offset)) {
+        (backing_block != next.backing_block || offset + size != next.offset)) {
        return false;
    }
    if (type == VMAType::BackingMemory && backing_memory + size != next.backing_memory) {
@@ -70,7 +69,9 @@ VMManager::VMAHandle VMManager::FindVMA(VAddr target) const {
 }
 ResultVal<VMManager::VMAHandle> VMManager::MapMemoryBlock(VAddr target,
-        std::shared_ptr<std::vector<u8>> block, size_t offset, u32 size, MemoryState state) {
+                                                          std::shared_ptr<std::vector<u8>> block,
+                                                          size_t offset, u32 size,
+                                                          MemoryState state) {
    ASSERT(block != nullptr);
    ASSERT(offset + size <= block->size());
@@ -89,7 +90,8 @@ ResultVal<VMManager::VMAHandle> VMManager::MapMemoryBlock(VAddr target,
    return MakeResult<VMAHandle>(MergeAdjacent(vma_handle));
 }
-ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, u8 * memory, u32 size, MemoryState state) {
+ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, u8* memory, u32 size,
+                                                            MemoryState state) {
    ASSERT(memory != nullptr);
    // This is the appropriately sized VMA that will turn into our allocation.
@@ -106,7 +108,9 @@ ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, u8 * m
    return MakeResult<VMAHandle>(MergeAdjacent(vma_handle));
 }
-ResultVal<VMManager::VMAHandle> VMManager::MapMMIO(VAddr target, PAddr paddr, u32 size, MemoryState state, Memory::MMIORegionPointer mmio_handler) {
+ResultVal<VMManager::VMAHandle> VMManager::MapMMIO(VAddr target, PAddr paddr, u32 size,
+                                                   MemoryState state,
+                                                   Memory::MMIORegionPointer mmio_handler) {
    // This is the appropriately sized VMA that will turn into our allocation.
    CASCADE_RESULT(VMAIter vma_handle, CarveVMA(target, size));
    VirtualMemoryArea& final_vma = vma_handle->second;
@@ -191,15 +195,16 @@ void VMManager::RefreshMemoryBlockMappings(const std::vector<u8>* block) {
 void VMManager::LogLayout(Log::Level log_level) const {
    for (const auto& p : vma_map) {
        const VirtualMemoryArea& vma = p.second;
-        LOG_GENERIC(Log::Class::Kernel, log_level, "%08X - %08X  size: %8X %c%c%c %s",
+        LOG_GENERIC(Log::Class::Kernel, log_level, "%08X - %08X  size: %8X %c%c%c %s", vma.base,
-            vma.base, vma.base + vma.size, vma.size,
+                    vma.base + vma.size, vma.size,
-            (u8)vma.permissions & (u8)VMAPermission::Read    ? 'R' : '-',
+                    (u8)vma.permissions & (u8)VMAPermission::Read ? 'R' : '-',
-            (u8)vma.permissions & (u8)VMAPermission::Write   ? 'W' : '-',
+                    (u8)vma.permissions & (u8)VMAPermission::Write ? 'W' : '-',
-            (u8)vma.permissions & (u8)VMAPermission::Execute ? 'X' : '-', GetMemoryStateName(vma.meminfo_state));
+                    (u8)vma.permissions & (u8)VMAPermission::Execute ? 'X' : '-',
+                    GetMemoryStateName(vma.meminfo_state));
    }
 }
-VMManager::VMAIter VMManager::StripIterConstness(const VMAHandle & iter) {
+VMManager::VMAIter VMManager::StripIterConstness(const VMAHandle& iter) {
    // This uses a neat C++ trick to convert a const_iterator to a regular iterator, given
    // non-const access to its container.
    return vma_map.erase(iter, iter); // Erases an empty range of elements
@@ -337,5 +342,4 @@ void VMManager::UpdatePageTableForVMA(const VirtualMemoryArea& vma) {
        break;
    }
 }
 }
diff --git a/src/core/hle/kernel/vm_manager.h b/src/core/hle/kernel/vm_manager.h
index 91d40655b..fbcd9870f 100644
--- a/src/core/hle/kernel/vm_manager.h
+++ b/src/core/hle/kernel/vm_manager.h
@@ -15,13 +15,13 @@
 namespace Kernel {
-const ResultCode ERR_INVALID_ADDRESS{ // 0xE0E01BF5
+const ResultCode ERR_INVALID_ADDRESS{// 0xE0E01BF5
-        ErrorDescription::InvalidAddress, ErrorModule::OS,
+                                     ErrorDescription::InvalidAddress, ErrorModule::OS,
-        ErrorSummary::InvalidArgument, ErrorLevel::Usage};
+                                     ErrorSummary::InvalidArgument, ErrorLevel::Usage};
-const ResultCode ERR_INVALID_ADDRESS_STATE{ // 0xE0A01BF5
+const ResultCode ERR_INVALID_ADDRESS_STATE{// 0xE0A01BF5
-        ErrorDescription::InvalidAddress, ErrorModule::OS,
+                                           ErrorDescription::InvalidAddress, ErrorModule::OS,
-        ErrorSummary::InvalidState, ErrorLevel::Usage};
+                                           ErrorSummary::InvalidState, ErrorLevel::Usage};
 enum class VMAType : u8 {
    /// VMA represents an unmapped region of the address space.
@@ -115,7 +115,8 @@ class VMManager final {
    // TODO(yuriks): Make page tables switchable to support multiple VMManagers
 public:
    /**
-     * The maximum amount of address space managed by the kernel. Addresses above this are never used.
+     * The maximum amount of address space managed by the kernel. Addresses above this are never
+     * used.
     * @note This is the limit used by the New 3DS kernel. Old 3DS used 0x20000000.
     */
    static const u32 MAX_ADDRESS = 0x40000000;
@@ -151,7 +152,7 @@ public:
     * @param state MemoryState tag to attach to the VMA.
     */
    ResultVal<VMAHandle> MapMemoryBlock(VAddr target, std::shared_ptr<std::vector<u8>> block,
-            size_t offset, u32 size, MemoryState state);
+                                        size_t offset, u32 size, MemoryState state);
    /**
     * Maps an unmanaged host memory pointer at a given address.
@@ -172,7 +173,8 @@ public:
     * @param state MemoryState tag to attach to the VMA.
     * @param mmio_handler The handler that will implement read and write for this MMIO region.
     */
-    ResultVal<VMAHandle> MapMMIO(VAddr target, PAddr paddr, u32 size, MemoryState state, Memory::MMIORegionPointer mmio_handler);
+    ResultVal<VMAHandle> MapMMIO(VAddr target, PAddr paddr, u32 size, MemoryState state,
+                                 Memory::MMIORegionPointer mmio_handler);
    /// Unmaps a range of addresses, splitting VMAs as necessary.
    ResultCode UnmapRange(VAddr target, u32 size);
@@ -228,5 +230,4 @@ private:
    /// Updates the pages corresponding to this VMA so they match the VMA's attributes.
    void UpdatePageTableForVMA(const VirtualMemoryArea& vma);
 };
 }
diff --git a/src/core/hle/result.h b/src/core/hle/result.h
index 268a8dad2..6e3dd9cd2 100644
--- a/src/core/hle/result.h
+++ b/src/core/hle/result.h
@@ -26,7 +26,8 @@ enum class ErrorDescription : u32 {
    FS_InvalidOpenFlags = 230,
    FS_NotAFile = 250,
    FS_NotFormatted = 340, ///< This is used by the FS service when creating a SaveData archive
-    OutofRangeOrMisalignedAddress = 513, // TODO(purpasmart): Check if this name fits its actual usage
+    OutofRangeOrMisalignedAddress =
+        513, // TODO(purpasmart): Check if this name fits its actual usage
    GPU_FirstInitialization = 519,
    FS_InvalidPath = 702,
    InvalidSection = 1000,
@@ -168,15 +169,15 @@ enum class ErrorSummary : u32 {
    Success = 0,
    NothingHappened = 1,
    WouldBlock = 2,
-    OutOfResource = 3,      ///< There are no more kernel resources (memory, table slots) to
+    OutOfResource = 3, ///< There are no more kernel resources (memory, table slots) to
-                            ///< execute the operation.
+                       ///< execute the operation.
-    NotFound = 4,           ///< A file or resource was not found.
+    NotFound = 4,      ///< A file or resource was not found.
    InvalidState = 5,
-    NotSupported = 6,       ///< The operation is not supported or not implemented.
+    NotSupported = 6,    ///< The operation is not supported or not implemented.
-    InvalidArgument = 7,    ///< Returned when a passed argument is invalid in the current runtime
+    InvalidArgument = 7, ///< Returned when a passed argument is invalid in the current runtime
-                            ///< context. (Invalid handle, out-of-bounds pointer or size, etc.)
+                         ///< context. (Invalid handle, out-of-bounds pointer or size, etc.)
-    WrongArgument = 8,      ///< Returned when a passed argument is in an incorrect format for use
+    WrongArgument = 8,   ///< Returned when a passed argument is in an incorrect format for use
-                            ///< with the function. (E.g. Invalid enum value)
+                         ///< with the function. (E.g. Invalid enum value)
    Canceled = 9,
    StatusChanged = 10,
    Internal = 11,
@@ -208,19 +209,25 @@ union ResultCode {
    BitField<21, 6, ErrorSummary> summary;
    BitField<27, 5, ErrorLevel> level;
-    // The last bit of `level` is checked by apps and the kernel to determine if a result code is an error
+    // The last bit of `level` is checked by apps and the kernel to determine if a result code is an
+    // error
    BitField<31, 1, u32> is_error;
-    explicit ResultCode(u32 raw) : raw(raw) {}
+    explicit ResultCode(u32 raw) : raw(raw) {
-    ResultCode(ErrorDescription description_, ErrorModule module_,
+    }
-            ErrorSummary summary_, ErrorLevel level_) : raw(0) {
+    ResultCode(ErrorDescription description_, ErrorModule module_, ErrorSummary summary_,
+               ErrorLevel level_)
+        : raw(0) {
        description.Assign(description_);
        module.Assign(module_);
        summary.Assign(summary_);
        level.Assign(level_);
    }
-    ResultCode& operator=(const ResultCode& o) { raw = o.raw; return *this; }
+    ResultCode& operator=(const ResultCode& o) {
+        raw = o.raw;
+        return *this;
+    }
    bool IsSuccess() const {
        return is_error == 0;
@@ -246,8 +253,8 @@ const ResultCode RESULT_SUCCESS(0);
 /// Might be returned instead of a dummy success for unimplemented APIs.
 inline ResultCode UnimplementedFunction(ErrorModule module) {
-    return ResultCode(ErrorDescription::NotImplemented, module,
+    return ResultCode(ErrorDescription::NotImplemented, module, ErrorSummary::NotSupported,
-            ErrorSummary::NotSupported, ErrorLevel::Permanent);
+                      ErrorLevel::Permanent);
 }
 /**
@@ -285,10 +292,9 @@ inline ResultCode UnimplementedFunction(ErrorModule module) {
 template <typename T>
 class ResultVal {
 public:
-    /// Constructs an empty `ResultVal` with the given error code. The code must not be a success code.
+    /// Constructs an empty `ResultVal` with the given error code. The code must not be a success
-    ResultVal(ResultCode error_code = ResultCode(-1))
+    /// code.
-        : result_code(error_code)
+    ResultVal(ResultCode error_code = ResultCode(-1)) : result_code(error_code) {
-    {
        ASSERT(error_code.IsError());
    }
@@ -303,17 +309,13 @@ public:
        return result;
    }
-    ResultVal(const ResultVal& o)
+    ResultVal(const ResultVal& o) : result_code(o.result_code) {
-        : result_code(o.result_code)
-    {
        if (!o.empty()) {
            new (&object) T(o.object);
        }
    }
-    ResultVal(ResultVal&& o)
+    ResultVal(ResultVal&& o) : result_code(o.result_code) {
-        : result_code(o.result_code)
-    {
        if (!o.empty()) {
            new (&object) T(std::move(o.object));
        }
@@ -357,19 +359,35 @@ public:
    }
    /// Returns true if the `ResultVal` contains an error code and no value.
-    bool empty() const { return result_code.IsError(); }
+    bool empty() const {
+        return result_code.IsError();
+    }
    /// Returns true if the `ResultVal` contains a return value.
-    bool Succeeded() const { return result_code.IsSuccess(); }
+    bool Succeeded() const {
+        return result_code.IsSuccess();
+    }
    /// Returns true if the `ResultVal` contains an error code and no value.
-    bool Failed() const { return empty(); }
+    bool Failed() const {
+        return empty();
+    }
-    ResultCode Code() const { return result_code; }
+    ResultCode Code() const {
+        return result_code;
+    }
-    const T& operator* () const { return object; }
+    const T& operator*() const {
-          T& operator* ()       { return object; }
+        return object;
-    const T* operator->() const { return &object; }
+    }
-          T* operator->()       { return &object; }
+    T& operator*() {
+        return object;
+    }
+    const T* operator->() const {
+        return &object;
+    }
+    T* operator->() {
+        return &object;
+    }
    /// Returns the value contained in this `ResultVal`, or the supplied default if it is missing.
    template <typename U>
@@ -390,7 +408,9 @@ public:
 private:
    // A union is used to allocate the storage for the value, while allowing us to construct and
    // destruct it at will.
-    union { T object; };
+    union {
+        T object;
+    };
    ResultCode result_code;
 };
@@ -409,8 +429,8 @@ ResultVal<T> MakeResult(Args&&... args) {
 * variable declaration. If it fails the return code is returned from the current function. Thus it
 * can be used to cascade errors out, achieving something akin to exception handling.
 */
-#define CASCADE_RESULT(target, source) \
+#define CASCADE_RESULT(target, source)                                                             \
-        auto CONCAT2(check_result_L, __LINE__) = source; \
+    auto CONCAT2(check_result_L, __LINE__) = source;                                               \
-        if (CONCAT2(check_result_L, __LINE__).Failed()) \
+    if (CONCAT2(check_result_L, __LINE__).Failed())                                                \
-            return CONCAT2(check_result_L, __LINE__).Code(); \
+        return CONCAT2(check_result_L, __LINE__).Code();                                           \
-        target = std::move(*CONCAT2(check_result_L, __LINE__))
+    target = std::move(*CONCAT2(check_result_L, __LINE__))
diff --git a/src/core/hle/service/ac_u.cpp b/src/core/hle/service/ac_u.cpp
index 5241dd3e7..887b57529 100644
--- a/src/core/hle/service/ac_u.cpp
+++ b/src/core/hle/service/ac_u.cpp
@@ -47,7 +47,7 @@ static void GetWifiStatus(Service::Interface* self) {
    // it returns a valid result without implementing full functionality.
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
-    cmd_buff[2] = 0; // Connection type set to none
+    cmd_buff[2] = 0;                  // Connection type set to none
    LOG_WARNING(Service_AC, "(STUBBED) called");
 }
@@ -62,29 +62,29 @@ static void IsConnected(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
-    cmd_buff[2] = false; // Not connected to ac:u service
+    cmd_buff[2] = false;              // Not connected to ac:u service
    LOG_WARNING(Service_AC, "(STUBBED) called");
 }
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010000, nullptr,               "CreateDefaultConfig"},
+    {0x00010000, nullptr, "CreateDefaultConfig"},
-    {0x00040006, nullptr,               "ConnectAsync"},
+    {0x00040006, nullptr, "ConnectAsync"},
-    {0x00050002, nullptr,               "GetConnectResult"},
+    {0x00050002, nullptr, "GetConnectResult"},
-    {0x00080004, CloseAsync,            "CloseAsync"},
+    {0x00080004, CloseAsync, "CloseAsync"},
-    {0x00090002, nullptr,               "GetCloseResult"},
+    {0x00090002, nullptr, "GetCloseResult"},
-    {0x000A0000, nullptr,               "GetLastErrorCode"},
+    {0x000A0000, nullptr, "GetLastErrorCode"},
-    {0x000D0000, GetWifiStatus,         "GetWifiStatus"},
+    {0x000D0000, GetWifiStatus, "GetWifiStatus"},
-    {0x000E0042, nullptr,               "GetCurrentAPInfo"},
+    {0x000E0042, nullptr, "GetCurrentAPInfo"},
-    {0x00100042, nullptr,               "GetCurrentNZoneInfo"},
+    {0x00100042, nullptr, "GetCurrentNZoneInfo"},
-    {0x00110042, nullptr,               "GetNZoneApNumService"},
+    {0x00110042, nullptr, "GetNZoneApNumService"},
-    {0x00240042, nullptr,               "AddDenyApType"},
+    {0x00240042, nullptr, "AddDenyApType"},
-    {0x00270002, nullptr,               "GetInfraPriority"},
+    {0x00270002, nullptr, "GetInfraPriority"},
-    {0x002D0082, nullptr,               "SetRequestEulaVersion"},
+    {0x002D0082, nullptr, "SetRequestEulaVersion"},
-    {0x00300004, nullptr,               "RegisterDisconnectEvent"},
+    {0x00300004, nullptr, "RegisterDisconnectEvent"},
-    {0x003C0042, nullptr,               "GetAPSSIDList"},
+    {0x003C0042, nullptr, "GetAPSSIDList"},
-    {0x003E0042, IsConnected,           "IsConnected"},
+    {0x003E0042, IsConnected, "IsConnected"},
-    {0x00400042, nullptr,               "SetClientVersion"},
+    {0x00400042, nullptr, "SetClientVersion"},
 };
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index 3f71e7f2b..b653523a4 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -6,19 +6,19 @@
 #include "common/logging/log.h"
-#include "core/hle/service/service.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/am_app.h"
 #include "core/hle/service/am/am_net.h"
 #include "core/hle/service/am/am_sys.h"
 #include "core/hle/service/am/am_u.h"
+#include "core/hle/service/service.h"
 namespace Service {
 namespace AM {
-static std::array<u32, 3> am_content_count = { 0, 0, 0 };
+static std::array<u32, 3> am_content_count = {0, 0, 0};
-static std::array<u32, 3> am_titles_count = { 0, 0, 0 };
+static std::array<u32, 3> am_titles_count = {0, 0, 0};
-static std::array<u32, 3> am_titles_list_count = { 0, 0, 0 };
+static std::array<u32, 3> am_titles_list_count = {0, 0, 0};
 static u32 am_ticket_count = 0;
 static u32 am_ticket_list_count = 0;
@@ -29,7 +29,8 @@ void GetTitleCount(Service::Interface* self) {
    cmd_buff[1] = RESULT_SUCCESS.raw;
    cmd_buff[2] = am_titles_count[media_type];
-    LOG_WARNING(Service_AM, "(STUBBED) media_type=%u, title_count=0x%08x", media_type, am_titles_count[media_type]);
+    LOG_WARNING(Service_AM, "(STUBBED) media_type=%u, title_count=0x%08x", media_type,
+                am_titles_count[media_type]);
 }
 void FindContentInfos(Service::Interface* self) {
@@ -43,8 +44,10 @@ void FindContentInfos(Service::Interface* self) {
    am_content_count[media_type] = cmd_buff[4];
    cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_WARNING(Service_AM, "(STUBBED) media_type=%u, title_id=0x%016llx, content_cound=%u, content_ids_pointer=0x%08x, content_info_pointer=0x%08x",
+    LOG_WARNING(Service_AM, "(STUBBED) media_type=%u, title_id=0x%016llx, content_cound=%u, "
-                media_type, title_id, am_content_count[media_type], content_ids_pointer, content_info_pointer);
+                            "content_ids_pointer=0x%08x, content_info_pointer=0x%08x",
+                media_type, title_id, am_content_count[media_type], content_ids_pointer,
+                content_info_pointer);
 }
 void ListContentInfos(Service::Interface* self) {
@@ -59,8 +62,10 @@ void ListContentInfos(Service::Interface* self) {
    cmd_buff[1] = RESULT_SUCCESS.raw;
    cmd_buff[2] = am_content_count[media_type];
-    LOG_WARNING(Service_AM, "(STUBBED) media_type=%u, content_count=%u, title_id=0x%016" PRIx64 ", start_index=0x%08x, content_info_pointer=0x%08X",
+    LOG_WARNING(Service_AM, "(STUBBED) media_type=%u, content_count=%u, title_id=0x%016" PRIx64
-                media_type, am_content_count[media_type], title_id, start_index, content_info_pointer);
+                            ", start_index=0x%08x, content_info_pointer=0x%08X",
+                media_type, am_content_count[media_type], title_id, start_index,
+                content_info_pointer);
 }
 void DeleteContents(Service::Interface* self) {
@@ -73,8 +78,9 @@ void DeleteContents(Service::Interface* self) {
    am_content_count[media_type] = cmd_buff[4];
    cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_WARNING(Service_AM, "(STUBBED) media_type=%u, title_id=0x%016" PRIx64 ", content_count=%u, content_ids_pointer=0x%08x",
+    LOG_WARNING(Service_AM, "(STUBBED) media_type=%u, title_id=0x%016" PRIx64
-        media_type, title_id, am_content_count[media_type], content_ids_pointer);
+                            ", content_count=%u, content_ids_pointer=0x%08x",
+                media_type, title_id, am_content_count[media_type], content_ids_pointer);
 }
 void GetTitleList(Service::Interface* self) {
@@ -87,8 +93,10 @@ void GetTitleList(Service::Interface* self) {
    cmd_buff[1] = RESULT_SUCCESS.raw;
    cmd_buff[2] = am_titles_list_count[media_type];
-    LOG_WARNING(Service_AM, "(STUBBED) media_type=%u, titles_list_count=0x%08X, title_ids_output_pointer=0x%08X",
+    LOG_WARNING(
-                media_type, am_titles_list_count[media_type], title_ids_output_pointer);
+        Service_AM,
+        "(STUBBED) media_type=%u, titles_list_count=0x%08X, title_ids_output_pointer=0x%08X",
+        media_type, am_titles_list_count[media_type], title_ids_output_pointer);
 }
 void GetTitleInfo(Service::Interface* self) {
@@ -101,7 +109,8 @@ void GetTitleInfo(Service::Interface* self) {
    am_titles_count[media_type] = cmd_buff[2];
    cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_WARNING(Service_AM, "(STUBBED) media_type=%u, total_titles=0x%08X, title_id_list_pointer=0x%08X, title_list_pointer=0x%08X",
+    LOG_WARNING(Service_AM, "(STUBBED) media_type=%u, total_titles=0x%08X, "
+                            "title_id_list_pointer=0x%08X, title_list_pointer=0x%08X",
                media_type, am_titles_count[media_type], title_id_list_pointer, title_list_pointer);
 }
@@ -122,8 +131,9 @@ void ListDataTitleTicketInfos(Service::Interface* self) {
    cmd_buff[1] = RESULT_SUCCESS.raw;
    cmd_buff[2] = am_ticket_count;
-    LOG_WARNING(Service_AM, "(STUBBED) ticket_count=0x%08X, title_id=0x%016" PRIx64 ", start_index=0x%08X, ticket_info_pointer=0x%08X",
+    LOG_WARNING(Service_AM, "(STUBBED) ticket_count=0x%08X, title_id=0x%016" PRIx64
-                 am_ticket_count, title_id, start_index, ticket_info_pointer);
+                            ", start_index=0x%08X, ticket_info_pointer=0x%08X",
+                am_ticket_count, title_id, start_index, ticket_info_pointer);
 }
 void GetNumContentInfos(Service::Interface* self) {
@@ -140,7 +150,7 @@ void DeleteTicket(Service::Interface* self) {
    u64 title_id = (static_cast<u64>(cmd_buff[2]) << 32) | cmd_buff[1];
    cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_WARNING(Service_AM, "(STUBBED) called title_id=0x%016" PRIx64 "",title_id);
+    LOG_WARNING(Service_AM, "(STUBBED) called title_id=0x%016" PRIx64 "", title_id);
 }
 void GetTicketCount(Service::Interface* self) {
@@ -148,7 +158,7 @@ void GetTicketCount(Service::Interface* self) {
    cmd_buff[1] = RESULT_SUCCESS.raw;
    cmd_buff[2] = am_ticket_count;
-    LOG_WARNING(Service_AM, "(STUBBED) called ticket_count=0x%08x",am_ticket_count);
+    LOG_WARNING(Service_AM, "(STUBBED) called ticket_count=0x%08x", am_ticket_count);
 }
 void GetTicketList(Service::Interface* self) {
@@ -161,8 +171,10 @@ void GetTicketList(Service::Interface* self) {
    cmd_buff[1] = RESULT_SUCCESS.raw;
    cmd_buff[2] = am_ticket_list_count;
-    LOG_WARNING(Service_AM, "(STUBBED) ticket_list_count=0x%08x, num_of_skip=0x%08x, ticket_list_pointer=0x%08x",
+    LOG_WARNING(
-                am_ticket_list_count, num_of_skip, ticket_list_pointer);
+        Service_AM,
+        "(STUBBED) ticket_list_count=0x%08x, num_of_skip=0x%08x, ticket_list_pointer=0x%08x",
+        am_ticket_list_count, num_of_skip, ticket_list_pointer);
 }
 void Init() {
@@ -175,7 +187,6 @@ void Init() {
 }
 void Shutdown() {
 }
 } // namespace AM
diff --git a/src/core/hle/service/am/am_app.cpp b/src/core/hle/service/am/am_app.cpp
index d27b3defd..bfc1ca6bd 100644
--- a/src/core/hle/service/am/am_app.cpp
+++ b/src/core/hle/service/am/am_app.cpp
@@ -9,14 +9,14 @@ namespace Service {
 namespace AM {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x100100C0, GetNumContentInfos,        "GetNumContentInfos"},
+    {0x100100C0, GetNumContentInfos, "GetNumContentInfos"},
-    {0x10020104, FindContentInfos,          "FindContentInfos"},
+    {0x10020104, FindContentInfos, "FindContentInfos"},
-    {0x10030142, ListContentInfos,          "ListContentInfos"},
+    {0x10030142, ListContentInfos, "ListContentInfos"},
-    {0x10040102, DeleteContents,            "DeleteContents"},
+    {0x10040102, DeleteContents, "DeleteContents"},
-    {0x10050084, GetDataTitleInfos,         "GetDataTitleInfos"},
+    {0x10050084, GetDataTitleInfos, "GetDataTitleInfos"},
-    {0x10070102, ListDataTitleTicketInfos,  "ListDataTitleTicketInfos"},
+    {0x10070102, ListDataTitleTicketInfos, "ListDataTitleTicketInfos"},
-    {0x100900C0, nullptr,                   "IsDataTitleInUse"},
+    {0x100900C0, nullptr, "IsDataTitleInUse"},
-    {0x100A0000, nullptr,                   "IsExternalTitleDatabaseInitialized"},
+    {0x100A0000, nullptr, "IsExternalTitleDatabaseInitialized"},
 };
 AM_APP_Interface::AM_APP_Interface() {
diff --git a/src/core/hle/service/am/am_net.cpp b/src/core/hle/service/am/am_net.cpp
index e75755245..3a597a34c 100644
--- a/src/core/hle/service/am/am_net.cpp
+++ b/src/core/hle/service/am/am_net.cpp
@@ -9,61 +9,61 @@ namespace Service {
 namespace AM {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010040, GetTitleCount,         "GetTitleCount"},
+    {0x00010040, GetTitleCount, "GetTitleCount"},
-    {0x00020082, GetTitleList,          "GetTitleList"},
+    {0x00020082, GetTitleList, "GetTitleList"},
-    {0x00030084, GetTitleInfo,          "GetTitleInfo"},
+    {0x00030084, GetTitleInfo, "GetTitleInfo"},
-    {0x000400C0, nullptr,               "DeleteApplicationTitle"},
+    {0x000400C0, nullptr, "DeleteApplicationTitle"},
-    {0x000500C0, nullptr,               "GetTitleProductCode"},
+    {0x000500C0, nullptr, "GetTitleProductCode"},
-    {0x000600C0, nullptr,               "GetTitleExtDataId"},
+    {0x000600C0, nullptr, "GetTitleExtDataId"},
-    {0x00070080, DeleteTicket,          "DeleteTicket"},
+    {0x00070080, DeleteTicket, "DeleteTicket"},
-    {0x00080000, GetTicketCount,        "GetTicketCount"},
+    {0x00080000, GetTicketCount, "GetTicketCount"},
-    {0x00090082, GetTicketList,         "GetTicketList"},
+    {0x00090082, GetTicketList, "GetTicketList"},
-    {0x000A0000, nullptr,               "GetDeviceID"},
+    {0x000A0000, nullptr, "GetDeviceID"},
-    {0x000D0084, nullptr,               "GetPendingTitleInfo"},
+    {0x000D0084, nullptr, "GetPendingTitleInfo"},
-    {0x000E00C0, nullptr,               "DeletePendingTitle"},
+    {0x000E00C0, nullptr, "DeletePendingTitle"},
-    {0x00140040, nullptr,               "FinalizePendingTitles"},
+    {0x00140040, nullptr, "FinalizePendingTitles"},
-    {0x00150040, nullptr,               "DeleteAllPendingTitles"},
+    {0x00150040, nullptr, "DeleteAllPendingTitles"},
-    {0x00180080, nullptr,               "InitializeTitleDatabase"},
+    {0x00180080, nullptr, "InitializeTitleDatabase"},
-    {0x00190040, nullptr,               "ReloadDBS"},
+    {0x00190040, nullptr, "ReloadDBS"},
-    {0x001A00C0, nullptr,               "GetDSiWareExportSize"},
+    {0x001A00C0, nullptr, "GetDSiWareExportSize"},
-    {0x001B0144, nullptr,               "ExportDSiWare"},
+    {0x001B0144, nullptr, "ExportDSiWare"},
-    {0x001C0084, nullptr,               "ImportDSiWare"},
+    {0x001C0084, nullptr, "ImportDSiWare"},
-    {0x00230080, nullptr,               "TitleIDListGetTotal2"},
+    {0x00230080, nullptr, "TitleIDListGetTotal2"},
-    {0x002400C2, nullptr,               "GetTitleIDList2"},
+    {0x002400C2, nullptr, "GetTitleIDList2"},
-    {0x04010080, nullptr,               "InstallFIRM"},
+    {0x04010080, nullptr, "InstallFIRM"},
-    {0x04020040, nullptr,               "StartInstallCIADB0"},
+    {0x04020040, nullptr, "StartInstallCIADB0"},
-    {0x04030000, nullptr,               "StartInstallCIADB1"},
+    {0x04030000, nullptr, "StartInstallCIADB1"},
-    {0x04040002, nullptr,               "AbortCIAInstall"},
+    {0x04040002, nullptr, "AbortCIAInstall"},
-    {0x04050002, nullptr,               "CloseCIAFinalizeInstall"},
+    {0x04050002, nullptr, "CloseCIAFinalizeInstall"},
-    {0x04060002, nullptr,               "CloseCIA"},
+    {0x04060002, nullptr, "CloseCIA"},
-    {0x040700C2, nullptr,               "FinalizeTitlesInstall"},
+    {0x040700C2, nullptr, "FinalizeTitlesInstall"},
-    {0x04080042, nullptr,               "GetCiaFileInfo"},
+    {0x04080042, nullptr, "GetCiaFileInfo"},
-    {0x040E00C2, nullptr,               "InstallTitlesFinish"},
+    {0x040E00C2, nullptr, "InstallTitlesFinish"},
-    {0x040F0000, nullptr,               "InstallNATIVEFIRM"},
+    {0x040F0000, nullptr, "InstallNATIVEFIRM"},
-    {0x041000C0, nullptr,               "DeleteTitle"},
+    {0x041000C0, nullptr, "DeleteTitle"},
-    {0x04120000, nullptr,               "Initialize"},
+    {0x04120000, nullptr, "Initialize"},
-    {0x041700C0, nullptr,               "MigrateAGBtoSAV"},
+    {0x041700C0, nullptr, "MigrateAGBtoSAV"},
-    {0x08010000, nullptr,               "OpenTicket"},
+    {0x08010000, nullptr, "OpenTicket"},
-    {0x08020002, nullptr,               "TicketAbortInstall"},
+    {0x08020002, nullptr, "TicketAbortInstall"},
-    {0x08030002, nullptr,               "TicketFinalizeInstall"},
+    {0x08030002, nullptr, "TicketFinalizeInstall"},
-    {0x08040100, nullptr,               "InstallTitleBegin"},
+    {0x08040100, nullptr, "InstallTitleBegin"},
-    {0x08050000, nullptr,               "InstallTitleAbort"},
+    {0x08050000, nullptr, "InstallTitleAbort"},
-    {0x080600C0, nullptr,               "InstallTitleResume"},
+    {0x080600C0, nullptr, "InstallTitleResume"},
-    {0x08070000, nullptr,               "InstallTitleAbortTMD"},
+    {0x08070000, nullptr, "InstallTitleAbortTMD"},
-    {0x08080000, nullptr,               "InstallTitleFinish"},
+    {0x08080000, nullptr, "InstallTitleFinish"},
-    {0x080A0000, nullptr,               "OpenTMD"},
+    {0x080A0000, nullptr, "OpenTMD"},
-    {0x080B0002, nullptr,               "TMDAbortInstall"},
+    {0x080B0002, nullptr, "TMDAbortInstall"},
-    {0x080C0042, nullptr,               "TMDFinalizeInstall"},
+    {0x080C0042, nullptr, "TMDFinalizeInstall"},
-    {0x080E0040, nullptr,               "OpenContentCreate"},
+    {0x080E0040, nullptr, "OpenContentCreate"},
-    {0x080F0002, nullptr,               "ContentAbortInstall"},
+    {0x080F0002, nullptr, "ContentAbortInstall"},
-    {0x08100040, nullptr,               "OpenContentResume"},
+    {0x08100040, nullptr, "OpenContentResume"},
-    {0x08120002, nullptr,               "ContentFinalizeInstall"},
+    {0x08120002, nullptr, "ContentFinalizeInstall"},
-    {0x08130000, nullptr,               "GetTotalContents"},
+    {0x08130000, nullptr, "GetTotalContents"},
-    {0x08140042, nullptr,               "GetContentIndexes"},
+    {0x08140042, nullptr, "GetContentIndexes"},
-    {0x08150044, nullptr,               "GetContentsInfo"},
+    {0x08150044, nullptr, "GetContentsInfo"},
-    {0x08180042, nullptr,               "GetCTCert"},
+    {0x08180042, nullptr, "GetCTCert"},
-    {0x08190108, nullptr,               "SetCertificates"},
+    {0x08190108, nullptr, "SetCertificates"},
-    {0x081B00C2, nullptr,               "InstallTitlesFinish"},
+    {0x081B00C2, nullptr, "InstallTitlesFinish"},
 };
 AM_NET_Interface::AM_NET_Interface() {
diff --git a/src/core/hle/service/am/am_sys.cpp b/src/core/hle/service/am/am_sys.cpp
index 8bad5e1c9..8bb58cab7 100644
--- a/src/core/hle/service/am/am_sys.cpp
+++ b/src/core/hle/service/am/am_sys.cpp
@@ -8,29 +8,27 @@
 namespace Service {
 namespace AM {
-const Interface::FunctionInfo FunctionTable[] = {
+const Interface::FunctionInfo FunctionTable[] = {{0x00010040, GetTitleCount, "GetTitleCount"},
-    {0x00010040, GetTitleCount,               "GetTitleCount"},
+                                                 {0x00020082, GetTitleList, "GetTitleList"},
-    {0x00020082, GetTitleList,                "GetTitleList"},
+                                                 {0x00030084, GetTitleInfo, "GetTitleInfo"},
-    {0x00030084, GetTitleInfo,                "GetTitleInfo"},
+                                                 {0x000400C0, nullptr, "DeleteApplicationTitle"},
-    {0x000400C0, nullptr,                     "DeleteApplicationTitle"},
+                                                 {0x000500C0, nullptr, "GetTitleProductCode"},
-    {0x000500C0, nullptr,                     "GetTitleProductCode"},
+                                                 {0x000600C0, nullptr, "GetTitleExtDataId"},
-    {0x000600C0, nullptr,                     "GetTitleExtDataId"},
+                                                 {0x00070080, DeleteTicket, "DeleteTicket"},
-    {0x00070080, DeleteTicket,                "DeleteTicket"},
+                                                 {0x00080000, GetTicketCount, "GetTicketCount"},
-    {0x00080000, GetTicketCount,              "GetTicketCount"},
+                                                 {0x00090082, GetTicketList, "GetTicketList"},
-    {0x00090082, GetTicketList,               "GetTicketList"},
+                                                 {0x000A0000, nullptr, "GetDeviceID"},
-    {0x000A0000, nullptr,                     "GetDeviceID"},
+                                                 {0x000D0084, nullptr, "GetPendingTitleInfo"},
-    {0x000D0084, nullptr,                     "GetPendingTitleInfo"},
+                                                 {0x000E00C0, nullptr, "DeletePendingTitle"},
-    {0x000E00C0, nullptr,                     "DeletePendingTitle"},
+                                                 {0x00140040, nullptr, "FinalizePendingTitles"},
-    {0x00140040, nullptr,                     "FinalizePendingTitles"},
+                                                 {0x00150040, nullptr, "DeleteAllPendingTitles"},
-    {0x00150040, nullptr,                     "DeleteAllPendingTitles"},
+                                                 {0x00180080, nullptr, "InitializeTitleDatabase"},
-    {0x00180080, nullptr,                     "InitializeTitleDatabase"},
+                                                 {0x00190040, nullptr, "ReloadDBS"},
-    {0x00190040, nullptr,                     "ReloadDBS"},
+                                                 {0x001A00C0, nullptr, "GetDSiWareExportSize"},
-    {0x001A00C0, nullptr,                     "GetDSiWareExportSize"},
+                                                 {0x001B0144, nullptr, "ExportDSiWare"},
-    {0x001B0144, nullptr,                     "ExportDSiWare"},
+                                                 {0x001C0084, nullptr, "ImportDSiWare"},
-    {0x001C0084, nullptr,                     "ImportDSiWare"},
+                                                 {0x00230080, nullptr, "GetPendingTitleCount"},
-    {0x00230080, nullptr,                     "GetPendingTitleCount"},
+                                                 {0x002400C2, nullptr, "GetPendingTitleList"}};
-    {0x002400C2, nullptr,                     "GetPendingTitleList"}
-};
 AM_SYS_Interface::AM_SYS_Interface() {
    Register(FunctionTable);
diff --git a/src/core/hle/service/am/am_u.cpp b/src/core/hle/service/am/am_u.cpp
index d583dd9e6..32d47741f 100644
--- a/src/core/hle/service/am/am_u.cpp
+++ b/src/core/hle/service/am/am_u.cpp
@@ -8,42 +8,40 @@
 namespace Service {
 namespace AM {
-const Interface::FunctionInfo FunctionTable[] = {
+const Interface::FunctionInfo FunctionTable[] = {{0x00010040, GetTitleCount, "GetTitleCount"},
-    {0x00010040, GetTitleCount,               "GetTitleCount"},
+                                                 {0x00020082, GetTitleList, "GetTitleList"},
-    {0x00020082, GetTitleList,                "GetTitleList"},
+                                                 {0x00030084, GetTitleInfo, "GetTitleInfo"},
-    {0x00030084, GetTitleInfo,                "GetTitleInfo"},
+                                                 {0x000400C0, nullptr, "DeleteApplicationTitle"},
-    {0x000400C0, nullptr,                     "DeleteApplicationTitle"},
+                                                 {0x000500C0, nullptr, "GetTitleProductCode"},
-    {0x000500C0, nullptr,                     "GetTitleProductCode"},
+                                                 {0x000600C0, nullptr, "GetTitleExtDataId"},
-    {0x000600C0, nullptr,                     "GetTitleExtDataId"},
+                                                 {0x00070080, DeleteTicket, "DeleteTicket"},
-    {0x00070080, DeleteTicket,                "DeleteTicket"},
+                                                 {0x00080000, GetTicketCount, "GetTicketCount"},
-    {0x00080000, GetTicketCount,              "GetTicketCount"},
+                                                 {0x00090082, GetTicketList, "GetTicketList"},
-    {0x00090082, GetTicketList,               "GetTicketList"},
+                                                 {0x000A0000, nullptr, "GetDeviceID"},
-    {0x000A0000, nullptr,                     "GetDeviceID"},
+                                                 {0x000D0084, nullptr, "GetPendingTitleInfo"},
-    {0x000D0084, nullptr,                     "GetPendingTitleInfo"},
+                                                 {0x000E00C0, nullptr, "DeletePendingTitle"},
-    {0x000E00C0, nullptr,                     "DeletePendingTitle"},
+                                                 {0x00140040, nullptr, "FinalizePendingTitles"},
-    {0x00140040, nullptr,                     "FinalizePendingTitles"},
+                                                 {0x00150040, nullptr, "DeleteAllPendingTitles"},
-    {0x00150040, nullptr,                     "DeleteAllPendingTitles"},
+                                                 {0x00180080, nullptr, "InitializeTitleDatabase"},
-    {0x00180080, nullptr,                     "InitializeTitleDatabase"},
+                                                 {0x00190040, nullptr, "ReloadDBS"},
-    {0x00190040, nullptr,                     "ReloadDBS"},
+                                                 {0x001A00C0, nullptr, "GetDSiWareExportSize"},
-    {0x001A00C0, nullptr,                     "GetDSiWareExportSize"},
+                                                 {0x001B0144, nullptr, "ExportDSiWare"},
-    {0x001B0144, nullptr,                     "ExportDSiWare"},
+                                                 {0x001C0084, nullptr, "ImportDSiWare"},
-    {0x001C0084, nullptr,                     "ImportDSiWare"},
+                                                 {0x00230080, nullptr, "TitleIDListGetTotal2"},
-    {0x00230080, nullptr,                     "TitleIDListGetTotal2"},
+                                                 {0x002400C2, nullptr, "GetTitleIDList2"},
-    {0x002400C2, nullptr,                     "GetTitleIDList2"},
+                                                 {0x04010080, nullptr, "InstallFIRM"},
-    {0x04010080, nullptr,                     "InstallFIRM"},
+                                                 {0x04020040, nullptr, "StartInstallCIADB0"},
-    {0x04020040, nullptr,                     "StartInstallCIADB0"},
+                                                 {0x04030000, nullptr, "StartInstallCIADB1"},
-    {0x04030000, nullptr,                     "StartInstallCIADB1"},
+                                                 {0x04040002, nullptr, "AbortCIAInstall"},
-    {0x04040002, nullptr,                     "AbortCIAInstall"},
+                                                 {0x04050002, nullptr, "CloseCIAFinalizeInstall"},
-    {0x04050002, nullptr,                     "CloseCIAFinalizeInstall"},
+                                                 {0x04060002, nullptr, "CloseCIA"},
-    {0x04060002, nullptr,                     "CloseCIA"},
+                                                 {0x040700C2, nullptr, "FinalizeTitlesInstall"},
-    {0x040700C2, nullptr,                     "FinalizeTitlesInstall"},
+                                                 {0x04080042, nullptr, "GetCiaFileInfo"},
-    {0x04080042, nullptr,                     "GetCiaFileInfo"},
+                                                 {0x040E00C2, nullptr, "InstallTitlesFinish"},
-    {0x040E00C2, nullptr,                     "InstallTitlesFinish"},
+                                                 {0x040F0000, nullptr, "InstallNATIVEFIRM"},
-    {0x040F0000, nullptr,                     "InstallNATIVEFIRM"},
+                                                 {0x041000C0, nullptr, "DeleteTitle"},
-    {0x041000C0, nullptr,                     "DeleteTitle"},
+                                                 {0x04120000, nullptr, "Initialize"},
-    {0x04120000, nullptr,                     "Initialize"},
+                                                 {0x041700C0, nullptr, "MigrateAGBtoSAV"}};
-    {0x041700C0, nullptr,                     "MigrateAGBtoSAV"}
-};
 AM_U_Interface::AM_U_Interface() {
    Register(FunctionTable);
diff --git a/src/core/hle/service/apt/apt.cpp b/src/core/hle/service/apt/apt.cpp
index 4d2956638..c798e8752 100644
--- a/src/core/hle/service/apt/apt.cpp
+++ b/src/core/hle/service/apt/apt.cpp
@@ -7,7 +7,6 @@
 #include "common/logging/log.h"
 #include "core/hle/applets/applet.h"
-#include "core/hle/service/service.h"
 #include "core/hle/service/apt/apt.h"
 #include "core/hle/service/apt/apt_a.h"
 #include "core/hle/service/apt/apt_s.h"
@@ -15,6 +14,7 @@
 #include "core/hle/service/apt/bcfnt/bcfnt.h"
 #include "core/hle/service/fs/archive.h"
 #include "core/hle/service/ptm/ptm.h"
+#include "core/hle/service/service.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/mutex.h"
@@ -30,7 +30,7 @@ static bool shared_font_relocated = false;
 static Kernel::SharedPtr<Kernel::Mutex> lock;
 static Kernel::SharedPtr<Kernel::Event> notification_event; ///< APT notification event
-static Kernel::SharedPtr<Kernel::Event> parameter_event; ///< APT parameter event
+static Kernel::SharedPtr<Kernel::Event> parameter_event;    ///< APT parameter event
 static u32 cpu_percent; ///< CPU time available to the running application
@@ -51,7 +51,7 @@ void SendParameter(const MessageParameter& parameter) {
 void Initialize(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    u32 app_id = cmd_buff[1];
-    u32 flags  = cmd_buff[2];
+    u32 flags = cmd_buff[2];
    cmd_buff[2] = IPC::CopyHandleDesc(2);
    cmd_buff[3] = Kernel::g_handle_table.Create(notification_event).MoveFrom();
@@ -75,20 +75,24 @@ void GetSharedFont(Service::Interface* self) {
    if (!shared_font_mem) {
        LOG_ERROR(Service_APT, "shared font file missing - go dump it from your 3ds");
        cmd_buff[0] = IPC::MakeHeader(0x44, 2, 2);
-        cmd_buff[1] = -1;  // TODO: Find the right error code
+        cmd_buff[1] = -1; // TODO: Find the right error code
        return;
    }
-    // The shared font has to be relocated to the new address before being passed to the application.
+    // The shared font has to be relocated to the new address before being passed to the
-    VAddr target_address = Memory::PhysicalToVirtualAddress(shared_font_mem->linear_heap_phys_address);
+    // application.
+    VAddr target_address =
+        Memory::PhysicalToVirtualAddress(shared_font_mem->linear_heap_phys_address);
    if (!shared_font_relocated) {
        BCFNT::RelocateSharedFont(shared_font_mem, target_address);
        shared_font_relocated = true;
    }
    cmd_buff[0] = IPC::MakeHeader(0x44, 2, 2);
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
-    // Since the SharedMemory interface doesn't provide the address at which the memory was allocated,
+    // Since the SharedMemory interface doesn't provide the address at which the memory was
-    // the real APT service calculates this address by scanning the entire address space (using svcQueryMemory)
+    // allocated,
+    // the real APT service calculates this address by scanning the entire address space (using
+    // svcQueryMemory)
    // and searches for an allocation of the same size as the Shared Font.
    cmd_buff[2] = target_address;
    cmd_buff[3] = IPC::CopyHandleDesc();
@@ -112,18 +116,19 @@ void GetLockHandle(Service::Interface* self) {
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
    cmd_buff[2] = applet_attributes; // Applet Attributes, this value is passed to Enable.
-    cmd_buff[3] = 0; // Least significant bit = power button state
+    cmd_buff[3] = 0;                 // Least significant bit = power button state
    cmd_buff[4] = IPC::CopyHandleDesc();
    cmd_buff[5] = Kernel::g_handle_table.Create(lock).MoveFrom();
-    LOG_WARNING(Service_APT, "(STUBBED) called handle=0x%08X applet_attributes=0x%08X", cmd_buff[5], applet_attributes);
+    LOG_WARNING(Service_APT, "(STUBBED) called handle=0x%08X applet_attributes=0x%08X", cmd_buff[5],
+                applet_attributes);
 }
 void Enable(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    u32 attributes = cmd_buff[1];
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
-    parameter_event->Signal(); // Let the application know that it has been started
+    parameter_event->Signal();        // Let the application know that it has been started
    LOG_WARNING(Service_APT, "(STUBBED) called attributes=0x%08X", attributes);
 }
@@ -133,7 +138,7 @@ void GetAppletManInfo(Service::Interface* self) {
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
    cmd_buff[2] = 0;
    cmd_buff[3] = 0;
-    cmd_buff[4] = static_cast<u32>(AppletId::HomeMenu); // Home menu AppID
+    cmd_buff[4] = static_cast<u32>(AppletId::HomeMenu);    // Home menu AppID
    cmd_buff[5] = static_cast<u32>(AppletId::Application); // TODO(purpasmart96): Do this correctly
    LOG_WARNING(Service_APT, "(STUBBED) called unk=0x%08X", unk);
@@ -159,23 +164,24 @@ void IsRegistered(Service::Interface* self) {
 void InquireNotification(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    u32 app_id = cmd_buff[1];
-    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
+    cmd_buff[1] = RESULT_SUCCESS.raw;                 // No error
    cmd_buff[2] = static_cast<u32>(SignalType::None); // Signal type
    LOG_WARNING(Service_APT, "(STUBBED) called app_id=0x%08X", app_id);
 }
 void SendParameter(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
-    u32 src_app_id     = cmd_buff[1];
+    u32 src_app_id = cmd_buff[1];
-    u32 dst_app_id     = cmd_buff[2];
+    u32 dst_app_id = cmd_buff[2];
-    u32 signal_type    = cmd_buff[3];
+    u32 signal_type = cmd_buff[3];
-    u32 buffer_size    = cmd_buff[4];
+    u32 buffer_size = cmd_buff[4];
-    u32 value          = cmd_buff[5];
+    u32 value = cmd_buff[5];
-    u32 handle         = cmd_buff[6];
+    u32 handle = cmd_buff[6];
-    u32 size           = cmd_buff[7];
+    u32 size = cmd_buff[7];
-    u32 buffer         = cmd_buff[8];
+    u32 buffer = cmd_buff[8];
-    std::shared_ptr<HLE::Applets::Applet> dest_applet = HLE::Applets::Applet::Get(static_cast<AppletId>(dst_app_id));
+    std::shared_ptr<HLE::Applets::Applet> dest_applet =
+        HLE::Applets::Applet::Get(static_cast<AppletId>(dst_app_id));
    if (dest_applet == nullptr) {
        LOG_ERROR(Service_APT, "Unknown applet id=0x%08X", dst_app_id);
@@ -193,9 +199,11 @@ void SendParameter(Service::Interface* self) {
    cmd_buff[1] = dest_applet->ReceiveParameter(param).raw;
-    LOG_WARNING(Service_APT, "(STUBBED) called src_app_id=0x%08X, dst_app_id=0x%08X, signal_type=0x%08X,"
+    LOG_WARNING(
-               "buffer_size=0x%08X, value=0x%08X, handle=0x%08X, size=0x%08X, in_param_buffer_ptr=0x%08X",
+        Service_APT,
-               src_app_id, dst_app_id, signal_type, buffer_size, value, handle, size, buffer);
+        "(STUBBED) called src_app_id=0x%08X, dst_app_id=0x%08X, signal_type=0x%08X,"
+        "buffer_size=0x%08X, value=0x%08X, handle=0x%08X, size=0x%08X, in_param_buffer_ptr=0x%08X",
+        src_app_id, dst_app_id, signal_type, buffer_size, value, handle, size, buffer);
 }
 void ReceiveParameter(Service::Interface* self) {
@@ -206,7 +214,7 @@ void ReceiveParameter(Service::Interface* self) {
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
    cmd_buff[2] = next_parameter.sender_id;
-    cmd_buff[3] = next_parameter.signal; // Signal type
+    cmd_buff[3] = next_parameter.signal;        // Signal type
    cmd_buff[4] = next_parameter.buffer.size(); // Parameter buffer size
    cmd_buff[5] = 0x10;
    cmd_buff[6] = 0;
@@ -228,7 +236,7 @@ void GlanceParameter(Service::Interface* self) {
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
    cmd_buff[2] = next_parameter.sender_id;
-    cmd_buff[3] = next_parameter.signal; // Signal type
+    cmd_buff[3] = next_parameter.signal;        // Signal type
    cmd_buff[4] = next_parameter.buffer.size(); // Parameter buffer size
    cmd_buff[5] = 0x10;
    cmd_buff[6] = 0;
@@ -237,32 +245,34 @@ void GlanceParameter(Service::Interface* self) {
    cmd_buff[7] = (next_parameter.buffer.size() << 14) | 2;
    cmd_buff[8] = buffer;
-    Memory::WriteBlock(buffer, next_parameter.buffer.data(), std::min(static_cast<size_t>(buffer_size), next_parameter.buffer.size()));
+    Memory::WriteBlock(buffer, next_parameter.buffer.data(),
+                       std::min(static_cast<size_t>(buffer_size), next_parameter.buffer.size()));
    LOG_WARNING(Service_APT, "called app_id=0x%08X, buffer_size=0x%08X", app_id, buffer_size);
 }
 void CancelParameter(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
-    u32 flag1  = cmd_buff[1];
+    u32 flag1 = cmd_buff[1];
-    u32 unk    = cmd_buff[2];
+    u32 unk = cmd_buff[2];
-    u32 flag2  = cmd_buff[3];
+    u32 flag2 = cmd_buff[3];
    u32 app_id = cmd_buff[4];
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
-    cmd_buff[2] = 1; // Set to Success
+    cmd_buff[2] = 1;                  // Set to Success
-    LOG_WARNING(Service_APT, "(STUBBED) called flag1=0x%08X, unk=0x%08X, flag2=0x%08X, app_id=0x%08X",
+    LOG_WARNING(Service_APT,
-                flag1, unk, flag2, app_id);
+                "(STUBBED) called flag1=0x%08X, unk=0x%08X, flag2=0x%08X, app_id=0x%08X", flag1,
+                unk, flag2, app_id);
 }
 void PrepareToStartApplication(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
-    u32 title_info1  = cmd_buff[1];
+    u32 title_info1 = cmd_buff[1];
-    u32 title_info2  = cmd_buff[2];
+    u32 title_info2 = cmd_buff[2];
-    u32 title_info3  = cmd_buff[3];
+    u32 title_info3 = cmd_buff[3];
-    u32 title_info4  = cmd_buff[4];
+    u32 title_info4 = cmd_buff[4];
-    u32 flags        = cmd_buff[5];
+    u32 flags = cmd_buff[5];
    if (flags & 0x00000100) {
        unknown_ns_state_field = 1;
@@ -270,25 +280,28 @@ void PrepareToStartApplication(Service::Interface* self) {
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
-    LOG_WARNING(Service_APT, "(STUBBED) called title_info1=0x%08X, title_info2=0x%08X, title_info3=0x%08X,"
+    LOG_WARNING(Service_APT,
-               "title_info4=0x%08X, flags=0x%08X", title_info1, title_info2, title_info3, title_info4, flags);
+                "(STUBBED) called title_info1=0x%08X, title_info2=0x%08X, title_info3=0x%08X,"
+                "title_info4=0x%08X, flags=0x%08X",
+                title_info1, title_info2, title_info3, title_info4, flags);
 }
 void StartApplication(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    u32 buffer1_size = cmd_buff[1];
    u32 buffer2_size = cmd_buff[2];
-    u32 flag         = cmd_buff[3];
+    u32 flag = cmd_buff[3];
-    u32 size1        = cmd_buff[4];
+    u32 size1 = cmd_buff[4];
-    u32 buffer1_ptr  = cmd_buff[5];
+    u32 buffer1_ptr = cmd_buff[5];
-    u32 size2        = cmd_buff[6];
+    u32 size2 = cmd_buff[6];
-    u32 buffer2_ptr  = cmd_buff[7];
+    u32 buffer2_ptr = cmd_buff[7];
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
-    LOG_WARNING(Service_APT, "(STUBBED) called buffer1_size=0x%08X, buffer2_size=0x%08X, flag=0x%08X,"
+    LOG_WARNING(Service_APT,
-               "size1=0x%08X, buffer1_ptr=0x%08X, size2=0x%08X, buffer2_ptr=0x%08X",
+                "(STUBBED) called buffer1_size=0x%08X, buffer2_size=0x%08X, flag=0x%08X,"
-               buffer1_size, buffer2_size, flag, size1, buffer1_ptr, size2, buffer2_ptr);
+                "size1=0x%08X, buffer1_ptr=0x%08X, size2=0x%08X, buffer2_ptr=0x%08X",
+                buffer1_size, buffer2_size, flag, size1, buffer1_ptr, size2, buffer2_ptr);
 }
 void AppletUtility(Service::Interface* self) {
@@ -303,14 +316,15 @@ void AppletUtility(Service::Interface* self) {
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
-    LOG_WARNING(Service_APT, "(STUBBED) called command=0x%08X, buffer1_size=0x%08X, buffer2_size=0x%08X, "
+    LOG_WARNING(Service_APT,
-             "buffer1_addr=0x%08X, buffer2_addr=0x%08X", command, buffer1_size, buffer2_size,
+                "(STUBBED) called command=0x%08X, buffer1_size=0x%08X, buffer2_size=0x%08X, "
-             buffer1_addr, buffer2_addr);
+                "buffer1_addr=0x%08X, buffer2_addr=0x%08X",
+                command, buffer1_size, buffer2_size, buffer1_addr, buffer2_addr);
 }
 void SetAppCpuTimeLimit(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
-    u32 value   = cmd_buff[1];
+    u32 value = cmd_buff[1];
    cpu_percent = cmd_buff[2];
    if (value != 1) {
@@ -393,7 +407,8 @@ void SetScreenCapPostPermission(Service::Interface* self) {
    cmd_buff[0] = IPC::MakeHeader(0x55, 1, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_WARNING(Service_APT, "(STUBBED) screen_capture_post_permission=%u", screen_capture_post_permission);
+    LOG_WARNING(Service_APT, "(STUBBED) screen_capture_post_permission=%u",
+                screen_capture_post_permission);
 }
 void GetScreenCapPostPermission(Service::Interface* self) {
@@ -402,7 +417,8 @@ void GetScreenCapPostPermission(Service::Interface* self) {
    cmd_buff[0] = IPC::MakeHeader(0x56, 2, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw;
    cmd_buff[2] = static_cast<u32>(screen_capture_post_permission);
-    LOG_WARNING(Service_APT, "(STUBBED) screen_capture_post_permission=%u", screen_capture_post_permission);
+    LOG_WARNING(Service_APT, "(STUBBED) screen_capture_post_permission=%u",
+                screen_capture_post_permission);
 }
 void GetAppletInfo(Service::Interface* self) {
@@ -418,7 +434,8 @@ void GetAppletInfo(Service::Interface* self) {
        cmd_buff[7] = 0; // Applet Attributes
    } else {
        cmd_buff[1] = ResultCode(ErrorDescription::NotFound, ErrorModule::Applet,
-                                 ErrorSummary::NotFound, ErrorLevel::Status).raw;
+                                 ErrorSummary::NotFound, ErrorLevel::Status)
+                          .raw;
    }
    LOG_WARNING(Service_APT, "(stubbed) called appid=%u", app_id);
 }
@@ -429,11 +446,15 @@ void GetStartupArgument(Service::Interface* self) {
    StartupArgumentType startup_argument_type = static_cast<StartupArgumentType>(cmd_buff[2]);
    if (parameter_size >= 0x300) {
-        LOG_ERROR(Service_APT, "Parameter size is outside the valid range (capped to 0x300): parameter_size=0x%08x", parameter_size);
+        LOG_ERROR(
+            Service_APT,
+            "Parameter size is outside the valid range (capped to 0x300): parameter_size=0x%08x",
+            parameter_size);
        return;
    }
-    LOG_WARNING(Service_APT,"(stubbed) called startup_argument_type=%u , parameter_size=0x%08x , parameter_value=0x%08x",
+    LOG_WARNING(Service_APT, "(stubbed) called startup_argument_type=%u , parameter_size=0x%08x , "
+                             "parameter_value=0x%08x",
                startup_argument_type, parameter_size, Memory::Read32(cmd_buff[41]));
    cmd_buff[1] = RESULT_SUCCESS.raw;
@@ -484,8 +505,10 @@ void Init() {
    if (file.IsOpen()) {
        // Create shared font memory object
        using Kernel::MemoryPermission;
-        shared_font_mem = Kernel::SharedMemory::Create(nullptr, 0x332000, // 3272 KB
+        shared_font_mem =
-                MemoryPermission::ReadWrite, MemoryPermission::Read, 0, Kernel::MemoryRegion::SYSTEM, "APT:SharedFont");
+            Kernel::SharedMemory::Create(nullptr, 0x332000, // 3272 KB
+                                         MemoryPermission::ReadWrite, MemoryPermission::Read, 0,
+                                         Kernel::MemoryRegion::SYSTEM, "APT:SharedFont");
        // Read shared font data
        file.ReadBytes(shared_font_mem->GetPointer(), file.GetSize());
    } else {
@@ -497,7 +520,8 @@ void Init() {
    cpu_percent = 0;
    unknown_ns_state_field = 0;
-    screen_capture_post_permission = ScreencapPostPermission::CleanThePermission; // TODO(JamePeng): verify the initial value
+    screen_capture_post_permission =
+        ScreencapPostPermission::CleanThePermission; // TODO(JamePeng): verify the initial value
    // TODO(bunnei): Check if these are created in Initialize or on APT process startup.
    notification_event = Kernel::Event::Create(Kernel::ResetType::OneShot, "APT_U:Notification");
diff --git a/src/core/hle/service/apt/apt.h b/src/core/hle/service/apt/apt.h
index 077a6a316..fe8b8a7b8 100644
--- a/src/core/hle/service/apt/apt.h
+++ b/src/core/hle/service/apt/apt.h
@@ -46,58 +46,58 @@ static_assert(sizeof(CaptureBufferInfo) == 0x20, "CaptureBufferInfo struct has i
 /// Signals used by APT functions
 enum class SignalType : u32 {
-    None              = 0x0,
+    None = 0x0,
-    AppJustStarted    = 0x1,
+    AppJustStarted = 0x1,
    LibAppJustStarted = 0x2,
-    LibAppFinished    = 0x3,
+    LibAppFinished = 0x3,
-    LibAppClosed      = 0xA,
+    LibAppClosed = 0xA,
-    ReturningToApp    = 0xB,
+    ReturningToApp = 0xB,
-    ExitingApp        = 0xC,
+    ExitingApp = 0xC,
 };
 /// App Id's used by APT functions
 enum class AppletId : u32 {
-    HomeMenu           = 0x101,
+    HomeMenu = 0x101,
-    AlternateMenu      = 0x103,
+    AlternateMenu = 0x103,
-    Camera             = 0x110,
+    Camera = 0x110,
-    FriendsList        = 0x112,
+    FriendsList = 0x112,
-    GameNotes          = 0x113,
+    GameNotes = 0x113,
-    InternetBrowser    = 0x114,
+    InternetBrowser = 0x114,
-    InstructionManual  = 0x115,
+    InstructionManual = 0x115,
-    Notifications      = 0x116,
+    Notifications = 0x116,
-    Miiverse           = 0x117,
+    Miiverse = 0x117,
-    MiiversePost       = 0x118,
+    MiiversePost = 0x118,
-    AmiiboSettings     = 0x119,
+    AmiiboSettings = 0x119,
-    SoftwareKeyboard1  = 0x201,
+    SoftwareKeyboard1 = 0x201,
-    Ed1                = 0x202,
+    Ed1 = 0x202,
-    PnoteApp           = 0x204,
+    PnoteApp = 0x204,
-    SnoteApp           = 0x205,
+    SnoteApp = 0x205,
-    Error              = 0x206,
+    Error = 0x206,
-    Mint               = 0x207,
+    Mint = 0x207,
-    Extrapad           = 0x208,
+    Extrapad = 0x208,
-    Memolib            = 0x209,
+    Memolib = 0x209,
-    Application        = 0x300,
+    Application = 0x300,
-    AnyLibraryApplet   = 0x400,
+    AnyLibraryApplet = 0x400,
-    SoftwareKeyboard2  = 0x401,
+    SoftwareKeyboard2 = 0x401,
-    Ed2                = 0x402,
+    Ed2 = 0x402,
-    PnoteApp2          = 0x404,
+    PnoteApp2 = 0x404,
-    SnoteApp2          = 0x405,
+    SnoteApp2 = 0x405,
-    Error2             = 0x406,
+    Error2 = 0x406,
-    Mint2              = 0x407,
+    Mint2 = 0x407,
-    Extrapad2          = 0x408,
+    Extrapad2 = 0x408,
-    Memolib2           = 0x409,
+    Memolib2 = 0x409,
 };
 enum class StartupArgumentType : u32 {
-    OtherApp   = 0,
+    OtherApp = 0,
-    Restart    = 1,
+    Restart = 1,
    OtherMedia = 2,
 };
 enum class ScreencapPostPermission : u32 {
-    CleanThePermission                 = 0, //TODO(JamePeng): verify what "zero" means
+    CleanThePermission = 0, // TODO(JamePeng): verify what "zero" means
-    NoExplicitSetting                  = 1,
+    NoExplicitSetting = 1,
-    EnableScreenshotPostingToMiiverse  = 2,
+    EnableScreenshotPostingToMiiverse = 2,
    DisableScreenshotPostingToMiiverse = 3
 };
@@ -182,9 +182,12 @@ void GetAppletManInfo(Service::Interface* self);
 void GetAppletInfo(Service::Interface* self);
 /**
- * APT::IsRegistered service function. This returns whether the specified AppID is registered with NS yet.
+ * APT::IsRegistered service function. This returns whether the specified AppID is registered with
- * An AppID is "registered" once the process associated with the AppID uses APT:Enable. Home Menu uses this
+ * NS yet.
- * command to determine when the launched process is running and to determine when to stop using GSP etc,
+ * An AppID is "registered" once the process associated with the AppID uses APT:Enable. Home Menu
+ * uses this
+ * command to determine when the launched process is running and to determine when to stop using GSP
+ * etc,
 * while displaying the "Nintendo 3DS" loading screen.
 *  Inputs:
 *      1 : AppID
@@ -260,9 +263,11 @@ void GlanceParameter(Service::Interface* self);
 * clears the flag which indicates that parameter data is available
 * (same flag cleared by APT:ReceiveParameter).
 *  Inputs:
- *      1 : Flag, when non-zero NS will compare the word after this one with a field in the NS state.
+ *      1 : Flag, when non-zero NS will compare the word after this one with a field in the NS
+ * state.
 *      2 : Unknown, this is the same as the first unknown field returned by APT:ReceiveParameter.
- *      3 : Flag, when non-zero NS will compare the word after this one with a field in the NS state.
+ *      3 : Flag, when non-zero NS will compare the word after this one with a field in the NS
+ * state.
 *      4 : AppID
 *  Outputs:
 *      0 : Return header
diff --git a/src/core/hle/service/apt/apt_a.cpp b/src/core/hle/service/apt/apt_a.cpp
index 6c44c491c..7d47d7675 100644
--- a/src/core/hle/service/apt/apt_a.cpp
+++ b/src/core/hle/service/apt/apt_a.cpp
@@ -9,35 +9,34 @@ namespace Service {
 namespace APT {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010040, GetLockHandle,                "GetLockHandle?"},
+    {0x00010040, GetLockHandle, "GetLockHandle?"},
-    {0x00020080, Initialize,                   "Initialize?"},
+    {0x00020080, Initialize, "Initialize?"},
-    {0x00030040, Enable,                       "Enable?"},
+    {0x00030040, Enable, "Enable?"},
-    {0x00040040, nullptr,                      "Finalize?"},
+    {0x00040040, nullptr, "Finalize?"},
-    {0x00050040, GetAppletManInfo,             "GetAppletManInfo"},
+    {0x00050040, GetAppletManInfo, "GetAppletManInfo"},
-    {0x00060040, GetAppletInfo,                "GetAppletInfo"},
+    {0x00060040, GetAppletInfo, "GetAppletInfo"},
-    {0x00090040, IsRegistered,                 "IsRegistered"},
+    {0x00090040, IsRegistered, "IsRegistered"},
-    {0x000B0040, InquireNotification,          "InquireNotification"},
+    {0x000B0040, InquireNotification, "InquireNotification"},
-    {0x000C0104, SendParameter,                "SendParameter"},
+    {0x000C0104, SendParameter, "SendParameter"},
-    {0x000D0080, ReceiveParameter,             "ReceiveParameter"},
+    {0x000D0080, ReceiveParameter, "ReceiveParameter"},
-    {0x000E0080, GlanceParameter,              "GlanceParameter"},
+    {0x000E0080, GlanceParameter, "GlanceParameter"},
-    {0x000F0100, CancelParameter,              "CancelParameter"},
+    {0x000F0100, CancelParameter, "CancelParameter"},
-    {0x00150140, PrepareToStartApplication,    "PrepareToStartApplication"},
+    {0x00150140, PrepareToStartApplication, "PrepareToStartApplication"},
-    {0x00160040, PreloadLibraryApplet,         "PreloadLibraryApplet"},
+    {0x00160040, PreloadLibraryApplet, "PreloadLibraryApplet"},
-    {0x00180040, PrepareToStartLibraryApplet,  "PrepareToStartLibraryApplet"},
+    {0x00180040, PrepareToStartLibraryApplet, "PrepareToStartLibraryApplet"},
-    {0x001E0084, StartLibraryApplet,           "StartLibraryApplet"},
+    {0x001E0084, StartLibraryApplet, "StartLibraryApplet"},
-    {0x003B0040, nullptr,                      "CancelLibraryApplet?"},
+    {0x003B0040, nullptr, "CancelLibraryApplet?"},
-    {0x003E0080, nullptr,                      "ReplySleepQuery"},
+    {0x003E0080, nullptr, "ReplySleepQuery"},
-    {0x00430040, NotifyToWait,                 "NotifyToWait?"},
+    {0x00430040, NotifyToWait, "NotifyToWait?"},
-    {0x00440000, GetSharedFont,                "GetSharedFont?"},
+    {0x00440000, GetSharedFont, "GetSharedFont?"},
-    {0x004B00C2, AppletUtility,                "AppletUtility?"},
+    {0x004B00C2, AppletUtility, "AppletUtility?"},
-    {0x004F0080, SetAppCpuTimeLimit,           "SetAppCpuTimeLimit"},
+    {0x004F0080, SetAppCpuTimeLimit, "SetAppCpuTimeLimit"},
-    {0x00500040, GetAppCpuTimeLimit,           "GetAppCpuTimeLimit"},
+    {0x00500040, GetAppCpuTimeLimit, "GetAppCpuTimeLimit"},
-    {0x00510080, GetStartupArgument,           "GetStartupArgument"},
+    {0x00510080, GetStartupArgument, "GetStartupArgument"},
-    {0x00550040, SetScreenCapPostPermission,   "SetScreenCapPostPermission"},
+    {0x00550040, SetScreenCapPostPermission, "SetScreenCapPostPermission"},
-    {0x00560000, GetScreenCapPostPermission,   "GetScreenCapPostPermission"},
+    {0x00560000, GetScreenCapPostPermission, "GetScreenCapPostPermission"},
-    {0x01010000, CheckNew3DSApp,               "CheckNew3DSApp"},
+    {0x01010000, CheckNew3DSApp, "CheckNew3DSApp"},
-    {0x01020000, CheckNew3DS,                  "CheckNew3DS"}
+    {0x01020000, CheckNew3DS, "CheckNew3DS"}};
-};
 APT_A_Interface::APT_A_Interface() {
    Register(FunctionTable);
diff --git a/src/core/hle/service/apt/apt_s.cpp b/src/core/hle/service/apt/apt_s.cpp
index c70f2201f..76e71669c 100644
--- a/src/core/hle/service/apt/apt_s.cpp
+++ b/src/core/hle/service/apt/apt_s.cpp
@@ -9,95 +9,94 @@ namespace Service {
 namespace APT {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010040, GetLockHandle,         "GetLockHandle"},
+    {0x00010040, GetLockHandle, "GetLockHandle"},
-    {0x00020080, Initialize,            "Initialize"},
+    {0x00020080, Initialize, "Initialize"},
-    {0x00030040, Enable,                "Enable"},
+    {0x00030040, Enable, "Enable"},
-    {0x00040040, nullptr,               "Finalize"},
+    {0x00040040, nullptr, "Finalize"},
-    {0x00050040, GetAppletManInfo,      "GetAppletManInfo"},
+    {0x00050040, GetAppletManInfo, "GetAppletManInfo"},
-    {0x00060040, GetAppletInfo,         "GetAppletInfo"},
+    {0x00060040, GetAppletInfo, "GetAppletInfo"},
-    {0x00070000, nullptr,               "GetLastSignaledAppletId"},
+    {0x00070000, nullptr, "GetLastSignaledAppletId"},
-    {0x00080000, nullptr,               "CountRegisteredApplet"},
+    {0x00080000, nullptr, "CountRegisteredApplet"},
-    {0x00090040, nullptr,               "IsRegistered"},
+    {0x00090040, nullptr, "IsRegistered"},
-    {0x000A0040, nullptr,               "GetAttribute"},
+    {0x000A0040, nullptr, "GetAttribute"},
-    {0x000B0040, InquireNotification,   "InquireNotification"},
+    {0x000B0040, InquireNotification, "InquireNotification"},
-    {0x000C0104, nullptr,               "SendParameter"},
+    {0x000C0104, nullptr, "SendParameter"},
-    {0x000D0080, ReceiveParameter,      "ReceiveParameter"},
+    {0x000D0080, ReceiveParameter, "ReceiveParameter"},
-    {0x000E0080, GlanceParameter,       "GlanceParameter"},
+    {0x000E0080, GlanceParameter, "GlanceParameter"},
-    {0x000F0100, nullptr,               "CancelParameter"},
+    {0x000F0100, nullptr, "CancelParameter"},
-    {0x001000C2, nullptr,               "DebugFunc"},
+    {0x001000C2, nullptr, "DebugFunc"},
-    {0x001100C0, nullptr,               "MapProgramIdForDebug"},
+    {0x001100C0, nullptr, "MapProgramIdForDebug"},
-    {0x00120040, nullptr,               "SetHomeMenuAppletIdForDebug"},
+    {0x00120040, nullptr, "SetHomeMenuAppletIdForDebug"},
-    {0x00130000, nullptr,               "GetPreparationState"},
+    {0x00130000, nullptr, "GetPreparationState"},
-    {0x00140040, nullptr,               "SetPreparationState"},
+    {0x00140040, nullptr, "SetPreparationState"},
    {0x00150140, PrepareToStartApplication, "PrepareToStartApplication"},
-    {0x00160040, PreloadLibraryApplet,  "PreloadLibraryApplet"},
+    {0x00160040, PreloadLibraryApplet, "PreloadLibraryApplet"},
-    {0x00170040, nullptr,               "FinishPreloadingLibraryApplet"},
+    {0x00170040, nullptr, "FinishPreloadingLibraryApplet"},
-    {0x00180040, PrepareToStartLibraryApplet,"PrepareToStartLibraryApplet"},
+    {0x00180040, PrepareToStartLibraryApplet, "PrepareToStartLibraryApplet"},
-    {0x00190040, nullptr,               "PrepareToStartSystemApplet"},
+    {0x00190040, nullptr, "PrepareToStartSystemApplet"},
-    {0x001A0000, nullptr,               "PrepareToStartNewestHomeMenu"},
+    {0x001A0000, nullptr, "PrepareToStartNewestHomeMenu"},
-    {0x001B00C4, nullptr,               "StartApplication"},
+    {0x001B00C4, nullptr, "StartApplication"},
-    {0x001C0000, nullptr,               "WakeupApplication"},
+    {0x001C0000, nullptr, "WakeupApplication"},
-    {0x001D0000, nullptr,               "CancelApplication"},
+    {0x001D0000, nullptr, "CancelApplication"},
-    {0x001E0084, nullptr,               "StartLibraryApplet"},
+    {0x001E0084, nullptr, "StartLibraryApplet"},
-    {0x001F0084, nullptr,               "StartSystemApplet"},
+    {0x001F0084, nullptr, "StartSystemApplet"},
-    {0x00200044, nullptr,               "StartNewestHomeMenu"},
+    {0x00200044, nullptr, "StartNewestHomeMenu"},
-    {0x00210000, nullptr,               "OrderToCloseApplication"},
+    {0x00210000, nullptr, "OrderToCloseApplication"},
-    {0x00220040, nullptr,               "PrepareToCloseApplication"},
+    {0x00220040, nullptr, "PrepareToCloseApplication"},
-    {0x00230040, nullptr,               "PrepareToJumpToApplication"},
+    {0x00230040, nullptr, "PrepareToJumpToApplication"},
-    {0x00240044, nullptr,               "JumpToApplication"},
+    {0x00240044, nullptr, "JumpToApplication"},
-    {0x002500C0, nullptr,               "PrepareToCloseLibraryApplet"},
+    {0x002500C0, nullptr, "PrepareToCloseLibraryApplet"},
-    {0x00260000, nullptr,               "PrepareToCloseSystemApplet"},
+    {0x00260000, nullptr, "PrepareToCloseSystemApplet"},
-    {0x00270044, nullptr,               "CloseApplication"},
+    {0x00270044, nullptr, "CloseApplication"},
-    {0x00280044, nullptr,               "CloseLibraryApplet"},
+    {0x00280044, nullptr, "CloseLibraryApplet"},
-    {0x00290044, nullptr,               "CloseSystemApplet"},
+    {0x00290044, nullptr, "CloseSystemApplet"},
-    {0x002A0000, nullptr,               "OrderToCloseSystemApplet"},
+    {0x002A0000, nullptr, "OrderToCloseSystemApplet"},
-    {0x002B0000, nullptr,               "PrepareToJumpToHomeMenu"},
+    {0x002B0000, nullptr, "PrepareToJumpToHomeMenu"},
-    {0x002C0044, nullptr,               "JumpToHomeMenu"},
+    {0x002C0044, nullptr, "JumpToHomeMenu"},
-    {0x002D0000, nullptr,               "PrepareToLeaveHomeMenu"},
+    {0x002D0000, nullptr, "PrepareToLeaveHomeMenu"},
-    {0x002E0044, nullptr,               "LeaveHomeMenu"},
+    {0x002E0044, nullptr, "LeaveHomeMenu"},
-    {0x002F0040, nullptr,               "PrepareToLeaveResidentApplet"},
+    {0x002F0040, nullptr, "PrepareToLeaveResidentApplet"},
-    {0x00300044, nullptr,               "LeaveResidentApplet"},
+    {0x00300044, nullptr, "LeaveResidentApplet"},
-    {0x00310100, nullptr,               "PrepareToDoApplicationJump"},
+    {0x00310100, nullptr, "PrepareToDoApplicationJump"},
-    {0x00320084, nullptr,               "DoApplicationJump"},
+    {0x00320084, nullptr, "DoApplicationJump"},
-    {0x00330000, nullptr,               "GetProgramIdOnApplicationJump"},
+    {0x00330000, nullptr, "GetProgramIdOnApplicationJump"},
-    {0x00340084, nullptr,               "SendDeliverArg"},
+    {0x00340084, nullptr, "SendDeliverArg"},
-    {0x00350080, nullptr,               "ReceiveDeliverArg"},
+    {0x00350080, nullptr, "ReceiveDeliverArg"},
-    {0x00360040, nullptr,               "LoadSysMenuArg"},
+    {0x00360040, nullptr, "LoadSysMenuArg"},
-    {0x00370042, nullptr,               "StoreSysMenuArg"},
+    {0x00370042, nullptr, "StoreSysMenuArg"},
-    {0x00380040, nullptr,               "PreloadResidentApplet"},
+    {0x00380040, nullptr, "PreloadResidentApplet"},
-    {0x00390040, nullptr,               "PrepareToStartResidentApplet"},
+    {0x00390040, nullptr, "PrepareToStartResidentApplet"},
-    {0x003A0044, nullptr,               "StartResidentApplet"},
+    {0x003A0044, nullptr, "StartResidentApplet"},
-    {0x003B0040, nullptr,               "CancelLibraryApplet"},
+    {0x003B0040, nullptr, "CancelLibraryApplet"},
-    {0x003C0042, nullptr,               "SendDspSleep"},
+    {0x003C0042, nullptr, "SendDspSleep"},
-    {0x003D0042, nullptr,               "SendDspWakeUp"},
+    {0x003D0042, nullptr, "SendDspWakeUp"},
-    {0x003E0080, nullptr,               "ReplySleepQuery"},
+    {0x003E0080, nullptr, "ReplySleepQuery"},
-    {0x003F0040, nullptr,               "ReplySleepNotificationComplete"},
+    {0x003F0040, nullptr, "ReplySleepNotificationComplete"},
-    {0x00400042, nullptr,               "SendCaptureBufferInfo"},
+    {0x00400042, nullptr, "SendCaptureBufferInfo"},
-    {0x00410040, nullptr,               "ReceiveCaptureBufferInfo"},
+    {0x00410040, nullptr, "ReceiveCaptureBufferInfo"},
-    {0x00420080, nullptr,               "SleepSystem"},
+    {0x00420080, nullptr, "SleepSystem"},
-    {0x00430040, NotifyToWait,          "NotifyToWait"},
+    {0x00430040, NotifyToWait, "NotifyToWait"},
-    {0x00440000, GetSharedFont,         "GetSharedFont"},
+    {0x00440000, GetSharedFont, "GetSharedFont"},
-    {0x00450040, nullptr,               "GetWirelessRebootInfo"},
+    {0x00450040, nullptr, "GetWirelessRebootInfo"},
-    {0x00460104, nullptr,               "Wrap"},
+    {0x00460104, nullptr, "Wrap"},
-    {0x00470104, nullptr,               "Unwrap"},
+    {0x00470104, nullptr, "Unwrap"},
-    {0x00480100, nullptr,               "GetProgramInfo"},
+    {0x00480100, nullptr, "GetProgramInfo"},
-    {0x00490180, nullptr,               "Reboot"},
+    {0x00490180, nullptr, "Reboot"},
-    {0x004A0040, nullptr,               "GetCaptureInfo"},
+    {0x004A0040, nullptr, "GetCaptureInfo"},
-    {0x004B00C2, AppletUtility,         "AppletUtility"},
+    {0x004B00C2, AppletUtility, "AppletUtility"},
-    {0x004C0000, nullptr,               "SetFatalErrDispMode"},
+    {0x004C0000, nullptr, "SetFatalErrDispMode"},
-    {0x004D0080, nullptr,               "GetAppletProgramInfo"},
+    {0x004D0080, nullptr, "GetAppletProgramInfo"},
-    {0x004E0000, nullptr,               "HardwareResetAsync"},
+    {0x004E0000, nullptr, "HardwareResetAsync"},
-    {0x004F0080, SetAppCpuTimeLimit,    "SetAppCpuTimeLimit"},
+    {0x004F0080, SetAppCpuTimeLimit, "SetAppCpuTimeLimit"},
-    {0x00500040, GetAppCpuTimeLimit,    "GetAppCpuTimeLimit"},
+    {0x00500040, GetAppCpuTimeLimit, "GetAppCpuTimeLimit"},
-    {0x00510080, GetStartupArgument,    "GetStartupArgument"},
+    {0x00510080, GetStartupArgument, "GetStartupArgument"},
-    {0x00520104, nullptr,               "Wrap1"},
+    {0x00520104, nullptr, "Wrap1"},
-    {0x00530104, nullptr,               "Unwrap1"},
+    {0x00530104, nullptr, "Unwrap1"},
    {0x00550040, SetScreenCapPostPermission, "SetScreenCapPostPermission"},
    {0x00560000, GetScreenCapPostPermission, "GetScreenCapPostPermission"},
-    {0x00580002, nullptr,               "GetProgramID"},
+    {0x00580002, nullptr, "GetProgramID"},
-    {0x01010000, CheckNew3DSApp,        "CheckNew3DSApp"},
+    {0x01010000, CheckNew3DSApp, "CheckNew3DSApp"},
-    {0x01020000, CheckNew3DS,           "CheckNew3DS"}
+    {0x01020000, CheckNew3DS, "CheckNew3DS"}};
-};
 APT_S_Interface::APT_S_Interface() {
    Register(FunctionTable);
diff --git a/src/core/hle/service/apt/apt_u.cpp b/src/core/hle/service/apt/apt_u.cpp
index 7bb804ffa..9c6223dd7 100644
--- a/src/core/hle/service/apt/apt_u.cpp
+++ b/src/core/hle/service/apt/apt_u.cpp
@@ -9,95 +9,94 @@ namespace Service {
 namespace APT {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010040, GetLockHandle,                   "GetLockHandle"},
+    {0x00010040, GetLockHandle, "GetLockHandle"},
-    {0x00020080, Initialize,                      "Initialize"},
+    {0x00020080, Initialize, "Initialize"},
-    {0x00030040, Enable,                          "Enable"},
+    {0x00030040, Enable, "Enable"},
-    {0x00040040, nullptr,                         "Finalize"},
+    {0x00040040, nullptr, "Finalize"},
-    {0x00050040, GetAppletManInfo,                "GetAppletManInfo"},
+    {0x00050040, GetAppletManInfo, "GetAppletManInfo"},
-    {0x00060040, GetAppletInfo,                   "GetAppletInfo"},
+    {0x00060040, GetAppletInfo, "GetAppletInfo"},
-    {0x00070000, nullptr,                         "GetLastSignaledAppletId"},
+    {0x00070000, nullptr, "GetLastSignaledAppletId"},
-    {0x00080000, nullptr,                         "CountRegisteredApplet"},
+    {0x00080000, nullptr, "CountRegisteredApplet"},
-    {0x00090040, IsRegistered,                    "IsRegistered"},
+    {0x00090040, IsRegistered, "IsRegistered"},
-    {0x000A0040, nullptr,                         "GetAttribute"},
+    {0x000A0040, nullptr, "GetAttribute"},
-    {0x000B0040, InquireNotification,             "InquireNotification"},
+    {0x000B0040, InquireNotification, "InquireNotification"},
-    {0x000C0104, SendParameter,                   "SendParameter"},
+    {0x000C0104, SendParameter, "SendParameter"},
-    {0x000D0080, ReceiveParameter,                "ReceiveParameter"},
+    {0x000D0080, ReceiveParameter, "ReceiveParameter"},
-    {0x000E0080, GlanceParameter,                 "GlanceParameter"},
+    {0x000E0080, GlanceParameter, "GlanceParameter"},
-    {0x000F0100, CancelParameter,                 "CancelParameter"},
+    {0x000F0100, CancelParameter, "CancelParameter"},
-    {0x001000C2, nullptr,                         "DebugFunc"},
+    {0x001000C2, nullptr, "DebugFunc"},
-    {0x001100C0, nullptr,                         "MapProgramIdForDebug"},
+    {0x001100C0, nullptr, "MapProgramIdForDebug"},
-    {0x00120040, nullptr,                         "SetHomeMenuAppletIdForDebug"},
+    {0x00120040, nullptr, "SetHomeMenuAppletIdForDebug"},
-    {0x00130000, nullptr,                         "GetPreparationState"},
+    {0x00130000, nullptr, "GetPreparationState"},
-    {0x00140040, nullptr,                         "SetPreparationState"},
+    {0x00140040, nullptr, "SetPreparationState"},
-    {0x00150140, PrepareToStartApplication,       "PrepareToStartApplication"},
+    {0x00150140, PrepareToStartApplication, "PrepareToStartApplication"},
-    {0x00160040, PreloadLibraryApplet,            "PreloadLibraryApplet"},
+    {0x00160040, PreloadLibraryApplet, "PreloadLibraryApplet"},
-    {0x00170040, nullptr,                         "FinishPreloadingLibraryApplet"},
+    {0x00170040, nullptr, "FinishPreloadingLibraryApplet"},
-    {0x00180040, PrepareToStartLibraryApplet,     "PrepareToStartLibraryApplet"},
+    {0x00180040, PrepareToStartLibraryApplet, "PrepareToStartLibraryApplet"},
-    {0x00190040, nullptr,                         "PrepareToStartSystemApplet"},
+    {0x00190040, nullptr, "PrepareToStartSystemApplet"},
-    {0x001A0000, nullptr,                         "PrepareToStartNewestHomeMenu"},
+    {0x001A0000, nullptr, "PrepareToStartNewestHomeMenu"},
-    {0x001B00C4, nullptr,                         "StartApplication"},
+    {0x001B00C4, nullptr, "StartApplication"},
-    {0x001C0000, nullptr,                         "WakeupApplication"},
+    {0x001C0000, nullptr, "WakeupApplication"},
-    {0x001D0000, nullptr,                         "CancelApplication"},
+    {0x001D0000, nullptr, "CancelApplication"},
-    {0x001E0084, StartLibraryApplet,              "StartLibraryApplet"},
+    {0x001E0084, StartLibraryApplet, "StartLibraryApplet"},
-    {0x001F0084, nullptr,                         "StartSystemApplet"},
+    {0x001F0084, nullptr, "StartSystemApplet"},
-    {0x00200044, nullptr,                         "StartNewestHomeMenu"},
+    {0x00200044, nullptr, "StartNewestHomeMenu"},
-    {0x00210000, nullptr,                         "OrderToCloseApplication"},
+    {0x00210000, nullptr, "OrderToCloseApplication"},
-    {0x00220040, nullptr,                         "PrepareToCloseApplication"},
+    {0x00220040, nullptr, "PrepareToCloseApplication"},
-    {0x00230040, nullptr,                         "PrepareToJumpToApplication"},
+    {0x00230040, nullptr, "PrepareToJumpToApplication"},
-    {0x00240044, nullptr,                         "JumpToApplication"},
+    {0x00240044, nullptr, "JumpToApplication"},
-    {0x002500C0, nullptr,                         "PrepareToCloseLibraryApplet"},
+    {0x002500C0, nullptr, "PrepareToCloseLibraryApplet"},
-    {0x00260000, nullptr,                         "PrepareToCloseSystemApplet"},
+    {0x00260000, nullptr, "PrepareToCloseSystemApplet"},
-    {0x00270044, nullptr,                         "CloseApplication"},
+    {0x00270044, nullptr, "CloseApplication"},
-    {0x00280044, nullptr,                         "CloseLibraryApplet"},
+    {0x00280044, nullptr, "CloseLibraryApplet"},
-    {0x00290044, nullptr,                         "CloseSystemApplet"},
+    {0x00290044, nullptr, "CloseSystemApplet"},
-    {0x002A0000, nullptr,                         "OrderToCloseSystemApplet"},
+    {0x002A0000, nullptr, "OrderToCloseSystemApplet"},
-    {0x002B0000, nullptr,                         "PrepareToJumpToHomeMenu"},
+    {0x002B0000, nullptr, "PrepareToJumpToHomeMenu"},
-    {0x002C0044, nullptr,                         "JumpToHomeMenu"},
+    {0x002C0044, nullptr, "JumpToHomeMenu"},
-    {0x002D0000, nullptr,                         "PrepareToLeaveHomeMenu"},
+    {0x002D0000, nullptr, "PrepareToLeaveHomeMenu"},
-    {0x002E0044, nullptr,                         "LeaveHomeMenu"},
+    {0x002E0044, nullptr, "LeaveHomeMenu"},
-    {0x002F0040, nullptr,                         "PrepareToLeaveResidentApplet"},
+    {0x002F0040, nullptr, "PrepareToLeaveResidentApplet"},
-    {0x00300044, nullptr,                         "LeaveResidentApplet"},
+    {0x00300044, nullptr, "LeaveResidentApplet"},
-    {0x00310100, nullptr,                         "PrepareToDoApplicationJump"},
+    {0x00310100, nullptr, "PrepareToDoApplicationJump"},
-    {0x00320084, nullptr,                         "DoApplicationJump"},
+    {0x00320084, nullptr, "DoApplicationJump"},
-    {0x00330000, nullptr,                         "GetProgramIdOnApplicationJump"},
+    {0x00330000, nullptr, "GetProgramIdOnApplicationJump"},
-    {0x00340084, nullptr,                         "SendDeliverArg"},
+    {0x00340084, nullptr, "SendDeliverArg"},
-    {0x00350080, nullptr,                         "ReceiveDeliverArg"},
+    {0x00350080, nullptr, "ReceiveDeliverArg"},
-    {0x00360040, nullptr,                         "LoadSysMenuArg"},
+    {0x00360040, nullptr, "LoadSysMenuArg"},
-    {0x00370042, nullptr,                         "StoreSysMenuArg"},
+    {0x00370042, nullptr, "StoreSysMenuArg"},
-    {0x00380040, nullptr,                         "PreloadResidentApplet"},
+    {0x00380040, nullptr, "PreloadResidentApplet"},
-    {0x00390040, nullptr,                         "PrepareToStartResidentApplet"},
+    {0x00390040, nullptr, "PrepareToStartResidentApplet"},
-    {0x003A0044, nullptr,                         "StartResidentApplet"},
+    {0x003A0044, nullptr, "StartResidentApplet"},
-    {0x003B0040, nullptr,                         "CancelLibraryApplet"},
+    {0x003B0040, nullptr, "CancelLibraryApplet"},
-    {0x003C0042, nullptr,                         "SendDspSleep"},
+    {0x003C0042, nullptr, "SendDspSleep"},
-    {0x003D0042, nullptr,                         "SendDspWakeUp"},
+    {0x003D0042, nullptr, "SendDspWakeUp"},
-    {0x003E0080, nullptr,                         "ReplySleepQuery"},
+    {0x003E0080, nullptr, "ReplySleepQuery"},
-    {0x003F0040, nullptr,                         "ReplySleepNotificationComplete"},
+    {0x003F0040, nullptr, "ReplySleepNotificationComplete"},
-    {0x00400042, nullptr,                         "SendCaptureBufferInfo"},
+    {0x00400042, nullptr, "SendCaptureBufferInfo"},
-    {0x00410040, nullptr,                         "ReceiveCaptureBufferInfo"},
+    {0x00410040, nullptr, "ReceiveCaptureBufferInfo"},
-    {0x00420080, nullptr,                         "SleepSystem"},
+    {0x00420080, nullptr, "SleepSystem"},
-    {0x00430040, NotifyToWait,                    "NotifyToWait"},
+    {0x00430040, NotifyToWait, "NotifyToWait"},
-    {0x00440000, GetSharedFont,                   "GetSharedFont"},
+    {0x00440000, GetSharedFont, "GetSharedFont"},
-    {0x00450040, nullptr,                         "GetWirelessRebootInfo"},
+    {0x00450040, nullptr, "GetWirelessRebootInfo"},
-    {0x00460104, nullptr,                         "Wrap"},
+    {0x00460104, nullptr, "Wrap"},
-    {0x00470104, nullptr,                         "Unwrap"},
+    {0x00470104, nullptr, "Unwrap"},
-    {0x00480100, nullptr,                         "GetProgramInfo"},
+    {0x00480100, nullptr, "GetProgramInfo"},
-    {0x00490180, nullptr,                         "Reboot"},
+    {0x00490180, nullptr, "Reboot"},
-    {0x004A0040, nullptr,                         "GetCaptureInfo"},
+    {0x004A0040, nullptr, "GetCaptureInfo"},
-    {0x004B00C2, AppletUtility,                   "AppletUtility"},
+    {0x004B00C2, AppletUtility, "AppletUtility"},
-    {0x004C0000, nullptr,                         "SetFatalErrDispMode"},
+    {0x004C0000, nullptr, "SetFatalErrDispMode"},
-    {0x004D0080, nullptr,                         "GetAppletProgramInfo"},
+    {0x004D0080, nullptr, "GetAppletProgramInfo"},
-    {0x004E0000, nullptr,                         "HardwareResetAsync"},
+    {0x004E0000, nullptr, "HardwareResetAsync"},
-    {0x004F0080, SetAppCpuTimeLimit,              "SetAppCpuTimeLimit"},
+    {0x004F0080, SetAppCpuTimeLimit, "SetAppCpuTimeLimit"},
-    {0x00500040, GetAppCpuTimeLimit,              "GetAppCpuTimeLimit"},
+    {0x00500040, GetAppCpuTimeLimit, "GetAppCpuTimeLimit"},
-    {0x00510080, GetStartupArgument,              "GetStartupArgument"},
+    {0x00510080, GetStartupArgument, "GetStartupArgument"},
-    {0x00520104, nullptr,                         "Wrap1"},
+    {0x00520104, nullptr, "Wrap1"},
-    {0x00530104, nullptr,                         "Unwrap1"},
+    {0x00530104, nullptr, "Unwrap1"},
-    {0x00550040, SetScreenCapPostPermission,      "SetScreenCapPostPermission"},
+    {0x00550040, SetScreenCapPostPermission, "SetScreenCapPostPermission"},
-    {0x00560000, GetScreenCapPostPermission,      "GetScreenCapPostPermission"},
+    {0x00560000, GetScreenCapPostPermission, "GetScreenCapPostPermission"},
-    {0x00580002, nullptr,                         "GetProgramID"},
+    {0x00580002, nullptr, "GetProgramID"},
-    {0x01010000, CheckNew3DSApp,                  "CheckNew3DSApp"},
+    {0x01010000, CheckNew3DSApp, "CheckNew3DSApp"},
-    {0x01020000, CheckNew3DS,                     "CheckNew3DS"}
+    {0x01020000, CheckNew3DS, "CheckNew3DS"}};
-};
 APT_U_Interface::APT_U_Interface() {
    Register(FunctionTable);
diff --git a/src/core/hle/service/boss/boss.cpp b/src/core/hle/service/boss/boss.cpp
index 419ec976e..867b31fbf 100644
--- a/src/core/hle/service/boss/boss.cpp
+++ b/src/core/hle/service/boss/boss.cpp
@@ -2,10 +2,10 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
-#include "core/hle/service/service.h"
 #include "core/hle/service/boss/boss.h"
 #include "core/hle/service/boss/boss_p.h"
 #include "core/hle/service/boss/boss_u.h"
+#include "core/hle/service/service.h"
 namespace Service {
 namespace BOSS {
diff --git a/src/core/hle/service/boss/boss_p.cpp b/src/core/hle/service/boss/boss_p.cpp
index c498abe4e..dfee8d055 100644
--- a/src/core/hle/service/boss/boss_p.cpp
+++ b/src/core/hle/service/boss/boss_p.cpp
@@ -11,7 +11,7 @@ namespace BOSS {
 // const Interface::FunctionInfo FunctionTable[] = { };
 BOSS_P_Interface::BOSS_P_Interface() {
-    //Register(FunctionTable);
+    // Register(FunctionTable);
 }
 } // namespace BOSS
diff --git a/src/core/hle/service/boss/boss_u.cpp b/src/core/hle/service/boss/boss_u.cpp
index d59babe71..6affa23b1 100644
--- a/src/core/hle/service/boss/boss_u.cpp
+++ b/src/core/hle/service/boss/boss_u.cpp
@@ -8,10 +8,10 @@ namespace Service {
 namespace BOSS {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00020100, nullptr,               "GetStorageInfo"},
+    {0x00020100, nullptr, "GetStorageInfo"},
-    {0x000C0082, nullptr,               "UnregisterTask"},
+    {0x000C0082, nullptr, "UnregisterTask"},
-    {0x001E0042, nullptr,               "CancelTask"},
+    {0x001E0042, nullptr, "CancelTask"},
-    {0x00330042, nullptr,               "StartBgImmediate"},
+    {0x00330042, nullptr, "StartBgImmediate"},
 };
 BOSS_U_Interface::BOSS_U_Interface() {
diff --git a/src/core/hle/service/cam/cam.cpp b/src/core/hle/service/cam/cam.cpp
index 6edcf9610..ec1f9c749 100644
--- a/src/core/hle/service/cam/cam.cpp
+++ b/src/core/hle/service/cam/cam.cpp
@@ -71,15 +71,15 @@ void GetBufferErrorInterruptEvent(Service::Interface* self) {
 }
 void SetReceiving(Service::Interface* self) {
-    u32* cmd_buff  = Kernel::GetCommandBuffer();
+    u32* cmd_buff = Kernel::GetCommandBuffer();
-    VAddr dest     = cmd_buff[1];
+    VAddr dest = cmd_buff[1];
-    u8 port        = cmd_buff[2] & 0xFF;
+    u8 port = cmd_buff[2] & 0xFF;
    u32 image_size = cmd_buff[3];
    u16 trans_unit = cmd_buff[4] & 0xFFFF;
-    Kernel::Event* completion_event = (Port)port == Port::Cam2 ?
+    Kernel::Event* completion_event =
-            completion_event_cam2.get() : completion_event_cam1.get();
+        (Port)port == Port::Cam2 ? completion_event_cam2.get() : completion_event_cam1.get();
    completion_event->Signal();
@@ -89,36 +89,36 @@ void SetReceiving(Service::Interface* self) {
    cmd_buff[3] = Kernel::g_handle_table.Create(completion_event).MoveFrom();
    LOG_WARNING(Service_CAM, "(STUBBED) called, addr=0x%X, port=%d, image_size=%d, trans_unit=%d",
-            dest, port, image_size, trans_unit);
+                dest, port, image_size, trans_unit);
 }
 void SetTransferLines(Service::Interface* self) {
-    u32* cmd_buff      = Kernel::GetCommandBuffer();
+    u32* cmd_buff = Kernel::GetCommandBuffer();
-    u8  port           = cmd_buff[1] & 0xFF;
+    u8 port = cmd_buff[1] & 0xFF;
    u16 transfer_lines = cmd_buff[2] & 0xFFFF;
-    u16 width          = cmd_buff[3] & 0xFFFF;
+    u16 width = cmd_buff[3] & 0xFFFF;
-    u16 height         = cmd_buff[4] & 0xFFFF;
+    u16 height = cmd_buff[4] & 0xFFFF;
    cmd_buff[0] = IPC::MakeHeader(0x9, 1, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_WARNING(Service_CAM, "(STUBBED) called, port=%d, lines=%d, width=%d, height=%d",
+    LOG_WARNING(Service_CAM, "(STUBBED) called, port=%d, lines=%d, width=%d, height=%d", port,
-            port, transfer_lines, width, height);
+                transfer_lines, width, height);
 }
 void GetMaxLines(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
-    u16 width  = cmd_buff[1] & 0xFFFF;
+    u16 width = cmd_buff[1] & 0xFFFF;
    u16 height = cmd_buff[2] & 0xFFFF;
    cmd_buff[0] = IPC::MakeHeader(0xA, 2, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw;
    cmd_buff[2] = TRANSFER_BYTES / (2 * width);
-    LOG_WARNING(Service_CAM, "(STUBBED) called, width=%d, height=%d, lines = %d",
+    LOG_WARNING(Service_CAM, "(STUBBED) called, width=%d, height=%d, lines = %d", width, height,
-            width, height, cmd_buff[2]);
+                cmd_buff[2]);
 }
 void GetTransferBytes(Service::Interface* self) {
@@ -136,7 +136,7 @@ void GetTransferBytes(Service::Interface* self) {
 void SetTrimming(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
-    u8   port = cmd_buff[1] & 0xFF;
+    u8 port = cmd_buff[1] & 0xFF;
    bool trim = (cmd_buff[2] & 0xFF) != 0;
    cmd_buff[0] = IPC::MakeHeader(0xE, 1, 0);
@@ -148,17 +148,17 @@ void SetTrimming(Service::Interface* self) {
 void SetTrimmingParamsCenter(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
-    u8  port  = cmd_buff[1] & 0xFF;
+    u8 port = cmd_buff[1] & 0xFF;
    s16 trimW = cmd_buff[2] & 0xFFFF;
    s16 trimH = cmd_buff[3] & 0xFFFF;
-    s16 camW  = cmd_buff[4] & 0xFFFF;
+    s16 camW = cmd_buff[4] & 0xFFFF;
-    s16 camH  = cmd_buff[5] & 0xFFFF;
+    s16 camH = cmd_buff[5] & 0xFFFF;
    cmd_buff[0] = IPC::MakeHeader(0x12, 1, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw;
    LOG_WARNING(Service_CAM, "(STUBBED) called, port=%d, trimW=%d, trimH=%d, camW=%d, camH=%d",
-            port, trimW, trimH, camW, camH);
+                port, trimW, trimH, camW, camH);
 }
 void Activate(Service::Interface* self) {
@@ -169,36 +169,35 @@ void Activate(Service::Interface* self) {
    cmd_buff[0] = IPC::MakeHeader(0x13, 1, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_WARNING(Service_CAM, "(STUBBED) called, cam_select=%d",
+    LOG_WARNING(Service_CAM, "(STUBBED) called, cam_select=%d", cam_select);
-            cam_select);
 }
 void FlipImage(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    u8 cam_select = cmd_buff[1] & 0xFF;
-    u8 flip       = cmd_buff[2] & 0xFF;
+    u8 flip = cmd_buff[2] & 0xFF;
-    u8 context    = cmd_buff[3] & 0xFF;
+    u8 context = cmd_buff[3] & 0xFF;
    cmd_buff[0] = IPC::MakeHeader(0x1D, 1, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_WARNING(Service_CAM, "(STUBBED) called, cam_select=%d, flip=%d, context=%d",
+    LOG_WARNING(Service_CAM, "(STUBBED) called, cam_select=%d, flip=%d, context=%d", cam_select,
-            cam_select, flip, context);
+                flip, context);
 }
 void SetSize(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    u8 cam_select = cmd_buff[1] & 0xFF;
-    u8 size       = cmd_buff[2] & 0xFF;
+    u8 size = cmd_buff[2] & 0xFF;
-    u8 context    = cmd_buff[3] & 0xFF;
+    u8 context = cmd_buff[3] & 0xFF;
    cmd_buff[0] = IPC::MakeHeader(0x1F, 1, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_WARNING(Service_CAM, "(STUBBED) called, cam_select=%d, size=%d, context=%d",
+    LOG_WARNING(Service_CAM, "(STUBBED) called, cam_select=%d, size=%d, context=%d", cam_select,
-            cam_select, size, context);
+                size, context);
 }
 void SetFrameRate(Service::Interface* self) {
@@ -210,8 +209,8 @@ void SetFrameRate(Service::Interface* self) {
    cmd_buff[0] = IPC::MakeHeader(0x20, 1, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_WARNING(Service_CAM, "(STUBBED) called, cam_select=%d, frame_rate=%d",
+    LOG_WARNING(Service_CAM, "(STUBBED) called, cam_select=%d, frame_rate=%d", cam_select,
-            cam_select, frame_rate);
+                frame_rate);
 }
 void GetStereoCameraCalibrationData(Service::Interface* self) {
@@ -293,10 +292,14 @@ void Init() {
    AddService(new CAM_S_Interface);
    AddService(new CAM_U_Interface);
-    completion_event_cam1 = Kernel::Event::Create(ResetType::OneShot, "CAM_U::completion_event_cam1");
+    completion_event_cam1 =
-    completion_event_cam2 = Kernel::Event::Create(ResetType::OneShot, "CAM_U::completion_event_cam2");
+        Kernel::Event::Create(ResetType::OneShot, "CAM_U::completion_event_cam1");
-    interrupt_error_event = Kernel::Event::Create(ResetType::OneShot, "CAM_U::interrupt_error_event");
+    completion_event_cam2 =
-    vsync_interrupt_error_event = Kernel::Event::Create(ResetType::OneShot, "CAM_U::vsync_interrupt_error_event");
+        Kernel::Event::Create(ResetType::OneShot, "CAM_U::completion_event_cam2");
+    interrupt_error_event =
+        Kernel::Event::Create(ResetType::OneShot, "CAM_U::interrupt_error_event");
+    vsync_interrupt_error_event =
+        Kernel::Event::Create(ResetType::OneShot, "CAM_U::vsync_interrupt_error_event");
 }
 void Shutdown() {
diff --git a/src/core/hle/service/cam/cam.h b/src/core/hle/service/cam/cam.h
index 2f4923728..a87183493 100644
--- a/src/core/hle/service/cam/cam.h
+++ b/src/core/hle/service/cam/cam.h
@@ -14,12 +14,7 @@
 namespace Service {
 namespace CAM {
-enum class Port : u8 {
+enum class Port : u8 { None = 0, Cam1 = 1, Cam2 = 2, Both = Cam1 | Cam2 };
-    None = 0,
-    Cam1 = 1,
-    Cam2 = 2,
-    Both = Cam1 | Cam2
-};
 enum class CameraSelect : u8 {
    None = 0,
@@ -32,28 +27,11 @@ enum class CameraSelect : u8 {
    All = Out1 | In1 | Out2
 };
-enum class Effect : u8 {
+enum class Effect : u8 { None = 0, Mono = 1, Sepia = 2, Negative = 3, Negafilm = 4, Sepia01 = 5 };
-    None = 0,
-    Mono = 1,
-    Sepia = 2,
-    Negative = 3,
-    Negafilm = 4,
-    Sepia01 = 5
-};
-enum class Context : u8 {
+enum class Context : u8 { None = 0, A = 1, B = 2, Both = A | B };
-    None = 0,
-    A = 1,
-    B = 2,
-    Both = A | B
-};
-enum class Flip : u8 {
+enum class Flip : u8 { None = 0, Horizontal = 1, Vertical = 2, Reverse = 3 };
-    None = 0,
-    Horizontal = 1,
-    Vertical = 2,
-    Reverse = 3
-};
 enum class Size : u8 {
    VGA = 0,
@@ -83,11 +61,7 @@ enum class FrameRate : u8 {
    Rate_30_To_10 = 12
 };
-enum class ShutterSoundType : u8 {
+enum class ShutterSoundType : u8 { Normal = 0, Movie = 1, MovieEnd = 2 };
-    Normal = 0,
-    Movie = 1,
-    MovieEnd = 2
-};
 enum class WhiteBalance : u8 {
    BalanceAuto = 0,
@@ -106,13 +80,7 @@ enum class WhiteBalance : u8 {
    BalanceShade = Balance7000K
 };
-enum class PhotoMode : u8 {
+enum class PhotoMode : u8 { Normal = 0, Portrait = 1, Landscape = 2, Nightview = 3, Letter0 = 4 };
-    Normal = 0,
-    Portrait = 1,
-    Landscape = 2,
-    Nightview = 3,
-    Letter0 = 4
-};
 enum class LensCorrection : u8 {
    Off = 0,
@@ -140,21 +108,18 @@ enum class Contrast : u8 {
    High = Pattern07
 };
-enum class OutputFormat : u8 {
+enum class OutputFormat : u8 { YUV422 = 0, RGB565 = 1 };
-    YUV422 = 0,
-    RGB565 = 1
-};
 /// Stereo camera calibration data.
 struct StereoCameraCalibrationData {
-    u8 isValidRotationXY;      ///< Bool indicating whether the X and Y rotation data is valid.
+    u8 isValidRotationXY; ///< Bool indicating whether the X and Y rotation data is valid.
    INSERT_PADDING_BYTES(3);
-    float_le scale;            ///< Scale to match the left camera image with the right.
+    float_le scale;        ///< Scale to match the left camera image with the right.
-    float_le rotationZ;        ///< Z axis rotation to match the left camera image with the right.
+    float_le rotationZ;    ///< Z axis rotation to match the left camera image with the right.
-    float_le translationX;     ///< X axis translation to match the left camera image with the right.
+    float_le translationX; ///< X axis translation to match the left camera image with the right.
-    float_le translationY;     ///< Y axis translation to match the left camera image with the right.
+    float_le translationY; ///< Y axis translation to match the left camera image with the right.
-    float_le rotationX;        ///< X axis rotation to match the left camera image with the right.
+    float_le rotationX;    ///< X axis rotation to match the left camera image with the right.
-    float_le rotationY;        ///< Y axis rotation to match the left camera image with the right.
+    float_le rotationY;    ///< Y axis rotation to match the left camera image with the right.
    float_le angleOfViewRight; ///< Right camera angle of view.
    float_le angleOfViewLeft;  ///< Left camera angle of view.
    float_le distanceToChart;  ///< Distance between cameras and measurement chart.
@@ -163,7 +128,8 @@ struct StereoCameraCalibrationData {
    s16_le imageHeight;        ///< Image height.
    INSERT_PADDING_BYTES(16);
 };
-static_assert(sizeof(StereoCameraCalibrationData) == 64, "StereoCameraCalibrationData structure size is wrong");
+static_assert(sizeof(StereoCameraCalibrationData) == 64,
+              "StereoCameraCalibrationData structure size is wrong");
 struct PackageParameterCameraSelect {
    CameraSelect camera;
@@ -188,7 +154,8 @@ struct PackageParameterCameraSelect {
    s16 auto_white_balance_window_height;
 };
-static_assert(sizeof(PackageParameterCameraSelect) == 28, "PackageParameterCameraSelect structure size is wrong");
+static_assert(sizeof(PackageParameterCameraSelect) == 28,
+              "PackageParameterCameraSelect structure size is wrong");
 /**
 * Unknown
diff --git a/src/core/hle/service/cam/cam_c.cpp b/src/core/hle/service/cam/cam_c.cpp
index 8fa7abc85..93b047c1a 100644
--- a/src/core/hle/service/cam/cam_c.cpp
+++ b/src/core/hle/service/cam/cam_c.cpp
@@ -8,10 +8,10 @@ namespace Service {
 namespace CAM {
 // Empty arrays are illegal -- commented out until an entry is added.
-//const Interface::FunctionInfo FunctionTable[] = { };
+// const Interface::FunctionInfo FunctionTable[] = { };
 CAM_C_Interface::CAM_C_Interface() {
-    //Register(FunctionTable);
+    // Register(FunctionTable);
 }
 } // namespace CAM
diff --git a/src/core/hle/service/cam/cam_q.cpp b/src/core/hle/service/cam/cam_q.cpp
index d3ba91e9d..2ba853606 100644
--- a/src/core/hle/service/cam/cam_q.cpp
+++ b/src/core/hle/service/cam/cam_q.cpp
@@ -8,10 +8,10 @@ namespace Service {
 namespace CAM {
 // Empty arrays are illegal -- commented out until an entry is added.
-//const Interface::FunctionInfo FunctionTable[] = { };
+// const Interface::FunctionInfo FunctionTable[] = { };
 CAM_Q_Interface::CAM_Q_Interface() {
-    //Register(FunctionTable);
+    // Register(FunctionTable);
 }
 } // namespace CAM
diff --git a/src/core/hle/service/cam/cam_s.cpp b/src/core/hle/service/cam/cam_s.cpp
index 2a13984d8..f1c6da587 100644
--- a/src/core/hle/service/cam/cam_s.cpp
+++ b/src/core/hle/service/cam/cam_s.cpp
@@ -8,10 +8,10 @@ namespace Service {
 namespace CAM {
 // Empty arrays are illegal -- commented out until an entry is added.
-//const Interface::FunctionInfo FunctionTable[] = { };
+// const Interface::FunctionInfo FunctionTable[] = { };
 CAM_S_Interface::CAM_S_Interface() {
-    //Register(FunctionTable);
+    // Register(FunctionTable);
 }
 } // namespace CAM
diff --git a/src/core/hle/service/cam/cam_u.cpp b/src/core/hle/service/cam/cam_u.cpp
index a1070ebb2..af2123e5b 100644
--- a/src/core/hle/service/cam/cam_u.cpp
+++ b/src/core/hle/service/cam/cam_u.cpp
@@ -9,68 +9,68 @@ namespace Service {
 namespace CAM {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010040, StartCapture,                        "StartCapture"},
+    {0x00010040, StartCapture, "StartCapture"},
-    {0x00020040, StopCapture,                         "StopCapture"},
+    {0x00020040, StopCapture, "StopCapture"},
-    {0x00030040, nullptr,                             "IsBusy"},
+    {0x00030040, nullptr, "IsBusy"},
-    {0x00040040, nullptr,                             "ClearBuffer"},
+    {0x00040040, nullptr, "ClearBuffer"},
-    {0x00050040, GetVsyncInterruptEvent,              "GetVsyncInterruptEvent"},
+    {0x00050040, GetVsyncInterruptEvent, "GetVsyncInterruptEvent"},
-    {0x00060040, GetBufferErrorInterruptEvent,        "GetBufferErrorInterruptEvent"},
+    {0x00060040, GetBufferErrorInterruptEvent, "GetBufferErrorInterruptEvent"},
-    {0x00070102, SetReceiving,                        "SetReceiving"},
+    {0x00070102, SetReceiving, "SetReceiving"},
-    {0x00080040, nullptr,                             "IsFinishedReceiving"},
+    {0x00080040, nullptr, "IsFinishedReceiving"},
-    {0x00090100, SetTransferLines,                    "SetTransferLines"},
+    {0x00090100, SetTransferLines, "SetTransferLines"},
-    {0x000A0080, GetMaxLines,                         "GetMaxLines"},
+    {0x000A0080, GetMaxLines, "GetMaxLines"},
-    {0x000B0100, nullptr,                             "SetTransferBytes"},
+    {0x000B0100, nullptr, "SetTransferBytes"},
-    {0x000C0040, GetTransferBytes,                    "GetTransferBytes"},
+    {0x000C0040, GetTransferBytes, "GetTransferBytes"},
-    {0x000D0080, nullptr,                             "GetMaxBytes"},
+    {0x000D0080, nullptr, "GetMaxBytes"},
-    {0x000E0080, SetTrimming,                         "SetTrimming"},
+    {0x000E0080, SetTrimming, "SetTrimming"},
-    {0x000F0040, nullptr,                             "IsTrimming"},
+    {0x000F0040, nullptr, "IsTrimming"},
-    {0x00100140, nullptr,                             "SetTrimmingParams"},
+    {0x00100140, nullptr, "SetTrimmingParams"},
-    {0x00110040, nullptr,                             "GetTrimmingParams"},
+    {0x00110040, nullptr, "GetTrimmingParams"},
-    {0x00120140, SetTrimmingParamsCenter,             "SetTrimmingParamsCenter"},
+    {0x00120140, SetTrimmingParamsCenter, "SetTrimmingParamsCenter"},
-    {0x00130040, Activate,                            "Activate"},
+    {0x00130040, Activate, "Activate"},
-    {0x00140080, nullptr,                             "SwitchContext"},
+    {0x00140080, nullptr, "SwitchContext"},
-    {0x00150080, nullptr,                             "SetExposure"},
+    {0x00150080, nullptr, "SetExposure"},
-    {0x00160080, nullptr,                             "SetWhiteBalance"},
+    {0x00160080, nullptr, "SetWhiteBalance"},
-    {0x00170080, nullptr,                             "SetWhiteBalanceWithoutBaseUp"},
+    {0x00170080, nullptr, "SetWhiteBalanceWithoutBaseUp"},
-    {0x00180080, nullptr,                             "SetSharpness"},
+    {0x00180080, nullptr, "SetSharpness"},
-    {0x00190080, nullptr,                             "SetAutoExposure"},
+    {0x00190080, nullptr, "SetAutoExposure"},
-    {0x001A0040, nullptr,                             "IsAutoExposure"},
+    {0x001A0040, nullptr, "IsAutoExposure"},
-    {0x001B0080, nullptr,                             "SetAutoWhiteBalance"},
+    {0x001B0080, nullptr, "SetAutoWhiteBalance"},
-    {0x001C0040, nullptr,                             "IsAutoWhiteBalance"},
+    {0x001C0040, nullptr, "IsAutoWhiteBalance"},
-    {0x001D00C0, FlipImage,                           "FlipImage"},
+    {0x001D00C0, FlipImage, "FlipImage"},
-    {0x001E0200, nullptr,                             "SetDetailSize"},
+    {0x001E0200, nullptr, "SetDetailSize"},
-    {0x001F00C0, SetSize,                             "SetSize"},
+    {0x001F00C0, SetSize, "SetSize"},
-    {0x00200080, SetFrameRate,                        "SetFrameRate"},
+    {0x00200080, SetFrameRate, "SetFrameRate"},
-    {0x00210080, nullptr,                             "SetPhotoMode"},
+    {0x00210080, nullptr, "SetPhotoMode"},
-    {0x002200C0, nullptr,                             "SetEffect"},
+    {0x002200C0, nullptr, "SetEffect"},
-    {0x00230080, nullptr,                             "SetContrast"},
+    {0x00230080, nullptr, "SetContrast"},
-    {0x00240080, nullptr,                             "SetLensCorrection"},
+    {0x00240080, nullptr, "SetLensCorrection"},
-    {0x002500C0, nullptr,                             "SetOutputFormat"},
+    {0x002500C0, nullptr, "SetOutputFormat"},
-    {0x00260140, nullptr,                             "SetAutoExposureWindow"},
+    {0x00260140, nullptr, "SetAutoExposureWindow"},
-    {0x00270140, nullptr,                             "SetAutoWhiteBalanceWindow"},
+    {0x00270140, nullptr, "SetAutoWhiteBalanceWindow"},
-    {0x00280080, nullptr,                             "SetNoiseFilter"},
+    {0x00280080, nullptr, "SetNoiseFilter"},
-    {0x00290080, nullptr,                             "SynchronizeVsyncTiming"},
+    {0x00290080, nullptr, "SynchronizeVsyncTiming"},
-    {0x002A0080, nullptr,                             "GetLatestVsyncTiming"},
+    {0x002A0080, nullptr, "GetLatestVsyncTiming"},
-    {0x002B0000, GetStereoCameraCalibrationData,      "GetStereoCameraCalibrationData"},
+    {0x002B0000, GetStereoCameraCalibrationData, "GetStereoCameraCalibrationData"},
-    {0x002C0400, nullptr,                             "SetStereoCameraCalibrationData"},
+    {0x002C0400, nullptr, "SetStereoCameraCalibrationData"},
-    {0x002D00C0, nullptr,                             "WriteRegisterI2c"},
+    {0x002D00C0, nullptr, "WriteRegisterI2c"},
-    {0x002E00C0, nullptr,                             "WriteMcuVariableI2c"},
+    {0x002E00C0, nullptr, "WriteMcuVariableI2c"},
-    {0x002F0080, nullptr,                             "ReadRegisterI2cExclusive"},
+    {0x002F0080, nullptr, "ReadRegisterI2cExclusive"},
-    {0x00300080, nullptr,                             "ReadMcuVariableI2cExclusive"},
+    {0x00300080, nullptr, "ReadMcuVariableI2cExclusive"},
-    {0x00310180, nullptr,                             "SetImageQualityCalibrationData"},
+    {0x00310180, nullptr, "SetImageQualityCalibrationData"},
-    {0x00320000, nullptr,                             "GetImageQualityCalibrationData"},
+    {0x00320000, nullptr, "GetImageQualityCalibrationData"},
-    {0x003302C0, nullptr,                             "SetPackageParameterWithoutContext"},
+    {0x003302C0, nullptr, "SetPackageParameterWithoutContext"},
-    {0x00340140, nullptr,                             "SetPackageParameterWithContext"},
+    {0x00340140, nullptr, "SetPackageParameterWithContext"},
-    {0x003501C0, nullptr,                             "SetPackageParameterWithContextDetail"},
+    {0x003501C0, nullptr, "SetPackageParameterWithContextDetail"},
-    {0x00360000, GetSuitableY2rStandardCoefficient,   "GetSuitableY2rStandardCoefficient"},
+    {0x00360000, GetSuitableY2rStandardCoefficient, "GetSuitableY2rStandardCoefficient"},
-    {0x00370202, nullptr,                             "PlayShutterSoundWithWave"},
+    {0x00370202, nullptr, "PlayShutterSoundWithWave"},
-    {0x00380040, PlayShutterSound,                    "PlayShutterSound"},
+    {0x00380040, PlayShutterSound, "PlayShutterSound"},
-    {0x00390000, DriverInitialize,                    "DriverInitialize"},
+    {0x00390000, DriverInitialize, "DriverInitialize"},
-    {0x003A0000, DriverFinalize,                      "DriverFinalize"},
+    {0x003A0000, DriverFinalize, "DriverFinalize"},
-    {0x003B0000, nullptr,                             "GetActivatedCamera"},
+    {0x003B0000, nullptr, "GetActivatedCamera"},
-    {0x003C0000, nullptr,                             "GetSleepCamera"},
+    {0x003C0000, nullptr, "GetSleepCamera"},
-    {0x003D0040, nullptr,                             "SetSleepCamera"},
+    {0x003D0040, nullptr, "SetSleepCamera"},
-    {0x003E0040, nullptr,                             "SetBrightnessSynchronization"},
+    {0x003E0040, nullptr, "SetBrightnessSynchronization"},
 };
 CAM_U_Interface::CAM_U_Interface() {
diff --git a/src/core/hle/service/cecd/cecd.cpp b/src/core/hle/service/cecd/cecd.cpp
index 50c03495e..65a1d850b 100644
--- a/src/core/hle/service/cecd/cecd.cpp
+++ b/src/core/hle/service/cecd/cecd.cpp
@@ -5,10 +5,10 @@
 #include "common/logging/log.h"
 #include "core/hle/kernel/event.h"
-#include "core/hle/service/service.h"
 #include "core/hle/service/cecd/cecd.h"
 #include "core/hle/service/cecd/cecd_s.h"
 #include "core/hle/service/cecd/cecd_u.h"
+#include "core/hle/service/service.h"
 namespace Service {
 namespace CECD {
@@ -28,7 +28,7 @@ void GetCecStateAbbreviated(Service::Interface* self) {
 void GetCecInfoEventHandle(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
-    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
+    cmd_buff[1] = RESULT_SUCCESS.raw;                                      // No error
    cmd_buff[3] = Kernel::g_handle_table.Create(cecinfo_event).MoveFrom(); // Event handle
    LOG_WARNING(Service_CECD, "(STUBBED) called");
@@ -37,7 +37,7 @@ void GetCecInfoEventHandle(Service::Interface* self) {
 void GetChangeStateEventHandle(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
-    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
+    cmd_buff[1] = RESULT_SUCCESS.raw;                                           // No error
    cmd_buff[3] = Kernel::g_handle_table.Create(change_state_event).MoveFrom(); // Event handle
    LOG_WARNING(Service_CECD, "(STUBBED) called");
@@ -48,7 +48,8 @@ void Init() {
    AddService(new CECD_U_Interface);
    cecinfo_event = Kernel::Event::Create(Kernel::ResetType::OneShot, "CECD_U::cecinfo_event");
-    change_state_event = Kernel::Event::Create(Kernel::ResetType::OneShot, "CECD_U::change_state_event");
+    change_state_event =
+        Kernel::Event::Create(Kernel::ResetType::OneShot, "CECD_U::change_state_event");
 }
 void Shutdown() {
diff --git a/src/core/hle/service/cecd/cecd.h b/src/core/hle/service/cecd/cecd.h
index 435611363..ea97f9266 100644
--- a/src/core/hle/service/cecd/cecd.h
+++ b/src/core/hle/service/cecd/cecd.h
@@ -11,11 +11,13 @@ class Interface;
 namespace CECD {
 enum class CecStateAbbreviated {
-    CEC_STATE_ABBREV_IDLE      = 1, ///< Corresponds to CEC_STATE_IDLE
+    CEC_STATE_ABBREV_IDLE = 1,      ///< Corresponds to CEC_STATE_IDLE
    CEC_STATE_ABBREV_NOT_LOCAL = 2, ///< Corresponds to CEC_STATEs *FINISH*, *POST, and OVER_BOSS
-    CEC_STATE_ABBREV_SCANNING  = 3, ///< Corresponds to CEC_STATE_SCANNING
+    CEC_STATE_ABBREV_SCANNING = 3,  ///< Corresponds to CEC_STATE_SCANNING
-    CEC_STATE_ABBREV_WLREADY   = 4, ///< Corresponds to CEC_STATE_WIRELESS_READY when some unknown bool is true
+    CEC_STATE_ABBREV_WLREADY =
-    CEC_STATE_ABBREV_OTHER     = 5, ///< Corresponds to CEC_STATEs besides *FINISH*, *POST, and OVER_BOSS and those listed here
+        4, ///< Corresponds to CEC_STATE_WIRELESS_READY when some unknown bool is true
+    CEC_STATE_ABBREV_OTHER = 5, ///< Corresponds to CEC_STATEs besides *FINISH*, *POST, and
+                                /// OVER_BOSS and those listed here
 };
 /**
diff --git a/src/core/hle/service/cecd/cecd_s.cpp b/src/core/hle/service/cecd/cecd_s.cpp
index bfd821c07..7477b9320 100644
--- a/src/core/hle/service/cecd/cecd_s.cpp
+++ b/src/core/hle/service/cecd/cecd_s.cpp
@@ -8,10 +8,10 @@ namespace Service {
 namespace CECD {
 // Empty arrays are illegal -- commented out until an entry is added.
-//const Interface::FunctionInfo FunctionTable[] = { };
+// const Interface::FunctionInfo FunctionTable[] = { };
 CECD_S_Interface::CECD_S_Interface() {
-    //Register(FunctionTable);
+    // Register(FunctionTable);
 }
 } // namespace CECD
diff --git a/src/core/hle/service/cecd/cecd_u.cpp b/src/core/hle/service/cecd/cecd_u.cpp
index be6d4d8f6..4b747de7b 100644
--- a/src/core/hle/service/cecd/cecd_u.cpp
+++ b/src/core/hle/service/cecd/cecd_u.cpp
@@ -9,10 +9,10 @@ namespace Service {
 namespace CECD {
 static const Interface::FunctionInfo FunctionTable[] = {
-    {0x000E0000, GetCecStateAbbreviated,    "GetCecStateAbbreviated"},
+    {0x000E0000, GetCecStateAbbreviated, "GetCecStateAbbreviated"},
-    {0x000F0000, GetCecInfoEventHandle,     "GetCecInfoEventHandle"},
+    {0x000F0000, GetCecInfoEventHandle, "GetCecInfoEventHandle"},
    {0x00100000, GetChangeStateEventHandle, "GetChangeStateEventHandle"},
-    {0x00120104, nullptr,                   "ReadSavedData"},
+    {0x00120104, nullptr, "ReadSavedData"},
 };
 CECD_U_Interface::CECD_U_Interface() {
diff --git a/src/core/hle/service/cfg/cfg.cpp b/src/core/hle/service/cfg/cfg.cpp
index a5dc47322..fe97a69d1 100644
--- a/src/core/hle/service/cfg/cfg.cpp
+++ b/src/core/hle/service/cfg/cfg.cpp
@@ -11,7 +11,6 @@
 #include "core/file_sys/archive_systemsavedata.h"
 #include "core/file_sys/file_backend.h"
-#include "core/settings.h"
 #include "core/hle/result.h"
 #include "core/hle/service/cfg/cfg.h"
 #include "core/hle/service/cfg/cfg_i.h"
@@ -19,6 +18,7 @@
 #include "core/hle/service/cfg/cfg_u.h"
 #include "core/hle/service/fs/archive.h"
 #include "core/hle/service/service.h"
+#include "core/settings.h"
 namespace Service {
 namespace CFG {
@@ -33,25 +33,29 @@ namespace {
 * contains information about the blocks in the file
 */
 struct SaveFileConfig {
-    u16 total_entries;                        ///< The total number of set entries in the config file
+    u16 total_entries;       ///< The total number of set entries in the config file
-    u16 data_entries_offset;                  ///< The offset where the data for the blocks start, this is hardcoded to 0x455C as per hardware
+    u16 data_entries_offset; ///< The offset where the data for the blocks start, this is hardcoded
-    SaveConfigBlockEntry block_entries[CONFIG_FILE_MAX_BLOCK_ENTRIES]; ///< The block headers, the maximum possible value is 1479 as per hardware
+                             /// to 0x455C as per hardware
-    u32 unknown;                              ///< This field is unknown, possibly padding, 0 has been observed in hardware
+    SaveConfigBlockEntry block_entries[CONFIG_FILE_MAX_BLOCK_ENTRIES]; ///< The block headers, the
+                                                                       /// maximum possible value is
+    /// 1479 as per hardware
+    u32 unknown; ///< This field is unknown, possibly padding, 0 has been observed in hardware
 };
-static_assert(sizeof(SaveFileConfig) == 0x455C, "SaveFileConfig header must be exactly 0x455C bytes");
+static_assert(sizeof(SaveFileConfig) == 0x455C,
+              "SaveFileConfig header must be exactly 0x455C bytes");
 enum ConfigBlockID {
    StereoCameraSettingsBlockID = 0x00050005,
-    SoundOutputModeBlockID      = 0x00070001,
+    SoundOutputModeBlockID = 0x00070001,
-    ConsoleUniqueIDBlockID      = 0x00090001,
+    ConsoleUniqueIDBlockID = 0x00090001,
-    UsernameBlockID             = 0x000A0000,
+    UsernameBlockID = 0x000A0000,
-    BirthdayBlockID             = 0x000A0001,
+    BirthdayBlockID = 0x000A0001,
-    LanguageBlockID             = 0x000A0002,
+    LanguageBlockID = 0x000A0002,
-    CountryInfoBlockID          = 0x000B0000,
+    CountryInfoBlockID = 0x000B0000,
-    CountryNameBlockID          = 0x000B0001,
+    CountryNameBlockID = 0x000B0001,
-    StateNameBlockID            = 0x000B0002,
+    StateNameBlockID = 0x000B0002,
-    EULAVersionBlockID          = 0x000D0000,
+    EULAVersionBlockID = 0x000D0000,
-    ConsoleModelBlockID         = 0x000F0004,
+    ConsoleModelBlockID = 0x000F0004,
 };
 struct UsernameBlock {
@@ -68,8 +72,8 @@ struct BirthdayBlock {
 static_assert(sizeof(BirthdayBlock) == 2, "BirthdayBlock must be exactly 2 bytes");
 struct ConsoleModelInfo {
-    u8 model;       ///< The console model (3DS, 2DS, etc)
+    u8 model;      ///< The console model (3DS, 2DS, etc)
-    u8 unknown[3];  ///< Unknown data
+    u8 unknown[3]; ///< Unknown data
 };
 static_assert(sizeof(ConsoleModelInfo) == 4, "ConsoleModelInfo must be exactly 4 bytes");
@@ -78,36 +82,36 @@ struct ConsoleCountryInfo {
    u8 country_code; ///< The country code of the console
 };
 static_assert(sizeof(ConsoleCountryInfo) == 4, "ConsoleCountryInfo must be exactly 4 bytes");
 }
 static const u64 CFG_SAVE_ID = 0x00010017;
 static const u64 CONSOLE_UNIQUE_ID = 0xDEADC0DE;
-static const ConsoleModelInfo CONSOLE_MODEL = { NINTENDO_3DS_XL, { 0, 0, 0 } };
+static const ConsoleModelInfo CONSOLE_MODEL = {NINTENDO_3DS_XL, {0, 0, 0}};
 static const u8 CONSOLE_LANGUAGE = LANGUAGE_EN;
-static const UsernameBlock CONSOLE_USERNAME_BLOCK = { u"CITRA", 0, 0 };
+static const UsernameBlock CONSOLE_USERNAME_BLOCK = {u"CITRA", 0, 0};
-static const BirthdayBlock PROFILE_BIRTHDAY = { 3, 25 }; // March 25th, 2014
+static const BirthdayBlock PROFILE_BIRTHDAY = {3, 25}; // March 25th, 2014
 static const u8 SOUND_OUTPUT_MODE = SOUND_SURROUND;
 static const u8 UNITED_STATES_COUNTRY_ID = 49;
 /// TODO(Subv): Find what the other bytes are
-static const ConsoleCountryInfo COUNTRY_INFO = { { 0, 0, 0 }, UNITED_STATES_COUNTRY_ID };
+static const ConsoleCountryInfo COUNTRY_INFO = {{0, 0, 0}, UNITED_STATES_COUNTRY_ID};
 /**
 * TODO(Subv): Find out what this actually is, these values fix some NaN uniforms in some games,
 * for example Nintendo Zone
 * Thanks Normmatt for providing this information
 */
-static const std::array<float, 8> STEREO_CAMERA_SETTINGS = {{
+static const std::array<float, 8> STEREO_CAMERA_SETTINGS = {
-    62.0f, 289.0f, 76.80000305175781f, 46.08000183105469f,
+    {62.0f, 289.0f, 76.80000305175781f, 46.08000183105469f, 10.0f, 5.0f, 55.58000183105469f,
-    10.0f, 5.0f, 55.58000183105469f, 21.56999969482422f
+     21.56999969482422f}};
-}};
+static_assert(sizeof(STEREO_CAMERA_SETTINGS) == 0x20,
-static_assert(sizeof(STEREO_CAMERA_SETTINGS) == 0x20, "STEREO_CAMERA_SETTINGS must be exactly 0x20 bytes");
+              "STEREO_CAMERA_SETTINGS must be exactly 0x20 bytes");
 static const u32 CONFIG_SAVEFILE_SIZE = 0x8000;
 static std::array<u8, CONFIG_SAVEFILE_SIZE> cfg_config_file_buffer;
 static Service::FS::ArchiveHandle cfg_system_save_data_archive;
-static const std::vector<u8> cfg_system_savedata_id = { 0x00, 0x00, 0x00, 0x00, 0x17, 0x00, 0x01, 0x00 };
+static const std::vector<u8> cfg_system_savedata_id = {0x00, 0x00, 0x00, 0x00,
+                                                       0x17, 0x00, 0x01, 0x00};
 void GetCountryCodeString(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
@@ -115,7 +119,9 @@ void GetCountryCodeString(Service::Interface* self) {
    if (country_code_id >= country_codes.size() || 0 == country_codes[country_code_id]) {
        LOG_ERROR(Service_CFG, "requested country code id=%d is invalid", country_code_id);
-        cmd_buff[1] = ResultCode(ErrorDescription::NotFound, ErrorModule::Config, ErrorSummary::WrongArgument, ErrorLevel::Permanent).raw;
+        cmd_buff[1] = ResultCode(ErrorDescription::NotFound, ErrorModule::Config,
+                                 ErrorSummary::WrongArgument, ErrorLevel::Permanent)
+                          .raw;
        return;
    }
@@ -139,8 +145,11 @@ void GetCountryCodeID(Service::Interface* self) {
    }
    if (0 == country_code_id) {
-        LOG_ERROR(Service_CFG, "requested country code name=%c%c is invalid", country_code & 0xff, country_code >> 8);
+        LOG_ERROR(Service_CFG, "requested country code name=%c%c is invalid", country_code & 0xff,
-        cmd_buff[1] = ResultCode(ErrorDescription::NotFound, ErrorModule::Config, ErrorSummary::WrongArgument, ErrorLevel::Permanent).raw;
+                  country_code >> 8);
+        cmd_buff[1] = ResultCode(ErrorDescription::NotFound, ErrorModule::Config,
+                                 ErrorSummary::WrongArgument, ErrorLevel::Permanent)
+                          .raw;
        cmd_buff[2] = 0xFFFF;
        return;
    }
@@ -185,8 +194,8 @@ void GetSystemModel(Service::Interface* self) {
    u32 data;
    // TODO(Subv): Find out the correct error codes
-    cmd_buff[1] = Service::CFG::GetConfigInfoBlock(0x000F0004, 4, 0x8,
+    cmd_buff[1] =
-                                                   reinterpret_cast<u8*>(&data)).raw;
+        Service::CFG::GetConfigInfoBlock(0x000F0004, 4, 0x8, reinterpret_cast<u8*>(&data)).raw;
    cmd_buff[2] = data & 0xFF;
 }
@@ -195,8 +204,8 @@ void GetModelNintendo2DS(Service::Interface* self) {
    u32 data;
    // TODO(Subv): Find out the correct error codes
-    cmd_buff[1] = Service::CFG::GetConfigInfoBlock(0x000F0004, 4, 0x8,
+    cmd_buff[1] =
-                                                   reinterpret_cast<u8*>(&data)).raw;
+        Service::CFG::GetConfigInfoBlock(0x000F0004, 4, 0x8, reinterpret_cast<u8*>(&data)).raw;
    u8 model = data & 0xFF;
    if (model == Service::CFG::NINTENDO_2DS)
@@ -267,24 +276,29 @@ static ResultVal<void*> GetConfigInfoBlockPointer(u32 block_id, u32 size, u32 fl
    // Read the header
    SaveFileConfig* config = reinterpret_cast<SaveFileConfig*>(cfg_config_file_buffer.data());
-    auto itr = std::find_if(std::begin(config->block_entries), std::end(config->block_entries),
+    auto itr =
-        [&](const SaveConfigBlockEntry& entry) {
+        std::find_if(std::begin(config->block_entries), std::end(config->block_entries),
-            return entry.block_id == block_id;
+                     [&](const SaveConfigBlockEntry& entry) { return entry.block_id == block_id; });
-        });
    if (itr == std::end(config->block_entries)) {
-        LOG_ERROR(Service_CFG, "Config block 0x%X with flags %u and size %u was not found", block_id, flag, size);
+        LOG_ERROR(Service_CFG, "Config block 0x%X with flags %u and size %u was not found",
-        return ResultCode(ErrorDescription::NotFound, ErrorModule::Config, ErrorSummary::WrongArgument, ErrorLevel::Permanent);
+                  block_id, flag, size);
+        return ResultCode(ErrorDescription::NotFound, ErrorModule::Config,
+                          ErrorSummary::WrongArgument, ErrorLevel::Permanent);
    }
    if ((itr->flags & flag) == 0) {
-        LOG_ERROR(Service_CFG, "Invalid flag %u for config block 0x%X with size %u", flag, block_id, size);
+        LOG_ERROR(Service_CFG, "Invalid flag %u for config block 0x%X with size %u", flag, block_id,
-        return ResultCode(ErrorDescription::NotAuthorized, ErrorModule::Config, ErrorSummary::WrongArgument, ErrorLevel::Permanent);
+                  size);
+        return ResultCode(ErrorDescription::NotAuthorized, ErrorModule::Config,
+                          ErrorSummary::WrongArgument, ErrorLevel::Permanent);
    }
    if (itr->size != size) {
-        LOG_ERROR(Service_CFG, "Invalid size %u for config block 0x%X with flags %u", size, block_id, flag);
+        LOG_ERROR(Service_CFG, "Invalid size %u for config block 0x%X with flags %u", size,
-        return ResultCode(ErrorDescription::InvalidSize, ErrorModule::Config, ErrorSummary::WrongArgument, ErrorLevel::Permanent);
+                  block_id, flag);
+        return ResultCode(ErrorDescription::InvalidSize, ErrorModule::Config,
+                          ErrorSummary::WrongArgument, ErrorLevel::Permanent);
    }
    void* pointer;
@@ -318,7 +332,7 @@ ResultCode CreateConfigInfoBlk(u32 block_id, u16 size, u16 flags, const void* da
        return ResultCode(-1); // TODO(Subv): Find the right error code
    // Insert the block header with offset 0 for now
-    config->block_entries[config->total_entries] = { block_id, 0, size, flags };
+    config->block_entries[config->total_entries] = {block_id, 0, size, flags};
    if (size > 4) {
        u32 offset = config->data_entries_offset;
        // Perform a search to locate the next offset for the new data
@@ -326,8 +340,7 @@ ResultCode CreateConfigInfoBlk(u32 block_id, u16 size, u16 flags, const void* da
        for (int i = config->total_entries - 1; i >= 0; --i) {
            // Ignore the blocks that don't have a separate data offset
            if (config->block_entries[i].size > 4) {
-                offset = config->block_entries[i].offset_or_data +
+                offset = config->block_entries[i].offset_or_data + config->block_entries[i].size;
-                         config->block_entries[i].size;
                break;
            }
        }
@@ -336,8 +349,7 @@ ResultCode CreateConfigInfoBlk(u32 block_id, u16 size, u16 flags, const void* da
        // Write the data at the new offset
        memcpy(&cfg_config_file_buffer[offset], data, size);
-    }
+    } else {
-    else {
        // The offset_or_data field in the header contains the data itself if it's 4 bytes or less
        memcpy(&config->block_entries[config->total_entries].offset_or_data, data, size);
    }
@@ -384,28 +396,40 @@ ResultCode FormatConfig() {
    // 0x00030001 - Unknown
    res = CreateConfigInfoBlk(0x00030001, 0x8, 0xE, zero_buffer);
-    if (!res.IsSuccess()) return res;
+    if (!res.IsSuccess())
+        return res;
-    res = CreateConfigInfoBlk(StereoCameraSettingsBlockID, sizeof(STEREO_CAMERA_SETTINGS), 0xE, STEREO_CAMERA_SETTINGS.data());
+    res = CreateConfigInfoBlk(StereoCameraSettingsBlockID, sizeof(STEREO_CAMERA_SETTINGS), 0xE,
-    if (!res.IsSuccess()) return res;
+                              STEREO_CAMERA_SETTINGS.data());
+    if (!res.IsSuccess())
+        return res;
-    res = CreateConfigInfoBlk(SoundOutputModeBlockID, sizeof(SOUND_OUTPUT_MODE), 0xE, &SOUND_OUTPUT_MODE);
+    res = CreateConfigInfoBlk(SoundOutputModeBlockID, sizeof(SOUND_OUTPUT_MODE), 0xE,
-    if (!res.IsSuccess()) return res;
+                              &SOUND_OUTPUT_MODE);
+    if (!res.IsSuccess())
+        return res;
-    res = CreateConfigInfoBlk(ConsoleUniqueIDBlockID, sizeof(CONSOLE_UNIQUE_ID), 0xE, &CONSOLE_UNIQUE_ID);
+    res = CreateConfigInfoBlk(ConsoleUniqueIDBlockID, sizeof(CONSOLE_UNIQUE_ID), 0xE,
-    if (!res.IsSuccess()) return res;
+                              &CONSOLE_UNIQUE_ID);
+    if (!res.IsSuccess())
+        return res;
-    res = CreateConfigInfoBlk(UsernameBlockID, sizeof(CONSOLE_USERNAME_BLOCK), 0xE, &CONSOLE_USERNAME_BLOCK);
+    res = CreateConfigInfoBlk(UsernameBlockID, sizeof(CONSOLE_USERNAME_BLOCK), 0xE,
-    if (!res.IsSuccess()) return res;
+                              &CONSOLE_USERNAME_BLOCK);
+    if (!res.IsSuccess())
+        return res;
    res = CreateConfigInfoBlk(BirthdayBlockID, sizeof(PROFILE_BIRTHDAY), 0xE, &PROFILE_BIRTHDAY);
-    if (!res.IsSuccess()) return res;
+    if (!res.IsSuccess())
+        return res;
    res = CreateConfigInfoBlk(LanguageBlockID, sizeof(CONSOLE_LANGUAGE), 0xE, &CONSOLE_LANGUAGE);
-    if (!res.IsSuccess()) return res;
+    if (!res.IsSuccess())
+        return res;
    res = CreateConfigInfoBlk(CountryInfoBlockID, sizeof(COUNTRY_INFO), 0xE, &COUNTRY_INFO);
-    if (!res.IsSuccess()) return res;
+    if (!res.IsSuccess())
+        return res;
    u16_le country_name_buffer[16][0x40] = {};
    std::u16string region_name = Common::UTF8ToUTF16("Gensokyo");
@@ -413,34 +437,44 @@ ResultCode FormatConfig() {
        std::copy(region_name.cbegin(), region_name.cend(), country_name_buffer[i]);
    }
    // 0x000B0001 - Localized names for the profile Country
-    res = CreateConfigInfoBlk(CountryNameBlockID, sizeof(country_name_buffer), 0xE, country_name_buffer);
+    res = CreateConfigInfoBlk(CountryNameBlockID, sizeof(country_name_buffer), 0xE,
-    if (!res.IsSuccess()) return res;
+                              country_name_buffer);
+    if (!res.IsSuccess())
+        return res;
    // 0x000B0002 - Localized names for the profile State/Province
-    res = CreateConfigInfoBlk(StateNameBlockID, sizeof(country_name_buffer), 0xE, country_name_buffer);
+    res = CreateConfigInfoBlk(StateNameBlockID, sizeof(country_name_buffer), 0xE,
-    if (!res.IsSuccess()) return res;
+                              country_name_buffer);
+    if (!res.IsSuccess())
+        return res;
    // 0x000B0003 - Unknown, related to country/address (zip code?)
    res = CreateConfigInfoBlk(0x000B0003, 0x4, 0xE, zero_buffer);
-    if (!res.IsSuccess()) return res;
+    if (!res.IsSuccess())
+        return res;
    // 0x000C0000 - Unknown
    res = CreateConfigInfoBlk(0x000C0000, 0xC0, 0xE, zero_buffer);
-    if (!res.IsSuccess()) return res;
+    if (!res.IsSuccess())
+        return res;
    // 0x000C0001 - Unknown
    res = CreateConfigInfoBlk(0x000C0001, 0x14, 0xE, zero_buffer);
-    if (!res.IsSuccess()) return res;
+    if (!res.IsSuccess())
+        return res;
    // 0x000D0000 - Accepted EULA version
    res = CreateConfigInfoBlk(EULAVersionBlockID, 0x4, 0xE, zero_buffer);
-    if (!res.IsSuccess()) return res;
+    if (!res.IsSuccess())
+        return res;
    res = CreateConfigInfoBlk(ConsoleModelBlockID, sizeof(CONSOLE_MODEL), 0xC, &CONSOLE_MODEL);
-    if (!res.IsSuccess()) return res;
+    if (!res.IsSuccess())
+        return res;
    // 0x00170000 - Unknown
    res = CreateConfigInfoBlk(0x00170000, 0x4, 0xE, zero_buffer);
-    if (!res.IsSuccess()) return res;
+    if (!res.IsSuccess())
+        return res;
    // Save the buffer to the file
    res = UpdateConfigNANDSavegame();
@@ -452,15 +486,18 @@ ResultCode FormatConfig() {
 ResultCode LoadConfigNANDSaveFile() {
    // Open the SystemSaveData archive 0x00010017
    FileSys::Path archive_path(cfg_system_savedata_id);
-    auto archive_result = Service::FS::OpenArchive(Service::FS::ArchiveIdCode::SystemSaveData, archive_path);
+    auto archive_result =
+        Service::FS::OpenArchive(Service::FS::ArchiveIdCode::SystemSaveData, archive_path);
    // If the archive didn't exist, create the files inside
    if (archive_result.Code().description == ErrorDescription::FS_NotFormatted) {
        // Format the archive to create the directories
-        Service::FS::FormatArchive(Service::FS::ArchiveIdCode::SystemSaveData, FileSys::ArchiveFormatInfo(), archive_path);
+        Service::FS::FormatArchive(Service::FS::ArchiveIdCode::SystemSaveData,
+                                   FileSys::ArchiveFormatInfo(), archive_path);
        // Open it again to get a valid archive now that the folder exists
-        archive_result = Service::FS::OpenArchive(Service::FS::ArchiveIdCode::SystemSaveData, archive_path);
+        archive_result =
+            Service::FS::OpenArchive(Service::FS::ArchiveIdCode::SystemSaveData, archive_path);
    }
    ASSERT_MSG(archive_result.Succeeded(), "Could not open the CFG SystemSaveData archive!");
@@ -515,7 +552,7 @@ std::u16string GetUsername() {
 }
 void SetBirthday(u8 month, u8 day) {
-    BirthdayBlock block = { month, day };
+    BirthdayBlock block = {month, day};
    SetConfigInfoBlock(BirthdayBlockID, sizeof(block), 4, &block);
 }
diff --git a/src/core/hle/service/cfg/cfg.h b/src/core/hle/service/cfg/cfg.h
index 18f60f4ca..8cb231d72 100644
--- a/src/core/hle/service/cfg/cfg.h
+++ b/src/core/hle/service/cfg/cfg.h
@@ -40,16 +40,13 @@ enum SystemLanguage {
    LANGUAGE_TW = 11
 };
-enum SoundOutputMode {
+enum SoundOutputMode { SOUND_MONO = 0, SOUND_STEREO = 1, SOUND_SURROUND = 2 };
-    SOUND_MONO = 0,
-    SOUND_STEREO = 1,
-    SOUND_SURROUND = 2
-};
 /// Block header in the config savedata file
 struct SaveConfigBlockEntry {
    u32 block_id;       ///< The id of the current block
-    u32 offset_or_data; ///< This is the absolute offset to the block data if the size is greater than 4 bytes, otherwise it contains the data itself
+    u32 offset_or_data; ///< This is the absolute offset to the block data if the size is greater
+                        /// than 4 bytes, otherwise it contains the data itself
    u16 size;           ///< The size of the block
    u16 flags;          ///< The flags of the block, possibly used for access control
 };
@@ -244,7 +241,8 @@ ResultCode GetConfigInfoBlock(u32 block_id, u32 size, u32 flag, void* output);
 ResultCode SetConfigInfoBlock(u32 block_id, u32 size, u32 flag, const void* input);
 /**
- * Creates a block with the specified id and writes the input data to the cfg savegame buffer in memory.
+ * Creates a block with the specified id and writes the input data to the cfg savegame buffer in
+ * memory.
 * The config savegame file in the filesystem is not updated.
 * @param block_id The id of the block we want to create
 * @param size The size of the block we want to create
diff --git a/src/core/hle/service/cfg/cfg_i.cpp b/src/core/hle/service/cfg/cfg_i.cpp
index 8b0db785f..2ff52c8b8 100644
--- a/src/core/hle/service/cfg/cfg_i.cpp
+++ b/src/core/hle/service/cfg/cfg_i.cpp
@@ -10,49 +10,49 @@ namespace CFG {
 const Interface::FunctionInfo FunctionTable[] = {
    // cfg common
-    {0x00010082, GetConfigInfoBlk2,                    "GetConfigInfoBlk2"},
+    {0x00010082, GetConfigInfoBlk2, "GetConfigInfoBlk2"},
-    {0x00020000, SecureInfoGetRegion,                  "SecureInfoGetRegion"},
+    {0x00020000, SecureInfoGetRegion, "SecureInfoGetRegion"},
-    {0x00030040, GenHashConsoleUnique,                 "GenHashConsoleUnique"},
+    {0x00030040, GenHashConsoleUnique, "GenHashConsoleUnique"},
-    {0x00040000, GetRegionCanadaUSA,                   "GetRegionCanadaUSA"},
+    {0x00040000, GetRegionCanadaUSA, "GetRegionCanadaUSA"},
-    {0x00050000, GetSystemModel,                       "GetSystemModel"},
+    {0x00050000, GetSystemModel, "GetSystemModel"},
-    {0x00060000, GetModelNintendo2DS,                  "GetModelNintendo2DS"},
+    {0x00060000, GetModelNintendo2DS, "GetModelNintendo2DS"},
-    {0x00070040, nullptr,                              "WriteToFirstByteCfgSavegame"},
+    {0x00070040, nullptr, "WriteToFirstByteCfgSavegame"},
-    {0x00080080, nullptr,                              "GoThroughTable"},
+    {0x00080080, nullptr, "GoThroughTable"},
-    {0x00090040, GetCountryCodeString,                 "GetCountryCodeString"},
+    {0x00090040, GetCountryCodeString, "GetCountryCodeString"},
-    {0x000A0040, GetCountryCodeID,                     "GetCountryCodeID"},
+    {0x000A0040, GetCountryCodeID, "GetCountryCodeID"},
    // cfg:i
-    {0x04010082, GetConfigInfoBlk8,                    "GetConfigInfoBlk8"},
+    {0x04010082, GetConfigInfoBlk8, "GetConfigInfoBlk8"},
-    {0x04020082, SetConfigInfoBlk4,                    "SetConfigInfoBlk4"},
+    {0x04020082, SetConfigInfoBlk4, "SetConfigInfoBlk4"},
-    {0x04030000, UpdateConfigNANDSavegame,             "UpdateConfigNANDSavegame"},
+    {0x04030000, UpdateConfigNANDSavegame, "UpdateConfigNANDSavegame"},
-    {0x04040042, nullptr,                              "GetLocalFriendCodeSeedData"},
+    {0x04040042, nullptr, "GetLocalFriendCodeSeedData"},
-    {0x04050000, nullptr,                              "GetLocalFriendCodeSeed"},
+    {0x04050000, nullptr, "GetLocalFriendCodeSeed"},
-    {0x04060000, SecureInfoGetRegion,                  "SecureInfoGetRegion"},
+    {0x04060000, SecureInfoGetRegion, "SecureInfoGetRegion"},
-    {0x04070000, nullptr,                              "SecureInfoGetByte101"},
+    {0x04070000, nullptr, "SecureInfoGetByte101"},
-    {0x04080042, nullptr,                              "SecureInfoGetSerialNo"},
+    {0x04080042, nullptr, "SecureInfoGetSerialNo"},
-    {0x04090000, nullptr,                              "UpdateConfigBlk00040003"},
+    {0x04090000, nullptr, "UpdateConfigBlk00040003"},
-    {0x08010082, GetConfigInfoBlk8,                    "GetConfigInfoBlk8"},
+    {0x08010082, GetConfigInfoBlk8, "GetConfigInfoBlk8"},
-    {0x08020082, SetConfigInfoBlk4,                    "SetConfigInfoBlk4"},
+    {0x08020082, SetConfigInfoBlk4, "SetConfigInfoBlk4"},
-    {0x08030000, UpdateConfigNANDSavegame,             "UpdateConfigNANDSavegame"},
+    {0x08030000, UpdateConfigNANDSavegame, "UpdateConfigNANDSavegame"},
-    {0x080400C2, nullptr,                              "CreateConfigInfoBlk"},
+    {0x080400C2, nullptr, "CreateConfigInfoBlk"},
-    {0x08050000, nullptr,                              "DeleteConfigNANDSavefile"},
+    {0x08050000, nullptr, "DeleteConfigNANDSavefile"},
-    {0x08060000, FormatConfig,                         "FormatConfig"},
+    {0x08060000, FormatConfig, "FormatConfig"},
-    {0x08080000, nullptr,                              "UpdateConfigBlk1"},
+    {0x08080000, nullptr, "UpdateConfigBlk1"},
-    {0x08090000, nullptr,                              "UpdateConfigBlk2"},
+    {0x08090000, nullptr, "UpdateConfigBlk2"},
-    {0x080A0000, nullptr,                              "UpdateConfigBlk3"},
+    {0x080A0000, nullptr, "UpdateConfigBlk3"},
-    {0x080B0082, nullptr,                              "SetGetLocalFriendCodeSeedData"},
+    {0x080B0082, nullptr, "SetGetLocalFriendCodeSeedData"},
-    {0x080C0042, nullptr,                              "SetLocalFriendCodeSeedSignature"},
+    {0x080C0042, nullptr, "SetLocalFriendCodeSeedSignature"},
-    {0x080D0000, nullptr,                              "DeleteCreateNANDLocalFriendCodeSeed"},
+    {0x080D0000, nullptr, "DeleteCreateNANDLocalFriendCodeSeed"},
-    {0x080E0000, nullptr,                              "VerifySigLocalFriendCodeSeed"},
+    {0x080E0000, nullptr, "VerifySigLocalFriendCodeSeed"},
-    {0x080F0042, nullptr,                              "GetLocalFriendCodeSeedData"},
+    {0x080F0042, nullptr, "GetLocalFriendCodeSeedData"},
-    {0x08100000, nullptr,                              "GetLocalFriendCodeSeed"},
+    {0x08100000, nullptr, "GetLocalFriendCodeSeed"},
-    {0x08110084, nullptr,                              "SetSecureInfo"},
+    {0x08110084, nullptr, "SetSecureInfo"},
-    {0x08120000, nullptr,                              "DeleteCreateNANDSecureInfo"},
+    {0x08120000, nullptr, "DeleteCreateNANDSecureInfo"},
-    {0x08130000, nullptr,                              "VerifySigSecureInfo"},
+    {0x08130000, nullptr, "VerifySigSecureInfo"},
-    {0x08140042, nullptr,                              "SecureInfoGetData"},
+    {0x08140042, nullptr, "SecureInfoGetData"},
-    {0x08150042, nullptr,                              "SecureInfoGetSignature"},
+    {0x08150042, nullptr, "SecureInfoGetSignature"},
-    {0x08160000, SecureInfoGetRegion,                  "SecureInfoGetRegion"},
+    {0x08160000, SecureInfoGetRegion, "SecureInfoGetRegion"},
-    {0x08170000, nullptr,                              "SecureInfoGetByte101"},
+    {0x08170000, nullptr, "SecureInfoGetByte101"},
-    {0x08180042, nullptr,                              "SecureInfoGetSerialNo"},
+    {0x08180042, nullptr, "SecureInfoGetSerialNo"},
 };
 CFG_I_Interface::CFG_I_Interface() {
diff --git a/src/core/hle/service/cfg/cfg_s.cpp b/src/core/hle/service/cfg/cfg_s.cpp
index 12b458783..eed26dec7 100644
--- a/src/core/hle/service/cfg/cfg_s.cpp
+++ b/src/core/hle/service/cfg/cfg_s.cpp
@@ -10,26 +10,26 @@ namespace CFG {
 const Interface::FunctionInfo FunctionTable[] = {
    // cfg common
-    {0x00010082, GetConfigInfoBlk2,                    "GetConfigInfoBlk2"},
+    {0x00010082, GetConfigInfoBlk2, "GetConfigInfoBlk2"},
-    {0x00020000, SecureInfoGetRegion,                  "SecureInfoGetRegion"},
+    {0x00020000, SecureInfoGetRegion, "SecureInfoGetRegion"},
-    {0x00030040, GenHashConsoleUnique,                 "GenHashConsoleUnique"},
+    {0x00030040, GenHashConsoleUnique, "GenHashConsoleUnique"},
-    {0x00040000, GetRegionCanadaUSA,                   "GetRegionCanadaUSA"},
+    {0x00040000, GetRegionCanadaUSA, "GetRegionCanadaUSA"},
-    {0x00050000, GetSystemModel,                       "GetSystemModel"},
+    {0x00050000, GetSystemModel, "GetSystemModel"},
-    {0x00060000, GetModelNintendo2DS,                  "GetModelNintendo2DS"},
+    {0x00060000, GetModelNintendo2DS, "GetModelNintendo2DS"},
-    {0x00070040, nullptr,                              "WriteToFirstByteCfgSavegame"},
+    {0x00070040, nullptr, "WriteToFirstByteCfgSavegame"},
-    {0x00080080, nullptr,                              "GoThroughTable"},
+    {0x00080080, nullptr, "GoThroughTable"},
-    {0x00090040, GetCountryCodeString,                 "GetCountryCodeString"},
+    {0x00090040, GetCountryCodeString, "GetCountryCodeString"},
-    {0x000A0040, GetCountryCodeID,                     "GetCountryCodeID"},
+    {0x000A0040, GetCountryCodeID, "GetCountryCodeID"},
    // cfg:s
-    {0x04010082, GetConfigInfoBlk8,                    "GetConfigInfoBlk8"},
+    {0x04010082, GetConfigInfoBlk8, "GetConfigInfoBlk8"},
-    {0x04020082, SetConfigInfoBlk4,                    "SetConfigInfoBlk4"},
+    {0x04020082, SetConfigInfoBlk4, "SetConfigInfoBlk4"},
-    {0x04030000, UpdateConfigNANDSavegame,             "UpdateConfigNANDSavegame"},
+    {0x04030000, UpdateConfigNANDSavegame, "UpdateConfigNANDSavegame"},
-    {0x04040042, nullptr,                              "GetLocalFriendCodeSeedData"},
+    {0x04040042, nullptr, "GetLocalFriendCodeSeedData"},
-    {0x04050000, nullptr,                              "GetLocalFriendCodeSeed"},
+    {0x04050000, nullptr, "GetLocalFriendCodeSeed"},
-    {0x04060000, nullptr,                              "SecureInfoGetRegion"},
+    {0x04060000, nullptr, "SecureInfoGetRegion"},
-    {0x04070000, nullptr,                              "SecureInfoGetByte101"},
+    {0x04070000, nullptr, "SecureInfoGetByte101"},
-    {0x04080042, nullptr,                              "SecureInfoGetSerialNo"},
+    {0x04080042, nullptr, "SecureInfoGetSerialNo"},
-    {0x04090000, nullptr,                              "UpdateConfigBlk00040003"},
+    {0x04090000, nullptr, "UpdateConfigBlk00040003"},
 };
 CFG_S_Interface::CFG_S_Interface() {
diff --git a/src/core/hle/service/cfg/cfg_u.cpp b/src/core/hle/service/cfg/cfg_u.cpp
index 606f7b2eb..f28217134 100644
--- a/src/core/hle/service/cfg/cfg_u.cpp
+++ b/src/core/hle/service/cfg/cfg_u.cpp
@@ -10,16 +10,16 @@ namespace CFG {
 const Interface::FunctionInfo FunctionTable[] = {
    // cfg common
-    {0x00010082, GetConfigInfoBlk2,     "GetConfigInfoBlk2"},
+    {0x00010082, GetConfigInfoBlk2, "GetConfigInfoBlk2"},
-    {0x00020000, SecureInfoGetRegion,   "SecureInfoGetRegion"},
+    {0x00020000, SecureInfoGetRegion, "SecureInfoGetRegion"},
-    {0x00030040, GenHashConsoleUnique,  "GenHashConsoleUnique"},
+    {0x00030040, GenHashConsoleUnique, "GenHashConsoleUnique"},
-    {0x00040000, GetRegionCanadaUSA,    "GetRegionCanadaUSA"},
+    {0x00040000, GetRegionCanadaUSA, "GetRegionCanadaUSA"},
-    {0x00050000, GetSystemModel,        "GetSystemModel"},
+    {0x00050000, GetSystemModel, "GetSystemModel"},
-    {0x00060000, GetModelNintendo2DS,   "GetModelNintendo2DS"},
+    {0x00060000, GetModelNintendo2DS, "GetModelNintendo2DS"},
-    {0x00070040, nullptr,               "WriteToFirstByteCfgSavegame"},
+    {0x00070040, nullptr, "WriteToFirstByteCfgSavegame"},
-    {0x00080080, nullptr,               "GoThroughTable"},
+    {0x00080080, nullptr, "GoThroughTable"},
-    {0x00090040, GetCountryCodeString,  "GetCountryCodeString"},
+    {0x00090040, GetCountryCodeString, "GetCountryCodeString"},
-    {0x000A0040, GetCountryCodeID,      "GetCountryCodeID"},
+    {0x000A0040, GetCountryCodeID, "GetCountryCodeID"},
 };
 CFG_U_Interface::CFG_U_Interface() {
diff --git a/src/core/hle/service/csnd_snd.cpp b/src/core/hle/service/csnd_snd.cpp
index 913c8dc09..e777ea9d6 100644
--- a/src/core/hle/service/csnd_snd.cpp
+++ b/src/core/hle/service/csnd_snd.cpp
@@ -2,12 +2,12 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
+#include "core/hle/service/csnd_snd.h"
 #include <cstring>
 #include "common/alignment.h"
 #include "core/hle/hle.h"
 #include "core/hle/kernel/mutex.h"
 #include "core/hle/kernel/shared_memory.h"
-#include "core/hle/service/csnd_snd.h"
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Namespace CSND_SND
@@ -15,18 +15,18 @@
 namespace CSND_SND {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010140, Initialize,            "Initialize"},
+    {0x00010140, Initialize, "Initialize"},
-    {0x00020000, Shutdown,              "Shutdown"},
+    {0x00020000, Shutdown, "Shutdown"},
-    {0x00030040, ExecuteType0Commands,  "ExecuteType0Commands"},
+    {0x00030040, ExecuteType0Commands, "ExecuteType0Commands"},
-    {0x00040080, nullptr,               "ExecuteType1Commands"},
+    {0x00040080, nullptr, "ExecuteType1Commands"},
-    {0x00050000, AcquireSoundChannels,  "AcquireSoundChannels"},
+    {0x00050000, AcquireSoundChannels, "AcquireSoundChannels"},
-    {0x00060000, nullptr,               "ReleaseSoundChannels"},
+    {0x00060000, nullptr, "ReleaseSoundChannels"},
-    {0x00070000, nullptr,               "AcquireCaptureDevice"},
+    {0x00070000, nullptr, "AcquireCaptureDevice"},
-    {0x00080040, nullptr,               "ReleaseCaptureDevice"},
+    {0x00080040, nullptr, "ReleaseCaptureDevice"},
-    {0x00090082, nullptr,               "FlushDataCache"},
+    {0x00090082, nullptr, "FlushDataCache"},
-    {0x000A0082, nullptr,               "StoreDataCache"},
+    {0x000A0082, nullptr, "StoreDataCache"},
-    {0x000B0082, nullptr,               "InvalidateDataCache"},
+    {0x000B0082, nullptr, "InvalidateDataCache"},
-    {0x000C0000, nullptr,               "Reset"},
+    {0x000C0000, nullptr, "Reset"},
 };
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -44,9 +44,9 @@ void Initialize(Service::Interface* self) {
    u32 size = Common::AlignUp(cmd_buff[1], Memory::PAGE_SIZE);
    using Kernel::MemoryPermission;
-    shared_memory = Kernel::SharedMemory::Create(nullptr, size,
+    shared_memory = Kernel::SharedMemory::Create(nullptr, size, MemoryPermission::ReadWrite,
-                                                 MemoryPermission::ReadWrite, MemoryPermission::ReadWrite,
+                                                 MemoryPermission::ReadWrite, 0,
-                                                 0, Kernel::MemoryRegion::BASE, "CSND:SharedMemory");
+                                                 Kernel::MemoryRegion::BASE, "CSND:SharedMemory");
    mutex = Kernel::Mutex::Create(false);
@@ -58,7 +58,7 @@ void Initialize(Service::Interface* self) {
 void ExecuteType0Commands(Service::Interface* self) {
    u32* const cmd_buff = Kernel::GetCommandBuffer();
-    u8*  const ptr = shared_memory->GetPointer(cmd_buff[1]);
+    u8* const ptr = shared_memory->GetPointer(cmd_buff[1]);
    if (shared_memory != nullptr && ptr != nullptr) {
        Type0Command command;
diff --git a/src/core/hle/service/csnd_snd.h b/src/core/hle/service/csnd_snd.h
index e861f3327..a146d116b 100644
--- a/src/core/hle/service/csnd_snd.h
+++ b/src/core/hle/service/csnd_snd.h
@@ -25,7 +25,7 @@ struct Type0Command {
    u32 command_id;
    u32 finished;
    u32 flags;
-    u8  parameters[20];
+    u8 parameters[20];
 };
 void Initialize(Service::Interface* self);
diff --git a/src/core/hle/service/dlp/dlp.cpp b/src/core/hle/service/dlp/dlp.cpp
index 7c8db794b..fd124e819 100644
--- a/src/core/hle/service/dlp/dlp.cpp
+++ b/src/core/hle/service/dlp/dlp.cpp
@@ -2,11 +2,11 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
-#include "core/hle/service/service.h"
 #include "core/hle/service/dlp/dlp.h"
 #include "core/hle/service/dlp/dlp_clnt.h"
 #include "core/hle/service/dlp/dlp_fkcl.h"
 #include "core/hle/service/dlp/dlp_srvr.h"
+#include "core/hle/service/service.h"
 namespace Service {
 namespace DLP {
diff --git a/src/core/hle/service/dlp/dlp_clnt.cpp b/src/core/hle/service/dlp/dlp_clnt.cpp
index 0b31d47df..56f934b3f 100644
--- a/src/core/hle/service/dlp/dlp_clnt.cpp
+++ b/src/core/hle/service/dlp/dlp_clnt.cpp
@@ -8,8 +8,7 @@ namespace Service {
 namespace DLP {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x000100C3, nullptr, "Initialize"},
+    {0x000100C3, nullptr, "Initialize"}, {0x00110000, nullptr, "GetWirelessRebootPassphrase"},
-    {0x00110000, nullptr, "GetWirelessRebootPassphrase"},
 };
 DLP_CLNT_Interface::DLP_CLNT_Interface() {
diff --git a/src/core/hle/service/dlp/dlp_fkcl.cpp b/src/core/hle/service/dlp/dlp_fkcl.cpp
index a845260e5..29b9d52e0 100644
--- a/src/core/hle/service/dlp/dlp_fkcl.cpp
+++ b/src/core/hle/service/dlp/dlp_fkcl.cpp
@@ -8,8 +8,7 @@ namespace Service {
 namespace DLP {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010083, nullptr, "Initialize"},
+    {0x00010083, nullptr, "Initialize"}, {0x000F0000, nullptr, "GetWirelessRebootPassphrase"},
-    {0x000F0000, nullptr, "GetWirelessRebootPassphrase"},
 };
 DLP_FKCL_Interface::DLP_FKCL_Interface() {
diff --git a/src/core/hle/service/dlp/dlp_srvr.cpp b/src/core/hle/service/dlp/dlp_srvr.cpp
index da9b30f56..113f6a79f 100644
--- a/src/core/hle/service/dlp/dlp_srvr.cpp
+++ b/src/core/hle/service/dlp/dlp_srvr.cpp
@@ -2,10 +2,10 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
+#include "core/hle/service/dlp/dlp_srvr.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "core/hle/result.h"
-#include "core/hle/service/dlp/dlp_srvr.h"
 namespace Service {
 namespace DLP {
@@ -20,10 +20,10 @@ static void unk_0x000E0040(Interface* self) {
 }
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010183, nullptr,           "Initialize"},
+    {0x00010183, nullptr, "Initialize"},
-    {0x00020000, nullptr,           "Finalize"},
+    {0x00020000, nullptr, "Finalize"},
-    {0x000800C0, nullptr,           "SendWirelessRebootPassphrase"},
+    {0x000800C0, nullptr, "SendWirelessRebootPassphrase"},
-    {0x000E0040, unk_0x000E0040,    "unk_0x000E0040"},
+    {0x000E0040, unk_0x000E0040, "unk_0x000E0040"},
 };
 DLP_SRVR_Interface::DLP_SRVR_Interface() {
diff --git a/src/core/hle/service/dsp_dsp.cpp b/src/core/hle/service/dsp_dsp.cpp
index c8aadd9db..70e92c30c 100644
--- a/src/core/hle/service/dsp_dsp.cpp
+++ b/src/core/hle/service/dsp_dsp.cpp
@@ -23,9 +23,7 @@ namespace DSP_DSP {
 static Kernel::SharedPtr<Kernel::Event> semaphore_event;
 /// There are three types of interrupts
-enum class InterruptType {
+enum class InterruptType { Zero, One, Pipe };
-    Zero, One, Pipe
-};
 constexpr size_t NUM_INTERRUPT_TYPE = 3;
 class InterruptEvents final {
@@ -57,9 +55,8 @@ public:
        // Actual service implementation only has 6 'slots' for interrupts.
        constexpr size_t max_number_of_interrupt_events = 6;
-        size_t number = std::count_if(pipe.begin(), pipe.end(), [](const auto& evt) {
+        size_t number =
-            return evt != nullptr;
+            std::count_if(pipe.begin(), pipe.end(), [](const auto& evt) { return evt != nullptr; });
-        });
        if (zero != nullptr)
            number++;
@@ -105,7 +102,8 @@ static void ConvertProcessAddressFromDspDram(Service::Interface* self) {
    cmd_buff[0] = IPC::MakeHeader(0xC, 2, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
-    // TODO(merry): There is a per-region offset missing in this calculation (that seems to be always zero).
+    // TODO(merry): There is a per-region offset missing in this calculation (that seems to be
+    // always zero).
    cmd_buff[2] = (addr << 1) + (Memory::DSP_RAM_VADDR + 0x40000);
    LOG_DEBUG(Service_DSP, "addr=0x%08X", addr);
@@ -126,15 +124,15 @@ static void ConvertProcessAddressFromDspDram(Service::Interface* self) {
 static void LoadComponent(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
-    u32 size       = cmd_buff[1];
+    u32 size = cmd_buff[1];
-    u32 prog_mask  = cmd_buff[2];
+    u32 prog_mask = cmd_buff[2];
-    u32 data_mask  = cmd_buff[3];
+    u32 data_mask = cmd_buff[3];
-    u32 desc       = cmd_buff[4];
+    u32 desc = cmd_buff[4];
-    u32 buffer     = cmd_buff[5];
+    u32 buffer = cmd_buff[5];
    cmd_buff[0] = IPC::MakeHeader(0x11, 2, 2);
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
-    cmd_buff[2] = 1; // Pretend that we actually loaded the DSP firmware
+    cmd_buff[2] = 1;                  // Pretend that we actually loaded the DSP firmware
    cmd_buff[3] = desc;
    cmd_buff[4] = buffer;
@@ -145,12 +143,15 @@ static void LoadComponent(Service::Interface* self) {
    std::vector<u8> component_data(size);
    Memory::ReadBlock(buffer, component_data.data(), component_data.size());
-    LOG_INFO(Service_DSP, "Firmware hash: %#" PRIx64, Common::ComputeHash64(component_data.data(), component_data.size()));
+    LOG_INFO(Service_DSP, "Firmware hash: %#" PRIx64,
+             Common::ComputeHash64(component_data.data(), component_data.size()));
    // Some versions of the firmware have the location of DSP structures listed here.
    ASSERT(size > 0x37C);
-    LOG_INFO(Service_DSP, "Structures hash: %#" PRIx64, Common::ComputeHash64(component_data.data() + 0x340, 60));
+    LOG_INFO(Service_DSP, "Structures hash: %#" PRIx64,
+             Common::ComputeHash64(component_data.data() + 0x340, 60));
-    LOG_WARNING(Service_DSP, "(STUBBED) called size=0x%X, prog_mask=0x%08X, data_mask=0x%08X, buffer=0x%08X",
+    LOG_WARNING(Service_DSP,
+                "(STUBBED) called size=0x%X, prog_mask=0x%08X, data_mask=0x%08X, buffer=0x%08X",
                size, prog_mask, data_mask, buffer);
 }
@@ -187,13 +188,14 @@ static void GetSemaphoreEventHandle(Service::Interface* self) {
 static void FlushDataCache(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    u32 address = cmd_buff[1];
-    u32 size    = cmd_buff[2];
+    u32 size = cmd_buff[2];
    u32 process = cmd_buff[4];
    cmd_buff[0] = IPC::MakeHeader(0x13, 1, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
-    LOG_TRACE(Service_DSP, "called address=0x%08X, size=0x%X, process=0x%08X", address, size, process);
+    LOG_TRACE(Service_DSP, "called address=0x%08X, size=0x%X, process=0x%08X", address, size,
+              process);
 }
 /**
@@ -224,23 +226,29 @@ static void RegisterInterruptEvents(Service::Interface* self) {
        auto evt = Kernel::g_handle_table.Get<Kernel::Event>(cmd_buff[4]);
        if (!evt) {
-            LOG_INFO(Service_DSP, "Invalid event handle! type=%u, pipe=%u, event_handle=0x%08X", type_index, pipe_index, event_handle);
+            LOG_INFO(Service_DSP, "Invalid event handle! type=%u, pipe=%u, event_handle=0x%08X",
+                     type_index, pipe_index, event_handle);
            ASSERT(false); // TODO: This should really be handled at an IPC translation layer.
        }
        if (interrupt_events.HasTooManyEventsRegistered()) {
-            LOG_INFO(Service_DSP, "Ran out of space to register interrupts (Attempted to register type=%u, pipe=%u, event_handle=0x%08X)",
+            LOG_INFO(Service_DSP, "Ran out of space to register interrupts (Attempted to register "
+                                  "type=%u, pipe=%u, event_handle=0x%08X)",
                     type_index, pipe_index, event_handle);
-            cmd_buff[1] = ResultCode(ErrorDescription::InvalidResultValue, ErrorModule::DSP, ErrorSummary::OutOfResource, ErrorLevel::Status).raw;
+            cmd_buff[1] = ResultCode(ErrorDescription::InvalidResultValue, ErrorModule::DSP,
+                                     ErrorSummary::OutOfResource, ErrorLevel::Status)
+                              .raw;
            return;
        }
        interrupt_events.Get(type, pipe) = evt;
-        LOG_INFO(Service_DSP, "Registered type=%u, pipe=%u, event_handle=0x%08X", type_index, pipe_index, event_handle);
+        LOG_INFO(Service_DSP, "Registered type=%u, pipe=%u, event_handle=0x%08X", type_index,
+                 pipe_index, event_handle);
        cmd_buff[1] = RESULT_SUCCESS.raw;
    } else {
        interrupt_events.Get(type, pipe) = nullptr;
-        LOG_INFO(Service_DSP, "Unregistered interrupt=%u, channel=%u, event_handle=0x%08X", type_index, pipe_index, event_handle);
+        LOG_INFO(Service_DSP, "Unregistered interrupt=%u, channel=%u, event_handle=0x%08X",
+                 type_index, pipe_index, event_handle);
        cmd_buff[1] = RESULT_SUCCESS.raw;
    }
 }
@@ -282,13 +290,18 @@ static void WriteProcessPipe(Service::Interface* self) {
    DSP::HLE::DspPipe pipe = static_cast<DSP::HLE::DspPipe>(pipe_index);
    if (IPC::StaticBufferDesc(size, 1) != cmd_buff[3]) {
-        LOG_ERROR(Service_DSP, "IPC static buffer descriptor failed validation (0x%X). pipe=%u, size=0x%X, buffer=0x%08X", cmd_buff[3], pipe_index, size, buffer);
+        LOG_ERROR(Service_DSP, "IPC static buffer descriptor failed validation (0x%X). pipe=%u, "
+                               "size=0x%X, buffer=0x%08X",
+                  cmd_buff[3], pipe_index, size, buffer);
        cmd_buff[0] = IPC::MakeHeader(0, 1, 0);
-        cmd_buff[1] = ResultCode(ErrorDescription::OS_InvalidBufferDescriptor, ErrorModule::OS, ErrorSummary::WrongArgument, ErrorLevel::Permanent).raw;
+        cmd_buff[1] = ResultCode(ErrorDescription::OS_InvalidBufferDescriptor, ErrorModule::OS,
+                                 ErrorSummary::WrongArgument, ErrorLevel::Permanent)
+                          .raw;
        return;
    }
-    ASSERT_MSG(Memory::IsValidVirtualAddress(buffer), "Invalid Buffer: pipe=%u, size=0x%X, buffer=0x%08X", pipe, size, buffer);
+    ASSERT_MSG(Memory::IsValidVirtualAddress(buffer),
+               "Invalid Buffer: pipe=%u, size=0x%X, buffer=0x%08X", pipe, size, buffer);
    std::vector<u8> message(size);
    for (u32 i = 0; i < size; i++) {
@@ -327,7 +340,9 @@ static void ReadPipeIfPossible(Service::Interface* self) {
    DSP::HLE::DspPipe pipe = static_cast<DSP::HLE::DspPipe>(pipe_index);
-    ASSERT_MSG(Memory::IsValidVirtualAddress(addr), "Invalid addr: pipe=0x%08X, unknown=0x%08X, size=0x%X, buffer=0x%08X", pipe, unknown, size, addr);
+    ASSERT_MSG(Memory::IsValidVirtualAddress(addr),
+               "Invalid addr: pipe=0x%08X, unknown=0x%08X, size=0x%X, buffer=0x%08X", pipe, unknown,
+               size, addr);
    cmd_buff[0] = IPC::MakeHeader(0x10, 1, 2);
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
@@ -343,7 +358,9 @@ static void ReadPipeIfPossible(Service::Interface* self) {
    cmd_buff[3] = IPC::StaticBufferDesc(size, 0);
    cmd_buff[4] = addr;
-    LOG_DEBUG(Service_DSP, "pipe=%u, unknown=0x%08X, size=0x%X, buffer=0x%08X, return cmd_buff[2]=0x%08X", pipe_index, unknown, size, addr, cmd_buff[2]);
+    LOG_DEBUG(Service_DSP,
+              "pipe=%u, unknown=0x%08X, size=0x%X, buffer=0x%08X, return cmd_buff[2]=0x%08X",
+              pipe_index, unknown, size, addr, cmd_buff[2]);
 }
 /**
@@ -367,7 +384,9 @@ static void ReadPipe(Service::Interface* self) {
    DSP::HLE::DspPipe pipe = static_cast<DSP::HLE::DspPipe>(pipe_index);
-    ASSERT_MSG(Memory::IsValidVirtualAddress(addr), "Invalid addr: pipe=0x%08X, unknown=0x%08X, size=0x%X, buffer=0x%08X", pipe, unknown, size, addr);
+    ASSERT_MSG(Memory::IsValidVirtualAddress(addr),
+               "Invalid addr: pipe=0x%08X, unknown=0x%08X, size=0x%X, buffer=0x%08X", pipe, unknown,
+               size, addr);
    if (DSP::HLE::GetPipeReadableSize(pipe) >= size) {
        std::vector<u8> response = DSP::HLE::PipeRead(pipe, size);
@@ -384,7 +403,9 @@ static void ReadPipe(Service::Interface* self) {
        UNREACHABLE();
    }
-    LOG_DEBUG(Service_DSP, "pipe=%u, unknown=0x%08X, size=0x%X, buffer=0x%08X, return cmd_buff[2]=0x%08X", pipe_index, unknown, size, addr, cmd_buff[2]);
+    LOG_DEBUG(Service_DSP,
+              "pipe=%u, unknown=0x%08X, size=0x%X, buffer=0x%08X, return cmd_buff[2]=0x%08X",
+              pipe_index, unknown, size, addr, cmd_buff[2]);
 }
 /**
@@ -408,7 +429,8 @@ static void GetPipeReadableSize(Service::Interface* self) {
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
    cmd_buff[2] = static_cast<u32>(DSP::HLE::GetPipeReadableSize(pipe));
-    LOG_DEBUG(Service_DSP, "pipe=%u, unknown=0x%08X, return cmd_buff[2]=0x%08X", pipe_index, unknown, cmd_buff[2]);
+    LOG_DEBUG(Service_DSP, "pipe=%u, unknown=0x%08X, return cmd_buff[2]=0x%08X", pipe_index,
+              unknown, cmd_buff[2]);
 }
 /**
@@ -443,7 +465,7 @@ static void GetHeadphoneStatus(Service::Interface* self) {
    cmd_buff[0] = IPC::MakeHeader(0x1F, 2, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
-    cmd_buff[2] = 0; // Not using headphones
+    cmd_buff[2] = 0;                  // Not using headphones
    LOG_DEBUG(Service_DSP, "called");
 }
@@ -466,7 +488,8 @@ static void RecvData(Service::Interface* self) {
    ASSERT_MSG(register_number == 0, "Unknown register_number %u", register_number);
-    // Application reads this after requesting DSP shutdown, to verify the DSP has indeed shutdown or slept.
+    // Application reads this after requesting DSP shutdown, to verify the DSP has indeed shutdown
+    // or slept.
    cmd_buff[0] = IPC::MakeHeader(0x1, 2, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw;
@@ -512,39 +535,39 @@ static void RecvDataIsReady(Service::Interface* self) {
 }
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010040, RecvData,                         "RecvData"},
+    {0x00010040, RecvData, "RecvData"},
-    {0x00020040, RecvDataIsReady,                  "RecvDataIsReady"},
+    {0x00020040, RecvDataIsReady, "RecvDataIsReady"},
-    {0x00030080, nullptr,                          "SendData"},
+    {0x00030080, nullptr, "SendData"},
-    {0x00040040, nullptr,                          "SendDataIsEmpty"},
+    {0x00040040, nullptr, "SendDataIsEmpty"},
-    {0x000500C2, nullptr,                          "SendFifoEx"},
+    {0x000500C2, nullptr, "SendFifoEx"},
-    {0x000600C0, nullptr,                          "RecvFifoEx"},
+    {0x000600C0, nullptr, "RecvFifoEx"},
-    {0x00070040, SetSemaphore,                     "SetSemaphore"},
+    {0x00070040, SetSemaphore, "SetSemaphore"},
-    {0x00080000, nullptr,                          "GetSemaphore"},
+    {0x00080000, nullptr, "GetSemaphore"},
-    {0x00090040, nullptr,                          "ClearSemaphore"},
+    {0x00090040, nullptr, "ClearSemaphore"},
-    {0x000A0040, nullptr,                          "MaskSemaphore"},
+    {0x000A0040, nullptr, "MaskSemaphore"},
-    {0x000B0000, nullptr,                          "CheckSemaphoreRequest"},
+    {0x000B0000, nullptr, "CheckSemaphoreRequest"},
    {0x000C0040, ConvertProcessAddressFromDspDram, "ConvertProcessAddressFromDspDram"},
-    {0x000D0082, WriteProcessPipe,                 "WriteProcessPipe"},
+    {0x000D0082, WriteProcessPipe, "WriteProcessPipe"},
-    {0x000E00C0, ReadPipe,                         "ReadPipe"},
+    {0x000E00C0, ReadPipe, "ReadPipe"},
-    {0x000F0080, GetPipeReadableSize,              "GetPipeReadableSize"},
+    {0x000F0080, GetPipeReadableSize, "GetPipeReadableSize"},
-    {0x001000C0, ReadPipeIfPossible,               "ReadPipeIfPossible"},
+    {0x001000C0, ReadPipeIfPossible, "ReadPipeIfPossible"},
-    {0x001100C2, LoadComponent,                    "LoadComponent"},
+    {0x001100C2, LoadComponent, "LoadComponent"},
-    {0x00120000, nullptr,                          "UnloadComponent"},
+    {0x00120000, nullptr, "UnloadComponent"},
-    {0x00130082, FlushDataCache,                   "FlushDataCache"},
+    {0x00130082, FlushDataCache, "FlushDataCache"},
-    {0x00140082, nullptr,                          "InvalidateDCache"},
+    {0x00140082, nullptr, "InvalidateDCache"},
-    {0x00150082, RegisterInterruptEvents,          "RegisterInterruptEvents"},
+    {0x00150082, RegisterInterruptEvents, "RegisterInterruptEvents"},
-    {0x00160000, GetSemaphoreEventHandle,          "GetSemaphoreEventHandle"},
+    {0x00160000, GetSemaphoreEventHandle, "GetSemaphoreEventHandle"},
-    {0x00170040, SetSemaphoreMask,                 "SetSemaphoreMask"},
+    {0x00170040, SetSemaphoreMask, "SetSemaphoreMask"},
-    {0x00180040, nullptr,                          "GetPhysicalAddress"},
+    {0x00180040, nullptr, "GetPhysicalAddress"},
-    {0x00190040, nullptr,                          "GetVirtualAddress"},
+    {0x00190040, nullptr, "GetVirtualAddress"},
-    {0x001A0042, nullptr,                          "SetIirFilterI2S1_cmd1"},
+    {0x001A0042, nullptr, "SetIirFilterI2S1_cmd1"},
-    {0x001B0042, nullptr,                          "SetIirFilterI2S1_cmd2"},
+    {0x001B0042, nullptr, "SetIirFilterI2S1_cmd2"},
-    {0x001C0082, nullptr,                          "SetIirFilterEQ"},
+    {0x001C0082, nullptr, "SetIirFilterEQ"},
-    {0x001D00C0, nullptr,                          "ReadMultiEx_SPI2"},
+    {0x001D00C0, nullptr, "ReadMultiEx_SPI2"},
-    {0x001E00C2, nullptr,                          "WriteMultiEx_SPI2"},
+    {0x001E00C2, nullptr, "WriteMultiEx_SPI2"},
-    {0x001F0000, GetHeadphoneStatus,               "GetHeadphoneStatus"},
+    {0x001F0000, GetHeadphoneStatus, "GetHeadphoneStatus"},
-    {0x00200040, nullptr,                          "ForceHeadphoneOut"},
+    {0x00200040, nullptr, "ForceHeadphoneOut"},
-    {0x00210000, nullptr,                          "GetIsDspOccupied"},
+    {0x00210000, nullptr, "GetIsDspOccupied"},
 };
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/err_f.cpp b/src/core/hle/service/err_f.cpp
index 5f9cf6e94..2cd8269de 100644
--- a/src/core/hle/service/err_f.cpp
+++ b/src/core/hle/service/err_f.cpp
@@ -35,70 +35,70 @@ union ErrInfo {
    u8 specifier;
    struct {
-        u8 specifier;                // 0x0
+        u8 specifier;            // 0x0
-        u8 rev_high;                 // 0x1
+        u8 rev_high;             // 0x1
-        u16 rev_low;                 // 0x2
+        u16 rev_low;             // 0x2
-        RSL result_code;             // 0x4
+        RSL result_code;         // 0x4
-        u32 address;                 // 0x8
+        u32 address;             // 0x8
-        INSERT_PADDING_BYTES(4);     // 0xC
+        INSERT_PADDING_BYTES(4); // 0xC
-        u32 pid_low;                 // 0x10
+        u32 pid_low;             // 0x10
-        u32 pid_high;                // 0x14
+        u32 pid_high;            // 0x14
-        u32 aid_low;                 // 0x18
+        u32 aid_low;             // 0x18
-        u32 aid_high;                // 0x1C
+        u32 aid_high;            // 0x1C
    } errtype1;
    struct {
-        u8 specifier;                // 0x0
+        u8 specifier;               // 0x0
-        u8 rev_high;                 // 0x1
+        u8 rev_high;                // 0x1
-        u16 rev_low;                 // 0x2
+        u16 rev_low;                // 0x2
-        INSERT_PADDING_BYTES(0xC);   // 0x4
+        INSERT_PADDING_BYTES(0xC);  // 0x4
-        u32 pid_low;                 // 0x10
+        u32 pid_low;                // 0x10
-        u32 pid_high;                // 0x14
+        u32 pid_high;               // 0x14
-        u32 aid_low;                 // 0x18
+        u32 aid_low;                // 0x18
-        u32 aid_high;                // 0x1C
+        u32 aid_high;               // 0x1C
-        u8 error_type;               // 0x20
+        u8 error_type;              // 0x20
-        INSERT_PADDING_BYTES(3);     // 0x21
+        INSERT_PADDING_BYTES(3);    // 0x21
-        u32 fault_status_reg;        // 0x24
+        u32 fault_status_reg;       // 0x24
-        u32 fault_addr;              // 0x28
+        u32 fault_addr;             // 0x28
-        u32 fpexc;                   // 0x2C
+        u32 fpexc;                  // 0x2C
-        u32 finst;                   // 0x30
+        u32 finst;                  // 0x30
-        u32 finst2;                  // 0x34
+        u32 finst2;                 // 0x34
-        INSERT_PADDING_BYTES(0x34);  // 0x38
+        INSERT_PADDING_BYTES(0x34); // 0x38
-        u32 sp;                      // 0x6C
+        u32 sp;                     // 0x6C
-        u32 pc;                      // 0x70
+        u32 pc;                     // 0x70
-        u32 lr;                      // 0x74
+        u32 lr;                     // 0x74
-        u32 cpsr;                    // 0x78
+        u32 cpsr;                   // 0x78
    } errtype3;
    struct {
-        u8 specifier;                // 0x0
+        u8 specifier;             // 0x0
-        u8 rev_high;                 // 0x1
+        u8 rev_high;              // 0x1
-        u16 rev_low;                 // 0x2
+        u16 rev_low;              // 0x2
-        RSL result_code;             // 0x4
+        RSL result_code;          // 0x4
-        INSERT_PADDING_BYTES(8);     // 0x8
+        INSERT_PADDING_BYTES(8);  // 0x8
-        u32 pid_low;                 // 0x10
+        u32 pid_low;              // 0x10
-        u32 pid_high;                // 0x14
+        u32 pid_high;             // 0x14
-        u32 aid_low;                 // 0x18
+        u32 aid_low;              // 0x18
-        u32 aid_high;                // 0x1C
+        u32 aid_high;             // 0x1C
-        char debug_string1[0x2E];    // 0x20
+        char debug_string1[0x2E]; // 0x20
-        char debug_string2[0x2E];    // 0x4E
+        char debug_string2[0x2E]; // 0x4E
    } errtype4;
 };
-enum {
+enum { PrefetchAbort = 0, DataAbort = 1, UndefInstr = 2, VectorFP = 3 };
-    PrefetchAbort = 0,
-    DataAbort     = 1,
-    UndefInstr    = 2,
-    VectorFP      = 3
-};
 static std::string GetErrInfo3Type(u8 type_code) {
    switch (type_code) {
-    case PrefetchAbort: return "Prefetch Abort";
+    case PrefetchAbort:
-    case DataAbort:     return "Data Abort";
+        return "Prefetch Abort";
-    case UndefInstr:    return "Undefined Instruction";
+    case DataAbort:
-    case VectorFP:      return "Vector Floating Point";
+        return "Data Abort";
-    default: return "unknown";
+    case UndefInstr:
+        return "Undefined Instruction";
+    case VectorFP:
+        return "Vector Floating Point";
+    default:
+        return "unknown";
    }
 }
@@ -110,8 +110,7 @@ static void ThrowFatalError(Service::Interface* self) {
    switch (errinfo->specifier) {
    case ErrSpecifier0:
-    case ErrSpecifier1:
+    case ErrSpecifier1: {
-    {
        const auto& errtype = errinfo->errtype1;
        LOG_CRITICAL(Service_ERR, "PID: 0x%08X_0x%08X", errtype.pid_low, errtype.pid_high);
        LOG_CRITICAL(Service_ERR, "REV: %d", errtype.rev_low | (errtype.rev_high << 16));
@@ -119,15 +118,14 @@ static void ThrowFatalError(Service::Interface* self) {
        LOG_CRITICAL(Service_ERR, "ADR: 0x%08X", errtype.address);
        LOG_CRITICAL(Service_ERR, "RSL: 0x%08X", errtype.result_code.raw);
-        LOG_CRITICAL(Service_ERR, "  Level: %u",   errtype.result_code.level.Value());
+        LOG_CRITICAL(Service_ERR, "  Level: %u", errtype.result_code.level.Value());
        LOG_CRITICAL(Service_ERR, "  Summary: %u", errtype.result_code.summary.Value());
-        LOG_CRITICAL(Service_ERR, "  Module: %u",  errtype.result_code.module.Value());
+        LOG_CRITICAL(Service_ERR, "  Module: %u", errtype.result_code.module.Value());
-        LOG_CRITICAL(Service_ERR, "  Desc: %u",    errtype.result_code.description.Value());
+        LOG_CRITICAL(Service_ERR, "  Desc: %u", errtype.result_code.description.Value());
        break;
    }
-    case ErrSpecifier3:
+    case ErrSpecifier3: {
-    {
        const auto& errtype = errinfo->errtype3;
        LOG_CRITICAL(Service_ERR, "PID: 0x%08X_0x%08X", errtype.pid_low, errtype.pid_high);
        LOG_CRITICAL(Service_ERR, "REV: %d", errtype.rev_low | (errtype.rev_high << 16));
@@ -154,18 +152,17 @@ static void ThrowFatalError(Service::Interface* self) {
        break;
    }
-    case ErrSpecifier4:
+    case ErrSpecifier4: {
-    {
        const auto& errtype = errinfo->errtype4;
        LOG_CRITICAL(Service_ERR, "PID: 0x%08X_0x%08X", errtype.pid_low, errtype.pid_high);
        LOG_CRITICAL(Service_ERR, "REV: %d", errtype.rev_low | (errtype.rev_high << 16));
        LOG_CRITICAL(Service_ERR, "AID: 0x%08X_0x%08X", errtype.aid_low, errtype.aid_high);
        LOG_CRITICAL(Service_ERR, "RSL: 0x%08X", errtype.result_code.raw);
-        LOG_CRITICAL(Service_ERR, "  Level: %u",   errtype.result_code.level.Value());
+        LOG_CRITICAL(Service_ERR, "  Level: %u", errtype.result_code.level.Value());
        LOG_CRITICAL(Service_ERR, "  Summary: %u", errtype.result_code.summary.Value());
-        LOG_CRITICAL(Service_ERR, "  Module: %u",  errtype.result_code.module.Value());
+        LOG_CRITICAL(Service_ERR, "  Module: %u", errtype.result_code.module.Value());
-        LOG_CRITICAL(Service_ERR, "  Desc: %u",    errtype.result_code.description.Value());
+        LOG_CRITICAL(Service_ERR, "  Desc: %u", errtype.result_code.description.Value());
        LOG_CRITICAL(Service_ERR, "%s", errtype.debug_string1);
        LOG_CRITICAL(Service_ERR, "%s", errtype.debug_string2);
@@ -176,9 +173,7 @@ static void ThrowFatalError(Service::Interface* self) {
    cmd_buff[1] = 0; // No error
 }
-const Interface::FunctionInfo FunctionTable[] = {
+const Interface::FunctionInfo FunctionTable[] = {{0x00010800, ThrowFatalError, "ThrowFatalError"}};
-    {0x00010800, ThrowFatalError,           "ThrowFatalError"}
-};
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Interface class
diff --git a/src/core/hle/service/frd/frd.cpp b/src/core/hle/service/frd/frd.cpp
index 29d144365..1e9fe178f 100644
--- a/src/core/hle/service/frd/frd.cpp
+++ b/src/core/hle/service/frd/frd.cpp
@@ -4,10 +4,10 @@
 #include "common/string_util.h"
-#include "core/hle/service/service.h"
 #include "core/hle/service/frd/frd.h"
 #include "core/hle/service/frd/frd_a.h"
 #include "core/hle/service/frd/frd_u.h"
+#include "core/hle/service/service.h"
 namespace Service {
 namespace FRD {
@@ -43,7 +43,7 @@ void GetFriendKeyList(Service::Interface* self) {
    }
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
-    cmd_buff[2] = 0; // 0 friends
+    cmd_buff[2] = 0;                  // 0 friends
    LOG_WARNING(Service_FRD, "(STUBBED) called, unknown=%d, frd_count=%d, frd_key_addr=0x%08X",
                unknown, frd_count, frd_key_addr);
 }
@@ -61,25 +61,27 @@ void GetFriendProfile(Service::Interface* self) {
    }
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
-    LOG_WARNING(Service_FRD, "(STUBBED) called, count=%d, frd_key_addr=0x%08X, profiles_addr=0x%08X",
+    LOG_WARNING(Service_FRD,
-                count, frd_key_addr, profiles_addr);
+                "(STUBBED) called, count=%d, frd_key_addr=0x%08X, profiles_addr=0x%08X", count,
+                frd_key_addr, profiles_addr);
 }
 void GetFriendAttributeFlags(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
-    u32 count           = cmd_buff[1];
+    u32 count = cmd_buff[1];
-    u32 frd_key_addr    = cmd_buff[3];
+    u32 frd_key_addr = cmd_buff[3];
    u32 attr_flags_addr = cmd_buff[65];
    for (u32 i = 0; i < count; ++i) {
-        //TODO:(mailwl) figure out AttributeFlag size and zero all buffer. Assume 1 byte
+        // TODO:(mailwl) figure out AttributeFlag size and zero all buffer. Assume 1 byte
        Memory::Write8(attr_flags_addr + i, 0);
    }
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
-    LOG_WARNING(Service_FRD, "(STUBBED) called, count=%d, frd_key_addr=0x%08X, attr_flags_addr=0x%08X",
+    LOG_WARNING(Service_FRD,
-                count, frd_key_addr, attr_flags_addr);
+                "(STUBBED) called, count=%d, frd_key_addr=0x%08X, attr_flags_addr=0x%08X", count,
+                frd_key_addr, attr_flags_addr);
 }
 void GetMyFriendKey(Service::Interface* self) {
diff --git a/src/core/hle/service/frd/frd_a.cpp b/src/core/hle/service/frd/frd_a.cpp
index 818d610f3..cfc37210b 100644
--- a/src/core/hle/service/frd/frd_a.cpp
+++ b/src/core/hle/service/frd/frd_a.cpp
@@ -11,7 +11,7 @@ namespace FRD {
 // const Interface::FunctionInfo FunctionTable[] = { };
 FRD_A_Interface::FRD_A_Interface() {
-    //Register(FunctionTable);
+    // Register(FunctionTable);
 }
 } // namespace FRD
diff --git a/src/core/hle/service/frd/frd_u.cpp b/src/core/hle/service/frd/frd_u.cpp
index db8666416..bd1c9c16b 100644
--- a/src/core/hle/service/frd/frd_u.cpp
+++ b/src/core/hle/service/frd/frd_u.cpp
@@ -9,59 +9,59 @@ namespace Service {
 namespace FRD {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010000, nullptr,                 "HasLoggedIn"},
+    {0x00010000, nullptr, "HasLoggedIn"},
-    {0x00020000, nullptr,                 "IsOnline"},
+    {0x00020000, nullptr, "IsOnline"},
-    {0x00030000, nullptr,                 "Login"},
+    {0x00030000, nullptr, "Login"},
-    {0x00040000, nullptr,                 "Logout"},
+    {0x00040000, nullptr, "Logout"},
-    {0x00050000, GetMyFriendKey,          "GetMyFriendKey"},
+    {0x00050000, GetMyFriendKey, "GetMyFriendKey"},
-    {0x00060000, nullptr,                 "GetMyPreference"},
+    {0x00060000, nullptr, "GetMyPreference"},
-    {0x00070000, nullptr,                 "GetMyProfile"},
+    {0x00070000, nullptr, "GetMyProfile"},
-    {0x00080000, GetMyPresence,           "GetMyPresence"},
+    {0x00080000, GetMyPresence, "GetMyPresence"},
-    {0x00090000, GetMyScreenName,         "GetMyScreenName"},
+    {0x00090000, GetMyScreenName, "GetMyScreenName"},
-    {0x000A0000, nullptr,                 "GetMyMii"},
+    {0x000A0000, nullptr, "GetMyMii"},
-    {0x000B0000, nullptr,                 "GetMyLocalAccountId"},
+    {0x000B0000, nullptr, "GetMyLocalAccountId"},
-    {0x000C0000, nullptr,                 "GetMyPlayingGame"},
+    {0x000C0000, nullptr, "GetMyPlayingGame"},
-    {0x000D0000, nullptr,                 "GetMyFavoriteGame"},
+    {0x000D0000, nullptr, "GetMyFavoriteGame"},
-    {0x000E0000, nullptr,                 "GetMyNcPrincipalId"},
+    {0x000E0000, nullptr, "GetMyNcPrincipalId"},
-    {0x000F0000, nullptr,                 "GetMyComment"},
+    {0x000F0000, nullptr, "GetMyComment"},
-    {0x00100040, nullptr,                 "GetMyPassword"},
+    {0x00100040, nullptr, "GetMyPassword"},
-    {0x00110080, GetFriendKeyList,        "GetFriendKeyList"},
+    {0x00110080, GetFriendKeyList, "GetFriendKeyList"},
-    {0x00120042, nullptr,                 "GetFriendPresence"},
+    {0x00120042, nullptr, "GetFriendPresence"},
-    {0x00130142, nullptr,                 "GetFriendScreenName"},
+    {0x00130142, nullptr, "GetFriendScreenName"},
-    {0x00140044, nullptr,                 "GetFriendMii"},
+    {0x00140044, nullptr, "GetFriendMii"},
-    {0x00150042, GetFriendProfile,        "GetFriendProfile"},
+    {0x00150042, GetFriendProfile, "GetFriendProfile"},
-    {0x00160042, nullptr,                 "GetFriendRelationship"},
+    {0x00160042, nullptr, "GetFriendRelationship"},
    {0x00170042, GetFriendAttributeFlags, "GetFriendAttributeFlags"},
-    {0x00180044, nullptr,                 "GetFriendPlayingGame"},
+    {0x00180044, nullptr, "GetFriendPlayingGame"},
-    {0x00190042, nullptr,                 "GetFriendFavoriteGame"},
+    {0x00190042, nullptr, "GetFriendFavoriteGame"},
-    {0x001A00C4, nullptr,                 "GetFriendInfo"},
+    {0x001A00C4, nullptr, "GetFriendInfo"},
-    {0x001B0080, nullptr,                 "IsIncludedInFriendList"},
+    {0x001B0080, nullptr, "IsIncludedInFriendList"},
-    {0x001C0042, nullptr,                 "UnscrambleLocalFriendCode"},
+    {0x001C0042, nullptr, "UnscrambleLocalFriendCode"},
-    {0x001D0002, nullptr,                 "UpdateGameModeDescription"},
+    {0x001D0002, nullptr, "UpdateGameModeDescription"},
-    {0x001E02C2, nullptr,                 "UpdateGameMode"},
+    {0x001E02C2, nullptr, "UpdateGameMode"},
-    {0x001F0042, nullptr,                 "SendInvitation"},
+    {0x001F0042, nullptr, "SendInvitation"},
-    {0x00200002, nullptr,                 "AttachToEventNotification"},
+    {0x00200002, nullptr, "AttachToEventNotification"},
-    {0x00210040, nullptr,                 "SetNotificationMask"},
+    {0x00210040, nullptr, "SetNotificationMask"},
-    {0x00220040, nullptr,                 "GetEventNotification"},
+    {0x00220040, nullptr, "GetEventNotification"},
-    {0x00230000, nullptr,                 "GetLastResponseResult"},
+    {0x00230000, nullptr, "GetLastResponseResult"},
-    {0x00240040, nullptr,                 "PrincipalIdToFriendCode"},
+    {0x00240040, nullptr, "PrincipalIdToFriendCode"},
-    {0x00250080, nullptr,                 "FriendCodeToPrincipalId"},
+    {0x00250080, nullptr, "FriendCodeToPrincipalId"},
-    {0x00260080, nullptr,                 "IsValidFriendCode"},
+    {0x00260080, nullptr, "IsValidFriendCode"},
-    {0x00270040, nullptr,                 "ResultToErrorCode"},
+    {0x00270040, nullptr, "ResultToErrorCode"},
-    {0x00280244, nullptr,                 "RequestGameAuthentication"},
+    {0x00280244, nullptr, "RequestGameAuthentication"},
-    {0x00290000, nullptr,                 "GetGameAuthenticationData"},
+    {0x00290000, nullptr, "GetGameAuthenticationData"},
-    {0x002A0204, nullptr,                 "RequestServiceLocator"},
+    {0x002A0204, nullptr, "RequestServiceLocator"},
-    {0x002B0000, nullptr,                 "GetServiceLocatorData"},
+    {0x002B0000, nullptr, "GetServiceLocatorData"},
-    {0x002C0002, nullptr,                 "DetectNatProperties"},
+    {0x002C0002, nullptr, "DetectNatProperties"},
-    {0x002D0000, nullptr,                 "GetNatProperties"},
+    {0x002D0000, nullptr, "GetNatProperties"},
-    {0x002E0000, nullptr,                 "GetServerTimeInterval"},
+    {0x002E0000, nullptr, "GetServerTimeInterval"},
-    {0x002F0040, nullptr,                 "AllowHalfAwake"},
+    {0x002F0040, nullptr, "AllowHalfAwake"},
-    {0x00300000, nullptr,                 "GetServerTypes"},
+    {0x00300000, nullptr, "GetServerTypes"},
-    {0x00310082, nullptr,                 "GetFriendComment"},
+    {0x00310082, nullptr, "GetFriendComment"},
-    {0x00320042, nullptr,                 "SetClientSdkVersion"},
+    {0x00320042, nullptr, "SetClientSdkVersion"},
-    {0x00330000, nullptr,                 "GetMyApproachContext"},
+    {0x00330000, nullptr, "GetMyApproachContext"},
-    {0x00340046, nullptr,                 "AddFriendWithApproach"},
+    {0x00340046, nullptr, "AddFriendWithApproach"},
-    {0x00350082, nullptr,                 "DecryptApproachContext"},
+    {0x00350082, nullptr, "DecryptApproachContext"},
 };
 FRD_U_Interface::FRD_U_Interface() {
diff --git a/src/core/hle/service/fs/archive.cpp b/src/core/hle/service/fs/archive.cpp
index 4c7aaa7f2..1b851eade 100644
--- a/src/core/hle/service/fs/archive.cpp
+++ b/src/core/hle/service/fs/archive.cpp
@@ -3,9 +3,9 @@
 // Refer to the license.txt file included.
 #include <cstddef>
+#include <memory>
 #include <system_error>
 #include <type_traits>
-#include <memory>
 #include <unordered_map>
 #include <utility>
@@ -25,25 +25,25 @@
 #include "core/file_sys/directory_backend.h"
 #include "core/file_sys/file_backend.h"
 #include "core/hle/hle.h"
-#include "core/hle/service/service.h"
+#include "core/hle/result.h"
 #include "core/hle/service/fs/archive.h"
 #include "core/hle/service/fs/fs_user.h"
-#include "core/hle/result.h"
+#include "core/hle/service/service.h"
 #include "core/memory.h"
 // Specializes std::hash for ArchiveIdCode, so that we can use it in std::unordered_map.
 // Workaroung for libstdc++ bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60970
 namespace std {
-    template <>
+template <>
-    struct hash<Service::FS::ArchiveIdCode> {
+struct hash<Service::FS::ArchiveIdCode> {
-        typedef Service::FS::ArchiveIdCode argument_type;
+    typedef Service::FS::ArchiveIdCode argument_type;
-        typedef std::size_t result_type;
+    typedef std::size_t result_type;
-        result_type operator()(const argument_type& id_code) const {
+    result_type operator()(const argument_type& id_code) const {
-            typedef std::underlying_type<argument_type>::type Type;
+        typedef std::underlying_type<argument_type>::type Type;
-            return std::hash<Type>()(static_cast<Type>(id_code));
+        return std::hash<Type>()(static_cast<Type>(id_code));
-        }
+    }
-    };
+};
 }
 /// TODO(Subv): Confirm length of these strings
@@ -56,197 +56,193 @@ namespace FS {
 // TODO: Verify code
 /// Returned when a function is passed an invalid handle.
 const ResultCode ERR_INVALID_HANDLE(ErrorDescription::InvalidHandle, ErrorModule::FS,
-        ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
+                                    ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
 /// Returned when a function is passed an invalid archive handle.
 const ResultCode ERR_INVALID_ARCHIVE_HANDLE(ErrorDescription::FS_ArchiveNotMounted, ErrorModule::FS,
-    ErrorSummary::NotFound, ErrorLevel::Status); // 0xC8804465
+                                            ErrorSummary::NotFound,
+                                            ErrorLevel::Status); // 0xC8804465
 // Command to access archive file
 enum class FileCommand : u32 {
-    Dummy1          = 0x000100C6,
+    Dummy1 = 0x000100C6,
-    Control         = 0x040100C4,
+    Control = 0x040100C4,
-    OpenSubFile     = 0x08010100,
+    OpenSubFile = 0x08010100,
-    Read            = 0x080200C2,
+    Read = 0x080200C2,
-    Write           = 0x08030102,
+    Write = 0x08030102,
-    GetSize         = 0x08040000,
+    GetSize = 0x08040000,
-    SetSize         = 0x08050080,
+    SetSize = 0x08050080,
-    GetAttributes   = 0x08060000,
+    GetAttributes = 0x08060000,
-    SetAttributes   = 0x08070040,
+    SetAttributes = 0x08070040,
-    Close           = 0x08080000,
+    Close = 0x08080000,
-    Flush           = 0x08090000,
+    Flush = 0x08090000,
-    SetPriority     = 0x080A0040,
+    SetPriority = 0x080A0040,
-    GetPriority     = 0x080B0000,
+    GetPriority = 0x080B0000,
-    OpenLinkFile    = 0x080C0000,
+    OpenLinkFile = 0x080C0000,
 };
 // Command to access directory
 enum class DirectoryCommand : u32 {
-    Dummy1          = 0x000100C6,
+    Dummy1 = 0x000100C6,
-    Control         = 0x040100C4,
+    Control = 0x040100C4,
-    Read            = 0x08010042,
+    Read = 0x08010042,
-    Close           = 0x08020000,
+    Close = 0x08020000,
 };
-File::File(std::unique_ptr<FileSys::FileBackend>&& backend, const FileSys::Path & path)
+File::File(std::unique_ptr<FileSys::FileBackend>&& backend, const FileSys::Path& path)
-    : path(path), priority(0), backend(std::move(backend)) {}
+    : path(path), priority(0), backend(std::move(backend)) {
+}
-File::~File() {}
+File::~File() {
+}
 ResultVal<bool> File::SyncRequest() {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    FileCommand cmd = static_cast<FileCommand>(cmd_buff[0]);
    switch (cmd) {
-        // Read from file...
+    // Read from file...
-        case FileCommand::Read:
+    case FileCommand::Read: {
-        {
+        u64 offset = cmd_buff[1] | ((u64)cmd_buff[2]) << 32;
-            u64 offset = cmd_buff[1] | ((u64)cmd_buff[2]) << 32;
+        u32 length = cmd_buff[3];
-            u32 length = cmd_buff[3];
+        u32 address = cmd_buff[5];
-            u32 address = cmd_buff[5];
+        LOG_TRACE(Service_FS, "Read %s %s: offset=0x%llx length=%d address=0x%x",
-            LOG_TRACE(Service_FS, "Read %s %s: offset=0x%llx length=%d address=0x%x",
+                  GetTypeName().c_str(), GetName().c_str(), offset, length, address);
-                      GetTypeName().c_str(), GetName().c_str(), offset, length, address);
+        if (offset + length > backend->GetSize()) {
-            if (offset + length > backend->GetSize()) {
+            LOG_ERROR(Service_FS,
-                LOG_ERROR(Service_FS, "Reading from out of bounds offset=0x%llX length=0x%08X file_size=0x%llX",
+                      "Reading from out of bounds offset=0x%llX length=0x%08X file_size=0x%llX",
-                          offset, length, backend->GetSize());
+                      offset, length, backend->GetSize());
-            }
-            std::vector<u8> data(length);
-            ResultVal<size_t> read = backend->Read(offset, data.size(), data.data());
-            if (read.Failed()) {
-                cmd_buff[1] = read.Code().raw;
-                return read.Code();
-            }
-            Memory::WriteBlock(address, data.data(), *read);
-            cmd_buff[2] = static_cast<u32>(*read);
-            break;
        }
-        // Write to file...
+        std::vector<u8> data(length);
-        case FileCommand::Write:
+        ResultVal<size_t> read = backend->Read(offset, data.size(), data.data());
-        {
+        if (read.Failed()) {
-            u64 offset = cmd_buff[1] | ((u64)cmd_buff[2]) << 32;
+            cmd_buff[1] = read.Code().raw;
-            u32 length = cmd_buff[3];
+            return read.Code();
-            u32 flush = cmd_buff[4];
-            u32 address = cmd_buff[6];
-            LOG_TRACE(Service_FS, "Write %s %s: offset=0x%llx length=%d address=0x%x, flush=0x%x",
-                      GetTypeName().c_str(), GetName().c_str(), offset, length, address, flush);
-            std::vector<u8> data(length);
-            Memory::ReadBlock(address, data.data(), data.size());
-            ResultVal<size_t> written = backend->Write(offset, data.size(), flush != 0, data.data());
-            if (written.Failed()) {
-                cmd_buff[1] = written.Code().raw;
-                return written.Code();
-            }
-            cmd_buff[2] = static_cast<u32>(*written);
-            break;
        }
+        Memory::WriteBlock(address, data.data(), *read);
+        cmd_buff[2] = static_cast<u32>(*read);
+        break;
+    }
-        case FileCommand::GetSize:
+    // Write to file...
-        {
+    case FileCommand::Write: {
-            LOG_TRACE(Service_FS, "GetSize %s %s", GetTypeName().c_str(), GetName().c_str());
+        u64 offset = cmd_buff[1] | ((u64)cmd_buff[2]) << 32;
-            u64 size = backend->GetSize();
+        u32 length = cmd_buff[3];
-            cmd_buff[2] = (u32)size;
+        u32 flush = cmd_buff[4];
-            cmd_buff[3] = size >> 32;
+        u32 address = cmd_buff[6];
-            break;
+        LOG_TRACE(Service_FS, "Write %s %s: offset=0x%llx length=%d address=0x%x, flush=0x%x",
+                  GetTypeName().c_str(), GetName().c_str(), offset, length, address, flush);
+        std::vector<u8> data(length);
+        Memory::ReadBlock(address, data.data(), data.size());
+        ResultVal<size_t> written = backend->Write(offset, data.size(), flush != 0, data.data());
+        if (written.Failed()) {
+            cmd_buff[1] = written.Code().raw;
+            return written.Code();
        }
+        cmd_buff[2] = static_cast<u32>(*written);
+        break;
+    }
-        case FileCommand::SetSize:
+    case FileCommand::GetSize: {
-        {
+        LOG_TRACE(Service_FS, "GetSize %s %s", GetTypeName().c_str(), GetName().c_str());
-            u64 size = cmd_buff[1] | ((u64)cmd_buff[2] << 32);
+        u64 size = backend->GetSize();
-            LOG_TRACE(Service_FS, "SetSize %s %s size=%llu",
+        cmd_buff[2] = (u32)size;
-                GetTypeName().c_str(), GetName().c_str(), size);
+        cmd_buff[3] = size >> 32;
-            backend->SetSize(size);
+        break;
-            break;
+    }
-        }
-        case FileCommand::Close:
+    case FileCommand::SetSize: {
-        {
+        u64 size = cmd_buff[1] | ((u64)cmd_buff[2] << 32);
-            LOG_TRACE(Service_FS, "Close %s %s", GetTypeName().c_str(), GetName().c_str());
+        LOG_TRACE(Service_FS, "SetSize %s %s size=%llu", GetTypeName().c_str(), GetName().c_str(),
-            backend->Close();
+                  size);
-            break;
+        backend->SetSize(size);
-        }
+        break;
+    }
-        case FileCommand::Flush:
+    case FileCommand::Close: {
-        {
+        LOG_TRACE(Service_FS, "Close %s %s", GetTypeName().c_str(), GetName().c_str());
-            LOG_TRACE(Service_FS, "Flush");
+        backend->Close();
-            backend->Flush();
+        break;
-            break;
+    }
-        }
-        case FileCommand::OpenLinkFile:
+    case FileCommand::Flush: {
-        {
+        LOG_TRACE(Service_FS, "Flush");
-            LOG_WARNING(Service_FS, "(STUBBED) File command OpenLinkFile %s", GetName().c_str());
+        backend->Flush();
-            cmd_buff[3] = Kernel::g_handle_table.Create(this).ValueOr(INVALID_HANDLE);
+        break;
-            break;
+    }
-        }
-        case FileCommand::SetPriority:
+    case FileCommand::OpenLinkFile: {
-        {
+        LOG_WARNING(Service_FS, "(STUBBED) File command OpenLinkFile %s", GetName().c_str());
-            priority = cmd_buff[1];
+        cmd_buff[3] = Kernel::g_handle_table.Create(this).ValueOr(INVALID_HANDLE);
-            LOG_TRACE(Service_FS, "SetPriority %u", priority);
+        break;
-            break;
+    }
-        }
-        case FileCommand::GetPriority:
+    case FileCommand::SetPriority: {
-        {
+        priority = cmd_buff[1];
-            cmd_buff[2] = priority;
+        LOG_TRACE(Service_FS, "SetPriority %u", priority);
-            LOG_TRACE(Service_FS, "GetPriority");
+        break;
-            break;
+    }
-        }
-        // Unknown command...
+    case FileCommand::GetPriority: {
-        default:
+        cmd_buff[2] = priority;
-            LOG_ERROR(Service_FS, "Unknown command=0x%08X!", cmd);
+        LOG_TRACE(Service_FS, "GetPriority");
-            ResultCode error = UnimplementedFunction(ErrorModule::FS);
+        break;
-            cmd_buff[1] = error.raw; // TODO(Link Mauve): use the correct error code for that.
+    }
-            return error;
+    // Unknown command...
+    default:
+        LOG_ERROR(Service_FS, "Unknown command=0x%08X!", cmd);
+        ResultCode error = UnimplementedFunction(ErrorModule::FS);
+        cmd_buff[1] = error.raw; // TODO(Link Mauve): use the correct error code for that.
+        return error;
    }
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
    return MakeResult<bool>(false);
 }
-Directory::Directory(std::unique_ptr<FileSys::DirectoryBackend>&& backend, const FileSys::Path & path)
+Directory::Directory(std::unique_ptr<FileSys::DirectoryBackend>&& backend,
-    : path(path), backend(std::move(backend)) {}
+                     const FileSys::Path& path)
+    : path(path), backend(std::move(backend)) {
+}
-Directory::~Directory() {}
+Directory::~Directory() {
+}
 ResultVal<bool> Directory::SyncRequest() {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    DirectoryCommand cmd = static_cast<DirectoryCommand>(cmd_buff[0]);
    switch (cmd) {
-        // Read from directory...
+    // Read from directory...
-        case DirectoryCommand::Read:
+    case DirectoryCommand::Read: {
-        {
+        u32 count = cmd_buff[1];
-            u32 count = cmd_buff[1];
+        u32 address = cmd_buff[3];
-            u32 address = cmd_buff[3];
+        std::vector<FileSys::Entry> entries(count);
-            std::vector<FileSys::Entry> entries(count);
+        LOG_TRACE(Service_FS, "Read %s %s: count=%d", GetTypeName().c_str(), GetName().c_str(),
-            LOG_TRACE(Service_FS, "Read %s %s: count=%d",
+                  count);
-                GetTypeName().c_str(), GetName().c_str(), count);
+        // Number of entries actually read
-            // Number of entries actually read
+        u32 read = backend->Read(entries.size(), entries.data());
-            u32 read = backend->Read(entries.size(), entries.data());
+        cmd_buff[2] = read;
-            cmd_buff[2] = read;
+        Memory::WriteBlock(address, entries.data(), read * sizeof(FileSys::Entry));
-            Memory::WriteBlock(address, entries.data(), read * sizeof(FileSys::Entry));
+        break;
-            break;
+    }
-        }
-        case DirectoryCommand::Close:
+    case DirectoryCommand::Close: {
-        {
+        LOG_TRACE(Service_FS, "Close %s %s", GetTypeName().c_str(), GetName().c_str());
-            LOG_TRACE(Service_FS, "Close %s %s", GetTypeName().c_str(), GetName().c_str());
+        backend->Close();
-            backend->Close();
+        break;
-            break;
+    }
-        }
-        // Unknown command...
+    // Unknown command...
-        default:
+    default:
-            LOG_ERROR(Service_FS, "Unknown command=0x%08X!", cmd);
+        LOG_ERROR(Service_FS, "Unknown command=0x%08X!", cmd);
-            ResultCode error = UnimplementedFunction(ErrorModule::FS);
+        ResultCode error = UnimplementedFunction(ErrorModule::FS);
-            cmd_buff[1] = error.raw; // TODO(Link Mauve): use the correct error code for that.
+        cmd_buff[1] = error.raw; // TODO(Link Mauve): use the correct error code for that.
-            return MakeResult<bool>(false);
+        return MakeResult<bool>(false);
    }
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
    return MakeResult<bool>(false);
@@ -280,8 +276,8 @@ ResultVal<ArchiveHandle> OpenArchive(ArchiveIdCode id_code, FileSys::Path& archi
    auto itr = id_code_map.find(id_code);
    if (itr == id_code_map.end()) {
        // TODO: Verify error against hardware
-        return ResultCode(ErrorDescription::NotFound, ErrorModule::FS,
+        return ResultCode(ErrorDescription::NotFound, ErrorModule::FS, ErrorSummary::NotFound,
-                          ErrorSummary::NotFound, ErrorLevel::Permanent);
+                          ErrorLevel::Permanent);
    }
    CASCADE_RESULT(std::unique_ptr<ArchiveBackend> res, itr->second->Open(archive_path));
@@ -303,19 +299,22 @@ ResultCode CloseArchive(ArchiveHandle handle) {
 // TODO(yuriks): This might be what the fs:REG service is for. See the Register/Unregister calls in
 // http://3dbrew.org/wiki/Filesystem_services#ProgramRegistry_service_.22fs:REG.22
-ResultCode RegisterArchiveType(std::unique_ptr<FileSys::ArchiveFactory>&& factory, ArchiveIdCode id_code) {
+ResultCode RegisterArchiveType(std::unique_ptr<FileSys::ArchiveFactory>&& factory,
+                               ArchiveIdCode id_code) {
    auto result = id_code_map.emplace(id_code, std::move(factory));
    bool inserted = result.second;
    ASSERT_MSG(inserted, "Tried to register more than one archive with same id code");
    auto& archive = result.first->second;
-    LOG_DEBUG(Service_FS, "Registered archive %s with id code 0x%08X", archive->GetName().c_str(), id_code);
+    LOG_DEBUG(Service_FS, "Registered archive %s with id code 0x%08X", archive->GetName().c_str(),
+              id_code);
    return RESULT_SUCCESS;
 }
 ResultVal<Kernel::SharedPtr<File>> OpenFileFromArchive(ArchiveHandle archive_handle,
-        const FileSys::Path& path, const FileSys::Mode mode) {
+                                                       const FileSys::Path& path,
+                                                       const FileSys::Mode mode) {
    ArchiveBackend* archive = GetArchive(archive_handle);
    if (archive == nullptr)
        return ERR_INVALID_ARCHIVE_HANDLE;
@@ -336,8 +335,10 @@ ResultCode DeleteFileFromArchive(ArchiveHandle archive_handle, const FileSys::Pa
    return archive->DeleteFile(path);
 }
-ResultCode RenameFileBetweenArchives(ArchiveHandle src_archive_handle, const FileSys::Path& src_path,
+ResultCode RenameFileBetweenArchives(ArchiveHandle src_archive_handle,
-                                     ArchiveHandle dest_archive_handle, const FileSys::Path& dest_path) {
+                                     const FileSys::Path& src_path,
+                                     ArchiveHandle dest_archive_handle,
+                                     const FileSys::Path& dest_path) {
    ArchiveBackend* src_archive = GetArchive(src_archive_handle);
    ArchiveBackend* dest_archive = GetArchive(dest_archive_handle);
    if (src_archive == nullptr || dest_archive == nullptr)
@@ -368,7 +369,8 @@ ResultCode DeleteDirectoryFromArchive(ArchiveHandle archive_handle, const FileSy
                      ErrorSummary::Canceled, ErrorLevel::Status);
 }
-ResultCode CreateFileInArchive(ArchiveHandle archive_handle, const FileSys::Path& path, u64 file_size) {
+ResultCode CreateFileInArchive(ArchiveHandle archive_handle, const FileSys::Path& path,
+                               u64 file_size) {
    ArchiveBackend* archive = GetArchive(archive_handle);
    if (archive == nullptr)
        return ERR_INVALID_ARCHIVE_HANDLE;
@@ -387,8 +389,10 @@ ResultCode CreateDirectoryFromArchive(ArchiveHandle archive_handle, const FileSy
                      ErrorSummary::Canceled, ErrorLevel::Status);
 }
-ResultCode RenameDirectoryBetweenArchives(ArchiveHandle src_archive_handle, const FileSys::Path& src_path,
+ResultCode RenameDirectoryBetweenArchives(ArchiveHandle src_archive_handle,
-                                          ArchiveHandle dest_archive_handle, const FileSys::Path& dest_path) {
+                                          const FileSys::Path& src_path,
+                                          ArchiveHandle dest_archive_handle,
+                                          const FileSys::Path& dest_path) {
    ArchiveBackend* src_archive = GetArchive(src_archive_handle);
    ArchiveBackend* dest_archive = GetArchive(dest_archive_handle);
    if (src_archive == nullptr || dest_archive == nullptr)
@@ -409,15 +413,15 @@ ResultCode RenameDirectoryBetweenArchives(ArchiveHandle src_archive_handle, cons
 }
 ResultVal<Kernel::SharedPtr<Directory>> OpenDirectoryFromArchive(ArchiveHandle archive_handle,
-        const FileSys::Path& path) {
+                                                                 const FileSys::Path& path) {
    ArchiveBackend* archive = GetArchive(archive_handle);
    if (archive == nullptr)
        return ERR_INVALID_ARCHIVE_HANDLE;
    std::unique_ptr<FileSys::DirectoryBackend> backend = archive->OpenDirectory(path);
    if (backend == nullptr) {
-        return ResultCode(ErrorDescription::FS_NotFound, ErrorModule::FS,
+        return ResultCode(ErrorDescription::FS_NotFound, ErrorModule::FS, ErrorSummary::NotFound,
-                          ErrorSummary::NotFound, ErrorLevel::Permanent);
+                          ErrorLevel::Permanent);
    }
    auto directory = Kernel::SharedPtr<Directory>(new Directory(std::move(backend), path));
@@ -431,7 +435,8 @@ ResultVal<u64> GetFreeBytesInArchive(ArchiveHandle archive_handle) {
    return MakeResult<u64>(archive->GetFreeBytes());
 }
-ResultCode FormatArchive(ArchiveIdCode id_code, const FileSys::ArchiveFormatInfo& format_info, const FileSys::Path& path) {
+ResultCode FormatArchive(ArchiveIdCode id_code, const FileSys::ArchiveFormatInfo& format_info,
+                         const FileSys::Path& path) {
    auto archive_itr = id_code_map.find(id_code);
    if (archive_itr == id_code_map.end()) {
        return UnimplementedFunction(ErrorModule::FS); // TODO(Subv): Find the right error
@@ -440,7 +445,8 @@ ResultCode FormatArchive(ArchiveIdCode id_code, const FileSys::ArchiveFormatInfo
    return archive_itr->second->Format(path, format_info);
 }
-ResultVal<FileSys::ArchiveFormatInfo> GetArchiveFormatInfo(ArchiveIdCode id_code, FileSys::Path& archive_path) {
+ResultVal<FileSys::ArchiveFormatInfo> GetArchiveFormatInfo(ArchiveIdCode id_code,
+                                                           FileSys::Path& archive_path) {
    auto archive = id_code_map.find(id_code);
    if (archive == id_code_map.end()) {
        return UnimplementedFunction(ErrorModule::FS); // TODO(Subv): Find the right error
@@ -449,11 +455,14 @@ ResultVal<FileSys::ArchiveFormatInfo> GetArchiveFormatInfo(ArchiveIdCode id_code
    return archive->second->GetFormatInfo(archive_path);
 }
-ResultCode CreateExtSaveData(MediaType media_type, u32 high, u32 low, VAddr icon_buffer, u32 icon_size, const FileSys::ArchiveFormatInfo& format_info) {
+ResultCode CreateExtSaveData(MediaType media_type, u32 high, u32 low, VAddr icon_buffer,
+                             u32 icon_size, const FileSys::ArchiveFormatInfo& format_info) {
    // Construct the binary path to the archive first
-    FileSys::Path path = FileSys::ConstructExtDataBinaryPath(static_cast<u32>(media_type), high, low);
+    FileSys::Path path =
+        FileSys::ConstructExtDataBinaryPath(static_cast<u32>(media_type), high, low);
-    auto archive = id_code_map.find(media_type == MediaType::NAND ? ArchiveIdCode::SharedExtSaveData : ArchiveIdCode::ExtSaveData);
+    auto archive = id_code_map.find(media_type == MediaType::NAND ? ArchiveIdCode::SharedExtSaveData
+                                                                  : ArchiveIdCode::ExtSaveData);
    if (archive == id_code_map.end()) {
        return UnimplementedFunction(ErrorModule::FS); // TODO(Subv): Find the right error
@@ -476,7 +485,8 @@ ResultCode CreateExtSaveData(MediaType media_type, u32 high, u32 low, VAddr icon
 ResultCode DeleteExtSaveData(MediaType media_type, u32 high, u32 low) {
    // Construct the binary path to the archive first
-    FileSys::Path path = FileSys::ConstructExtDataBinaryPath(static_cast<u32>(media_type), high, low);
+    FileSys::Path path =
+        FileSys::ConstructExtDataBinaryPath(static_cast<u32>(media_type), high, low);
    std::string media_type_directory;
    if (media_type == MediaType::NAND) {
@@ -489,7 +499,8 @@ ResultCode DeleteExtSaveData(MediaType media_type, u32 high, u32 low) {
    }
    // Delete all directories (/user, /boss) and the icon file.
-    std::string base_path = FileSys::GetExtDataContainerPath(media_type_directory, media_type == MediaType::NAND);
+    std::string base_path =
+        FileSys::GetExtDataContainerPath(media_type_directory, media_type == MediaType::NAND);
    std::string extsavedata_path = FileSys::GetExtSaveDataPath(base_path, path);
    if (FileUtil::Exists(extsavedata_path) && !FileUtil::DeleteDirRecursively(extsavedata_path))
        return ResultCode(-1); // TODO(Subv): Find the right error code
@@ -530,30 +541,36 @@ void RegisterArchiveTypes() {
    if (sdmc_factory->Initialize())
        RegisterArchiveType(std::move(sdmc_factory), ArchiveIdCode::SDMC);
    else
-        LOG_ERROR(Service_FS, "Can't instantiate SDMC archive with path %s", sdmc_directory.c_str());
+        LOG_ERROR(Service_FS, "Can't instantiate SDMC archive with path %s",
+                  sdmc_directory.c_str());
    // Create the SaveData archive
    auto savedata_factory = std::make_unique<FileSys::ArchiveFactory_SaveData>(sdmc_directory);
    RegisterArchiveType(std::move(savedata_factory), ArchiveIdCode::SaveData);
-    auto extsavedata_factory = std::make_unique<FileSys::ArchiveFactory_ExtSaveData>(sdmc_directory, false);
+    auto extsavedata_factory =
+        std::make_unique<FileSys::ArchiveFactory_ExtSaveData>(sdmc_directory, false);
    if (extsavedata_factory->Initialize())
        RegisterArchiveType(std::move(extsavedata_factory), ArchiveIdCode::ExtSaveData);
    else
-        LOG_ERROR(Service_FS, "Can't instantiate ExtSaveData archive with path %s", extsavedata_factory->GetMountPoint().c_str());
+        LOG_ERROR(Service_FS, "Can't instantiate ExtSaveData archive with path %s",
+                  extsavedata_factory->GetMountPoint().c_str());
-    auto sharedextsavedata_factory = std::make_unique<FileSys::ArchiveFactory_ExtSaveData>(nand_directory, true);
+    auto sharedextsavedata_factory =
+        std::make_unique<FileSys::ArchiveFactory_ExtSaveData>(nand_directory, true);
    if (sharedextsavedata_factory->Initialize())
        RegisterArchiveType(std::move(sharedextsavedata_factory), ArchiveIdCode::SharedExtSaveData);
    else
        LOG_ERROR(Service_FS, "Can't instantiate SharedExtSaveData archive with path %s",
-            sharedextsavedata_factory->GetMountPoint().c_str());
+                  sharedextsavedata_factory->GetMountPoint().c_str());
    // Create the SaveDataCheck archive, basically a small variation of the RomFS archive
-    auto savedatacheck_factory = std::make_unique<FileSys::ArchiveFactory_SaveDataCheck>(nand_directory);
+    auto savedatacheck_factory =
+        std::make_unique<FileSys::ArchiveFactory_SaveDataCheck>(nand_directory);
    RegisterArchiveType(std::move(savedatacheck_factory), ArchiveIdCode::SaveDataCheck);
-    auto systemsavedata_factory = std::make_unique<FileSys::ArchiveFactory_SystemSaveData>(nand_directory);
+    auto systemsavedata_factory =
+        std::make_unique<FileSys::ArchiveFactory_SystemSaveData>(nand_directory);
    RegisterArchiveType(std::move(systemsavedata_factory), ArchiveIdCode::SystemSaveData);
 }
diff --git a/src/core/hle/service/fs/archive.h b/src/core/hle/service/fs/archive.h
index f7a50a3a7..aad540ff9 100644
--- a/src/core/hle/service/fs/archive.h
+++ b/src/core/hle/service/fs/archive.h
@@ -28,21 +28,18 @@ namespace FS {
 /// Supported archive types
 enum class ArchiveIdCode : u32 {
-    RomFS               = 0x00000003,
+    RomFS = 0x00000003,
-    SaveData            = 0x00000004,
+    SaveData = 0x00000004,
-    ExtSaveData         = 0x00000006,
+    ExtSaveData = 0x00000006,
-    SharedExtSaveData   = 0x00000007,
+    SharedExtSaveData = 0x00000007,
-    SystemSaveData      = 0x00000008,
+    SystemSaveData = 0x00000008,
-    SDMC                = 0x00000009,
+    SDMC = 0x00000009,
-    SDMCWriteOnly       = 0x0000000A,
+    SDMCWriteOnly = 0x0000000A,
-    SaveDataCheck       = 0x2345678A,
+    SaveDataCheck = 0x2345678A,
 };
 /// Media types for the archives
-enum class MediaType : u32 {
+enum class MediaType : u32 { NAND = 0, SDMC = 1 };
-    NAND     = 0,
-    SDMC     = 1
-};
 typedef u64 ArchiveHandle;
@@ -51,11 +48,13 @@ public:
    File(std::unique_ptr<FileSys::FileBackend>&& backend, const FileSys::Path& path);
    ~File();
-    std::string GetName() const override { return "Path: " + path.DebugStr(); }
+    std::string GetName() const override {
+        return "Path: " + path.DebugStr();
+    }
    ResultVal<bool> SyncRequest() override;
    FileSys::Path path; ///< Path of the file
-    u32 priority; ///< Priority of the file. TODO(Subv): Find out what this means
+    u32 priority;       ///< Priority of the file. TODO(Subv): Find out what this means
    std::unique_ptr<FileSys::FileBackend> backend; ///< File backend interface
 };
@@ -64,10 +63,12 @@ public:
    Directory(std::unique_ptr<FileSys::DirectoryBackend>&& backend, const FileSys::Path& path);
    ~Directory();
-    std::string GetName() const override { return "Directory: " + path.DebugStr(); }
+    std::string GetName() const override {
+        return "Directory: " + path.DebugStr();
+    }
    ResultVal<bool> SyncRequest() override;
-    FileSys::Path path; ///< Path of the directory
+    FileSys::Path path;                                 ///< Path of the directory
    std::unique_ptr<FileSys::DirectoryBackend> backend; ///< File backend interface
 };
@@ -90,7 +91,8 @@ ResultCode CloseArchive(ArchiveHandle handle);
 * @param factory File system backend interface to the archive
 * @param id_code Id code used to access this type of archive
 */
-ResultCode RegisterArchiveType(std::unique_ptr<FileSys::ArchiveFactory>&& factory, ArchiveIdCode id_code);
+ResultCode RegisterArchiveType(std::unique_ptr<FileSys::ArchiveFactory>&& factory,
+                               ArchiveIdCode id_code);
 /**
 * Open a File from an Archive
@@ -100,7 +102,8 @@ ResultCode RegisterArchiveType(std::unique_ptr<FileSys::ArchiveFactory>&& factor
 * @return The opened File object as a Session
 */
 ResultVal<Kernel::SharedPtr<File>> OpenFileFromArchive(ArchiveHandle archive_handle,
-        const FileSys::Path& path, const FileSys::Mode mode);
+                                                       const FileSys::Path& path,
+                                                       const FileSys::Mode mode);
 /**
 * Delete a File from an Archive
@@ -118,8 +121,10 @@ ResultCode DeleteFileFromArchive(ArchiveHandle archive_handle, const FileSys::Pa
 * @param dest_path Path to the File inside of the destination Archive
 * @return Whether rename succeeded
 */
-ResultCode RenameFileBetweenArchives(ArchiveHandle src_archive_handle, const FileSys::Path& src_path,
+ResultCode RenameFileBetweenArchives(ArchiveHandle src_archive_handle,
-                                     ArchiveHandle dest_archive_handle, const FileSys::Path& dest_path);
+                                     const FileSys::Path& src_path,
+                                     ArchiveHandle dest_archive_handle,
+                                     const FileSys::Path& dest_path);
 /**
 * Delete a Directory from an Archive
@@ -136,7 +141,8 @@ ResultCode DeleteDirectoryFromArchive(ArchiveHandle archive_handle, const FileSy
 * @param file_size The size of the new file, filled with zeroes
 * @return File creation result code
 */
-ResultCode CreateFileInArchive(ArchiveHandle archive_handle, const FileSys::Path& path, u64 file_size);
+ResultCode CreateFileInArchive(ArchiveHandle archive_handle, const FileSys::Path& path,
+                               u64 file_size);
 /**
 * Create a Directory from an Archive
@@ -154,8 +160,10 @@ ResultCode CreateDirectoryFromArchive(ArchiveHandle archive_handle, const FileSy
 * @param dest_path Path to the Directory inside of the destination Archive
 * @return Whether rename succeeded
 */
-ResultCode RenameDirectoryBetweenArchives(ArchiveHandle src_archive_handle, const FileSys::Path& src_path,
+ResultCode RenameDirectoryBetweenArchives(ArchiveHandle src_archive_handle,
-                                          ArchiveHandle dest_archive_handle, const FileSys::Path& dest_path);
+                                          const FileSys::Path& src_path,
+                                          ArchiveHandle dest_archive_handle,
+                                          const FileSys::Path& dest_path);
 /**
 * Open a Directory from an Archive
@@ -164,7 +172,7 @@ ResultCode RenameDirectoryBetweenArchives(ArchiveHandle src_archive_handle, cons
 * @return The opened Directory object as a Session
 */
 ResultVal<Kernel::SharedPtr<Directory>> OpenDirectoryFromArchive(ArchiveHandle archive_handle,
-        const FileSys::Path& path);
+                                                                 const FileSys::Path& path);
 /**
 * Get the free space in an Archive
@@ -181,7 +189,8 @@ ResultVal<u64> GetFreeBytesInArchive(ArchiveHandle archive_handle);
 * @param path The path to the archive, if relevant.
 * @return ResultCode 0 on success or the corresponding code on error
 */
-ResultCode FormatArchive(ArchiveIdCode id_code, const FileSys::ArchiveFormatInfo& format_info, const FileSys::Path& path = FileSys::Path());
+ResultCode FormatArchive(ArchiveIdCode id_code, const FileSys::ArchiveFormatInfo& format_info,
+                         const FileSys::Path& path = FileSys::Path());
 /**
 * Retrieves the format info about the archive of the specified type and path.
@@ -190,7 +199,8 @@ ResultCode FormatArchive(ArchiveIdCode id_code, const FileSys::ArchiveFormatInfo
 * @param archive_path The path of the archive, if relevant
 * @return The format info of the archive, or the corresponding error code if failed.
 */
-ResultVal<FileSys::ArchiveFormatInfo> GetArchiveFormatInfo(ArchiveIdCode id_code, FileSys::Path& archive_path);
+ResultVal<FileSys::ArchiveFormatInfo> GetArchiveFormatInfo(ArchiveIdCode id_code,
+                                                           FileSys::Path& archive_path);
 /**
 * Creates a blank SharedExtSaveData archive for the specified extdata ID
@@ -202,7 +212,8 @@ ResultVal<FileSys::ArchiveFormatInfo> GetArchiveFormatInfo(ArchiveIdCode id_code
 * @param format_info Format information about the new archive
 * @return ResultCode 0 on success or the corresponding code on error
 */
-ResultCode CreateExtSaveData(MediaType media_type, u32 high, u32 low, VAddr icon_buffer, u32 icon_size, const FileSys::ArchiveFormatInfo& format_info);
+ResultCode CreateExtSaveData(MediaType media_type, u32 high, u32 low, VAddr icon_buffer,
+                             u32 icon_size, const FileSys::ArchiveFormatInfo& format_info);
 /**
 * Deletes the SharedExtSaveData archive for the specified extdata ID
diff --git a/src/core/hle/service/fs/fs_user.cpp b/src/core/hle/service/fs/fs_user.cpp
index 937868747..a0adad634 100644
--- a/src/core/hle/service/fs/fs_user.cpp
+++ b/src/core/hle/service/fs/fs_user.cpp
@@ -57,14 +57,16 @@ static void OpenFile(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    ArchiveHandle archive_handle = MakeArchiveHandle(cmd_buff[2], cmd_buff[3]);
-    auto filename_type    = static_cast<FileSys::LowPathType>(cmd_buff[4]);
+    auto filename_type = static_cast<FileSys::LowPathType>(cmd_buff[4]);
-    u32 filename_size     = cmd_buff[5];
+    u32 filename_size = cmd_buff[5];
-    FileSys::Mode mode; mode.hex = cmd_buff[6];
+    FileSys::Mode mode;
-    u32 attributes        = cmd_buff[7]; // TODO(Link Mauve): do something with those attributes.
+    mode.hex = cmd_buff[6];
-    u32 filename_ptr      = cmd_buff[9];
+    u32 attributes = cmd_buff[7]; // TODO(Link Mauve): do something with those attributes.
+    u32 filename_ptr = cmd_buff[9];
    FileSys::Path file_path(filename_type, filename_size, filename_ptr);
-    LOG_DEBUG(Service_FS, "path=%s, mode=%d attrs=%u", file_path.DebugStr().c_str(), mode.hex, attributes);
+    LOG_DEBUG(Service_FS, "path=%s, mode=%d attrs=%u", file_path.DebugStr().c_str(), mode.hex,
+              attributes);
    ResultVal<SharedPtr<File>> file_res = OpenFileFromArchive(archive_handle, file_path, mode);
    cmd_buff[1] = file_res.Code().raw;
@@ -98,24 +100,27 @@ static void OpenFile(Service::Interface* self) {
 static void OpenFileDirectly(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
-    auto archive_id       = static_cast<FS::ArchiveIdCode>(cmd_buff[2]);
+    auto archive_id = static_cast<FS::ArchiveIdCode>(cmd_buff[2]);
    auto archivename_type = static_cast<FileSys::LowPathType>(cmd_buff[3]);
-    u32 archivename_size  = cmd_buff[4];
+    u32 archivename_size = cmd_buff[4];
-    auto filename_type    = static_cast<FileSys::LowPathType>(cmd_buff[5]);
+    auto filename_type = static_cast<FileSys::LowPathType>(cmd_buff[5]);
-    u32 filename_size     = cmd_buff[6];
+    u32 filename_size = cmd_buff[6];
-    FileSys::Mode mode; mode.hex = cmd_buff[7];
+    FileSys::Mode mode;
-    u32 attributes        = cmd_buff[8]; // TODO(Link Mauve): do something with those attributes.
+    mode.hex = cmd_buff[7];
-    u32 archivename_ptr   = cmd_buff[10];
+    u32 attributes = cmd_buff[8]; // TODO(Link Mauve): do something with those attributes.
-    u32 filename_ptr      = cmd_buff[12];
+    u32 archivename_ptr = cmd_buff[10];
+    u32 filename_ptr = cmd_buff[12];
    FileSys::Path archive_path(archivename_type, archivename_size, archivename_ptr);
    FileSys::Path file_path(filename_type, filename_size, filename_ptr);
    LOG_DEBUG(Service_FS, "archive_id=0x%08X archive_path=%s file_path=%s, mode=%u attributes=%d",
-              archive_id, archive_path.DebugStr().c_str(), file_path.DebugStr().c_str(), mode.hex, attributes);
+              archive_id, archive_path.DebugStr().c_str(), file_path.DebugStr().c_str(), mode.hex,
+              attributes);
    ResultVal<ArchiveHandle> archive_handle = OpenArchive(archive_id, archive_path);
    if (archive_handle.Failed()) {
-        LOG_ERROR(Service_FS, "failed to get a handle for archive archive_id=0x%08X archive_path=%s",
+        LOG_ERROR(Service_FS,
+                  "failed to get a handle for archive archive_id=0x%08X archive_path=%s",
                  archive_id, archive_path.DebugStr().c_str());
        cmd_buff[1] = archive_handle.Code().raw;
        cmd_buff[3] = 0;
@@ -149,14 +154,14 @@ static void DeleteFile(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    ArchiveHandle archive_handle = MakeArchiveHandle(cmd_buff[2], cmd_buff[3]);
-    auto filename_type    = static_cast<FileSys::LowPathType>(cmd_buff[4]);
+    auto filename_type = static_cast<FileSys::LowPathType>(cmd_buff[4]);
-    u32 filename_size     = cmd_buff[5];
+    u32 filename_size = cmd_buff[5];
-    u32 filename_ptr      = cmd_buff[7];
+    u32 filename_ptr = cmd_buff[7];
    FileSys::Path file_path(filename_type, filename_size, filename_ptr);
-    LOG_DEBUG(Service_FS, "type=%d size=%d data=%s",
+    LOG_DEBUG(Service_FS, "type=%d size=%d data=%s", filename_type, filename_size,
-              filename_type, filename_size, file_path.DebugStr().c_str());
+              file_path.DebugStr().c_str());
    cmd_buff[1] = DeleteFileFromArchive(archive_handle, file_path).raw;
 }
@@ -181,22 +186,26 @@ static void RenameFile(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    ArchiveHandle src_archive_handle = MakeArchiveHandle(cmd_buff[2], cmd_buff[3]);
-    auto src_filename_type     = static_cast<FileSys::LowPathType>(cmd_buff[4]);
+    auto src_filename_type = static_cast<FileSys::LowPathType>(cmd_buff[4]);
-    u32 src_filename_size      = cmd_buff[5];
+    u32 src_filename_size = cmd_buff[5];
-    ArchiveHandle dest_archive_handle = MakeArchiveHandle(cmd_buff[6], cmd_buff[7]);;
+    ArchiveHandle dest_archive_handle = MakeArchiveHandle(cmd_buff[6], cmd_buff[7]);
-    auto dest_filename_type    = static_cast<FileSys::LowPathType>(cmd_buff[8]);
+    ;
-    u32 dest_filename_size     = cmd_buff[9];
+    auto dest_filename_type = static_cast<FileSys::LowPathType>(cmd_buff[8]);
-    u32 src_filename_ptr       = cmd_buff[11];
+    u32 dest_filename_size = cmd_buff[9];
-    u32 dest_filename_ptr      = cmd_buff[13];
+    u32 src_filename_ptr = cmd_buff[11];
+    u32 dest_filename_ptr = cmd_buff[13];
    FileSys::Path src_file_path(src_filename_type, src_filename_size, src_filename_ptr);
    FileSys::Path dest_file_path(dest_filename_type, dest_filename_size, dest_filename_ptr);
-    LOG_DEBUG(Service_FS, "src_type=%d src_size=%d src_data=%s dest_type=%d dest_size=%d dest_data=%s",
+    LOG_DEBUG(Service_FS,
+              "src_type=%d src_size=%d src_data=%s dest_type=%d dest_size=%d dest_data=%s",
              src_filename_type, src_filename_size, src_file_path.DebugStr().c_str(),
              dest_filename_type, dest_filename_size, dest_file_path.DebugStr().c_str());
-    cmd_buff[1] = RenameFileBetweenArchives(src_archive_handle, src_file_path, dest_archive_handle, dest_file_path).raw;
+    cmd_buff[1] = RenameFileBetweenArchives(src_archive_handle, src_file_path, dest_archive_handle,
+                                            dest_file_path)
+                      .raw;
 }
 /*
@@ -214,14 +223,14 @@ static void DeleteDirectory(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    ArchiveHandle archive_handle = MakeArchiveHandle(cmd_buff[2], cmd_buff[3]);
-    auto dirname_type     = static_cast<FileSys::LowPathType>(cmd_buff[4]);
+    auto dirname_type = static_cast<FileSys::LowPathType>(cmd_buff[4]);
-    u32 dirname_size      = cmd_buff[5];
+    u32 dirname_size = cmd_buff[5];
-    u32 dirname_ptr       = cmd_buff[7];
+    u32 dirname_ptr = cmd_buff[7];
    FileSys::Path dir_path(dirname_type, dirname_size, dirname_ptr);
-    LOG_DEBUG(Service_FS, "type=%d size=%d data=%s",
+    LOG_DEBUG(Service_FS, "type=%d size=%d data=%s", dirname_type, dirname_size,
-              dirname_type, dirname_size, dir_path.DebugStr().c_str());
+              dir_path.DebugStr().c_str());
    cmd_buff[1] = DeleteDirectoryFromArchive(archive_handle, dir_path).raw;
 }
@@ -243,14 +252,15 @@ static void CreateFile(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    ArchiveHandle archive_handle = MakeArchiveHandle(cmd_buff[2], cmd_buff[3]);
-    auto filename_type    = static_cast<FileSys::LowPathType>(cmd_buff[4]);
+    auto filename_type = static_cast<FileSys::LowPathType>(cmd_buff[4]);
-    u32 filename_size     = cmd_buff[5];
+    u32 filename_size = cmd_buff[5];
-    u64 file_size         = ((u64)cmd_buff[8] << 32) | cmd_buff[7];
+    u64 file_size = ((u64)cmd_buff[8] << 32) | cmd_buff[7];
-    u32 filename_ptr      = cmd_buff[10];
+    u32 filename_ptr = cmd_buff[10];
    FileSys::Path file_path(filename_type, filename_size, filename_ptr);
-    LOG_DEBUG(Service_FS, "type=%d size=%llu data=%s", filename_type, file_size, file_path.DebugStr().c_str());
+    LOG_DEBUG(Service_FS, "type=%d size=%llu data=%s", filename_type, file_size,
+              file_path.DebugStr().c_str());
    cmd_buff[1] = CreateFileInArchive(archive_handle, file_path, file_size).raw;
 }
@@ -276,7 +286,8 @@ static void CreateDirectory(Service::Interface* self) {
    FileSys::Path dir_path(dirname_type, dirname_size, dirname_ptr);
-    LOG_DEBUG(Service_FS, "type=%d size=%d data=%s", dirname_type, dirname_size, dir_path.DebugStr().c_str());
+    LOG_DEBUG(Service_FS, "type=%d size=%d data=%s", dirname_type, dirname_size,
+              dir_path.DebugStr().c_str());
    cmd_buff[1] = CreateDirectoryFromArchive(archive_handle, dir_path).raw;
 }
@@ -301,22 +312,25 @@ static void RenameDirectory(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    ArchiveHandle src_archive_handle = MakeArchiveHandle(cmd_buff[2], cmd_buff[3]);
-    auto src_dirname_type      = static_cast<FileSys::LowPathType>(cmd_buff[4]);
+    auto src_dirname_type = static_cast<FileSys::LowPathType>(cmd_buff[4]);
-    u32 src_dirname_size       = cmd_buff[5];
+    u32 src_dirname_size = cmd_buff[5];
    ArchiveHandle dest_archive_handle = MakeArchiveHandle(cmd_buff[6], cmd_buff[7]);
-    auto dest_dirname_type     = static_cast<FileSys::LowPathType>(cmd_buff[8]);
+    auto dest_dirname_type = static_cast<FileSys::LowPathType>(cmd_buff[8]);
-    u32 dest_dirname_size      = cmd_buff[9];
+    u32 dest_dirname_size = cmd_buff[9];
-    u32 src_dirname_ptr        = cmd_buff[11];
+    u32 src_dirname_ptr = cmd_buff[11];
-    u32 dest_dirname_ptr       = cmd_buff[13];
+    u32 dest_dirname_ptr = cmd_buff[13];
    FileSys::Path src_dir_path(src_dirname_type, src_dirname_size, src_dirname_ptr);
    FileSys::Path dest_dir_path(dest_dirname_type, dest_dirname_size, dest_dirname_ptr);
-    LOG_DEBUG(Service_FS, "src_type=%d src_size=%d src_data=%s dest_type=%d dest_size=%d dest_data=%s",
+    LOG_DEBUG(Service_FS,
+              "src_type=%d src_size=%d src_data=%s dest_type=%d dest_size=%d dest_data=%s",
              src_dirname_type, src_dirname_size, src_dir_path.DebugStr().c_str(),
              dest_dirname_type, dest_dirname_size, dest_dir_path.DebugStr().c_str());
-    cmd_buff[1] = RenameDirectoryBetweenArchives(src_archive_handle, src_dir_path, dest_archive_handle, dest_dir_path).raw;
+    cmd_buff[1] = RenameDirectoryBetweenArchives(src_archive_handle, src_dir_path,
+                                                 dest_archive_handle, dest_dir_path)
+                      .raw;
 }
 /**
@@ -342,7 +356,8 @@ static void OpenDirectory(Service::Interface* self) {
    FileSys::Path dir_path(dirname_type, dirname_size, dirname_ptr);
-    LOG_DEBUG(Service_FS, "type=%d size=%d data=%s", dirname_type, dirname_size, dir_path.DebugStr().c_str());
+    LOG_DEBUG(Service_FS, "type=%d size=%d data=%s", dirname_type, dirname_size,
+              dir_path.DebugStr().c_str());
    ResultVal<SharedPtr<Directory>> dir_res = OpenDirectoryFromArchive(archive_handle, dir_path);
    cmd_buff[1] = dir_res.Code().raw;
@@ -370,13 +385,14 @@ static void OpenDirectory(Service::Interface* self) {
 static void OpenArchive(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
-    auto archive_id       = static_cast<FS::ArchiveIdCode>(cmd_buff[1]);
+    auto archive_id = static_cast<FS::ArchiveIdCode>(cmd_buff[1]);
    auto archivename_type = static_cast<FileSys::LowPathType>(cmd_buff[2]);
-    u32 archivename_size  = cmd_buff[3];
+    u32 archivename_size = cmd_buff[3];
-    u32 archivename_ptr   = cmd_buff[5];
+    u32 archivename_ptr = cmd_buff[5];
    FileSys::Path archive_path(archivename_type, archivename_size, archivename_ptr);
-    LOG_DEBUG(Service_FS, "archive_id=0x%08X archive_path=%s", archive_id, archive_path.DebugStr().c_str());
+    LOG_DEBUG(Service_FS, "archive_id=0x%08X archive_path=%s", archive_id,
+              archive_path.DebugStr().c_str());
    ResultVal<ArchiveHandle> handle = OpenArchive(archive_id, archive_path);
    cmd_buff[1] = handle.Code().raw;
@@ -385,7 +401,8 @@ static void OpenArchive(Service::Interface* self) {
        cmd_buff[3] = (*handle >> 32) & 0xFFFFFFFF;
    } else {
        cmd_buff[2] = cmd_buff[3] = 0;
-        LOG_ERROR(Service_FS, "failed to get a handle for archive archive_id=0x%08X archive_path=%s",
+        LOG_ERROR(Service_FS,
+                  "failed to get a handle for archive archive_id=0x%08X archive_path=%s",
                  archive_id, archive_path.DebugStr().c_str());
    }
 }
@@ -471,7 +488,8 @@ static void FormatSaveData(Service::Interface* self) {
    if (archive_id != FS::ArchiveIdCode::SaveData) {
        LOG_ERROR(Service_FS, "tried to format an archive different than SaveData, %u", archive_id);
        cmd_buff[1] = ResultCode(ErrorDescription::FS_InvalidPath, ErrorModule::FS,
-                                 ErrorSummary::InvalidArgument, ErrorLevel::Usage).raw;
+                                 ErrorSummary::InvalidArgument, ErrorLevel::Usage)
+                          .raw;
        return;
    }
@@ -571,18 +589,21 @@ static void CreateExtSaveData(Service::Interface* self) {
    u32 icon_size = cmd_buff[9];
    VAddr icon_buffer = cmd_buff[11];
-    LOG_WARNING(Service_FS, "(STUBBED) savedata_high=%08X savedata_low=%08X cmd_buff[3]=%08X "
+    LOG_WARNING(
-            "cmd_buff[4]=%08X cmd_buff[5]=%08X cmd_buff[6]=%08X cmd_buff[7]=%08X cmd_buff[8]=%08X "
+        Service_FS,
-            "icon_size=%08X icon_descriptor=%08X icon_buffer=%08X", save_high, save_low,
+        "(STUBBED) savedata_high=%08X savedata_low=%08X cmd_buff[3]=%08X "
-            cmd_buff[3], cmd_buff[4], cmd_buff[5], cmd_buff[6], cmd_buff[7], cmd_buff[8], icon_size,
+        "cmd_buff[4]=%08X cmd_buff[5]=%08X cmd_buff[6]=%08X cmd_buff[7]=%08X cmd_buff[8]=%08X "
-            cmd_buff[10], icon_buffer);
+        "icon_size=%08X icon_descriptor=%08X icon_buffer=%08X",
+        save_high, save_low, cmd_buff[3], cmd_buff[4], cmd_buff[5], cmd_buff[6], cmd_buff[7],
+        cmd_buff[8], icon_size, cmd_buff[10], icon_buffer);
    FileSys::ArchiveFormatInfo format_info;
    format_info.number_directories = cmd_buff[5];
    format_info.number_files = cmd_buff[6];
    format_info.duplicate_data = false;
    format_info.total_size = 0;
-    cmd_buff[1] = CreateExtSaveData(media_type, save_high, save_low, icon_buffer, icon_size, format_info).raw;
+    cmd_buff[1] =
+        CreateExtSaveData(media_type, save_high, save_low, icon_buffer, icon_size, format_info).raw;
 }
 /**
@@ -604,7 +625,7 @@ static void DeleteExtSaveData(Service::Interface* self) {
    u32 unknown = cmd_buff[4]; // TODO(Subv): Figure out what this is
    LOG_WARNING(Service_FS, "(STUBBED) save_low=%08X save_high=%08X media_type=%08X unknown=%08X",
-            save_low, save_high, cmd_buff[1] & 0xFF, unknown);
+                save_low, save_high, cmd_buff[1] & 0xFF, unknown);
    cmd_buff[1] = DeleteExtSaveData(media_type, save_high, save_low).raw;
 }
@@ -662,10 +683,13 @@ static void CreateSystemSaveData(Service::Interface* self) {
    u32 savedata_high = cmd_buff[1];
    u32 savedata_low = cmd_buff[2];
-    LOG_WARNING(Service_FS, "(STUBBED) savedata_high=%08X savedata_low=%08X cmd_buff[3]=%08X "
+    LOG_WARNING(
-            "cmd_buff[4]=%08X cmd_buff[5]=%08X cmd_buff[6]=%08X cmd_buff[7]=%08X cmd_buff[8]=%08X "
+        Service_FS,
-            "cmd_buff[9]=%08X", savedata_high, savedata_low, cmd_buff[3], cmd_buff[4], cmd_buff[5],
+        "(STUBBED) savedata_high=%08X savedata_low=%08X cmd_buff[3]=%08X "
-            cmd_buff[6], cmd_buff[7], cmd_buff[8], cmd_buff[9]);
+        "cmd_buff[4]=%08X cmd_buff[5]=%08X cmd_buff[6]=%08X cmd_buff[7]=%08X cmd_buff[8]=%08X "
+        "cmd_buff[9]=%08X",
+        savedata_high, savedata_low, cmd_buff[3], cmd_buff[4], cmd_buff[5], cmd_buff[6],
+        cmd_buff[7], cmd_buff[8], cmd_buff[9]);
    cmd_buff[1] = CreateSystemSaveData(savedata_high, savedata_low).raw;
 }
@@ -692,10 +716,13 @@ static void CreateLegacySystemSaveData(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    u32 savedata_id = cmd_buff[1];
-    LOG_WARNING(Service_FS, "(STUBBED) savedata_id=%08X cmd_buff[3]=%08X "
+    LOG_WARNING(
-            "cmd_buff[4]=%08X cmd_buff[5]=%08X cmd_buff[6]=%08X cmd_buff[7]=%08X cmd_buff[8]=%08X "
+        Service_FS,
-            "cmd_buff[9]=%08X", savedata_id, cmd_buff[3], cmd_buff[4], cmd_buff[5],
+        "(STUBBED) savedata_id=%08X cmd_buff[3]=%08X "
-            cmd_buff[6], cmd_buff[7], cmd_buff[8], cmd_buff[9]);
+        "cmd_buff[4]=%08X cmd_buff[5]=%08X cmd_buff[6]=%08X cmd_buff[7]=%08X cmd_buff[8]=%08X "
+        "cmd_buff[9]=%08X",
+        savedata_id, cmd_buff[3], cmd_buff[4], cmd_buff[5], cmd_buff[6], cmd_buff[7], cmd_buff[8],
+        cmd_buff[9]);
    cmd_buff[0] = IPC::MakeHeader(0x810, 0x1, 0);
    // With this command, the SystemSaveData always has save_high = 0 (Always created in the NAND)
@@ -721,8 +748,8 @@ static void InitializeWithSdkVersion(Service::Interface* self) {
    cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_WARNING(Service_FS, "(STUBBED) called unk1=0x%08X, unk2=0x%08X, unk3=0x%08X",
+    LOG_WARNING(Service_FS, "(STUBBED) called unk1=0x%08X, unk2=0x%08X, unk3=0x%08X", unk1, unk2,
-                unk1, unk2, unk3);
+                unk3);
 }
 /**
@@ -834,115 +861,114 @@ static void GetFormatInfo(Service::Interface* self) {
 }
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x000100C6, nullptr,                  "Dummy1"},
+    {0x000100C6, nullptr, "Dummy1"},
-    {0x040100C4, nullptr,                  "Control"},
+    {0x040100C4, nullptr, "Control"},
-    {0x08010002, Initialize,               "Initialize"},
+    {0x08010002, Initialize, "Initialize"},
-    {0x080201C2, OpenFile,                 "OpenFile"},
+    {0x080201C2, OpenFile, "OpenFile"},
-    {0x08030204, OpenFileDirectly,         "OpenFileDirectly"},
+    {0x08030204, OpenFileDirectly, "OpenFileDirectly"},
-    {0x08040142, DeleteFile,               "DeleteFile"},
+    {0x08040142, DeleteFile, "DeleteFile"},
-    {0x08050244, RenameFile,               "RenameFile"},
+    {0x08050244, RenameFile, "RenameFile"},
-    {0x08060142, DeleteDirectory,          "DeleteDirectory"},
+    {0x08060142, DeleteDirectory, "DeleteDirectory"},
-    {0x08070142, nullptr,                  "DeleteDirectoryRecursively"},
+    {0x08070142, nullptr, "DeleteDirectoryRecursively"},
-    {0x08080202, CreateFile,               "CreateFile"},
+    {0x08080202, CreateFile, "CreateFile"},
-    {0x08090182, CreateDirectory,          "CreateDirectory"},
+    {0x08090182, CreateDirectory, "CreateDirectory"},
-    {0x080A0244, RenameDirectory,          "RenameDirectory"},
+    {0x080A0244, RenameDirectory, "RenameDirectory"},
-    {0x080B0102, OpenDirectory,            "OpenDirectory"},
+    {0x080B0102, OpenDirectory, "OpenDirectory"},
-    {0x080C00C2, OpenArchive,              "OpenArchive"},
+    {0x080C00C2, OpenArchive, "OpenArchive"},
-    {0x080D0144, nullptr,                  "ControlArchive"},
+    {0x080D0144, nullptr, "ControlArchive"},
-    {0x080E0080, CloseArchive,             "CloseArchive"},
+    {0x080E0080, CloseArchive, "CloseArchive"},
-    {0x080F0180, FormatThisUserSaveData,   "FormatThisUserSaveData"},
+    {0x080F0180, FormatThisUserSaveData, "FormatThisUserSaveData"},
    {0x08100200, CreateLegacySystemSaveData, "CreateLegacySystemSaveData"},
-    {0x08110040, nullptr,                  "DeleteSystemSaveData"},
+    {0x08110040, nullptr, "DeleteSystemSaveData"},
-    {0x08120080, GetFreeBytes,             "GetFreeBytes"},
+    {0x08120080, GetFreeBytes, "GetFreeBytes"},
-    {0x08130000, nullptr,                  "GetCardType"},
+    {0x08130000, nullptr, "GetCardType"},
-    {0x08140000, nullptr,                  "GetSdmcArchiveResource"},
+    {0x08140000, nullptr, "GetSdmcArchiveResource"},
-    {0x08150000, nullptr,                  "GetNandArchiveResource"},
+    {0x08150000, nullptr, "GetNandArchiveResource"},
-    {0x08160000, nullptr,                  "GetSdmcFatfsError"},
+    {0x08160000, nullptr, "GetSdmcFatfsError"},
-    {0x08170000, IsSdmcDetected,           "IsSdmcDetected"},
+    {0x08170000, IsSdmcDetected, "IsSdmcDetected"},
-    {0x08180000, IsSdmcWriteable,          "IsSdmcWritable"},
+    {0x08180000, IsSdmcWriteable, "IsSdmcWritable"},
-    {0x08190042, nullptr,                  "GetSdmcCid"},
+    {0x08190042, nullptr, "GetSdmcCid"},
-    {0x081A0042, nullptr,                  "GetNandCid"},
+    {0x081A0042, nullptr, "GetNandCid"},
-    {0x081B0000, nullptr,                  "GetSdmcSpeedInfo"},
+    {0x081B0000, nullptr, "GetSdmcSpeedInfo"},
-    {0x081C0000, nullptr,                  "GetNandSpeedInfo"},
+    {0x081C0000, nullptr, "GetNandSpeedInfo"},
-    {0x081D0042, nullptr,                  "GetSdmcLog"},
+    {0x081D0042, nullptr, "GetSdmcLog"},
-    {0x081E0042, nullptr,                  "GetNandLog"},
+    {0x081E0042, nullptr, "GetNandLog"},
-    {0x081F0000, nullptr,                  "ClearSdmcLog"},
+    {0x081F0000, nullptr, "ClearSdmcLog"},
-    {0x08200000, nullptr,                  "ClearNandLog"},
+    {0x08200000, nullptr, "ClearNandLog"},
-    {0x08210000, CardSlotIsInserted,       "CardSlotIsInserted"},
+    {0x08210000, CardSlotIsInserted, "CardSlotIsInserted"},
-    {0x08220000, nullptr,                  "CardSlotPowerOn"},
+    {0x08220000, nullptr, "CardSlotPowerOn"},
-    {0x08230000, nullptr,                  "CardSlotPowerOff"},
+    {0x08230000, nullptr, "CardSlotPowerOff"},
-    {0x08240000, nullptr,                  "CardSlotGetCardIFPowerStatus"},
+    {0x08240000, nullptr, "CardSlotGetCardIFPowerStatus"},
-    {0x08250040, nullptr,                  "CardNorDirectCommand"},
+    {0x08250040, nullptr, "CardNorDirectCommand"},
-    {0x08260080, nullptr,                  "CardNorDirectCommandWithAddress"},
+    {0x08260080, nullptr, "CardNorDirectCommandWithAddress"},
-    {0x08270082, nullptr,                  "CardNorDirectRead"},
+    {0x08270082, nullptr, "CardNorDirectRead"},
-    {0x082800C2, nullptr,                  "CardNorDirectReadWithAddress"},
+    {0x082800C2, nullptr, "CardNorDirectReadWithAddress"},
-    {0x08290082, nullptr,                  "CardNorDirectWrite"},
+    {0x08290082, nullptr, "CardNorDirectWrite"},
-    {0x082A00C2, nullptr,                  "CardNorDirectWriteWithAddress"},
+    {0x082A00C2, nullptr, "CardNorDirectWriteWithAddress"},
-    {0x082B00C2, nullptr,                  "CardNorDirectRead_4xIO"},
+    {0x082B00C2, nullptr, "CardNorDirectRead_4xIO"},
-    {0x082C0082, nullptr,                  "CardNorDirectCpuWriteWithoutVerify"},
+    {0x082C0082, nullptr, "CardNorDirectCpuWriteWithoutVerify"},
-    {0x082D0040, nullptr,                  "CardNorDirectSectorEraseWithoutVerify"},
+    {0x082D0040, nullptr, "CardNorDirectSectorEraseWithoutVerify"},
-    {0x082E0040, nullptr,                  "GetProductInfo"},
+    {0x082E0040, nullptr, "GetProductInfo"},
-    {0x082F0040, nullptr,                  "GetProgramLaunchInfo"},
+    {0x082F0040, nullptr, "GetProgramLaunchInfo"},
-    {0x08300182, nullptr,                  "CreateExtSaveData"},
+    {0x08300182, nullptr, "CreateExtSaveData"},
-    {0x08310180, nullptr,                  "CreateSharedExtSaveData"},
+    {0x08310180, nullptr, "CreateSharedExtSaveData"},
-    {0x08320102, nullptr,                  "ReadExtSaveDataIcon"},
+    {0x08320102, nullptr, "ReadExtSaveDataIcon"},
-    {0x08330082, nullptr,                  "EnumerateExtSaveData"},
+    {0x08330082, nullptr, "EnumerateExtSaveData"},
-    {0x08340082, nullptr,                  "EnumerateSharedExtSaveData"},
+    {0x08340082, nullptr, "EnumerateSharedExtSaveData"},
-    {0x08350080, nullptr,                  "DeleteExtSaveData"},
+    {0x08350080, nullptr, "DeleteExtSaveData"},
-    {0x08360080, nullptr,                  "DeleteSharedExtSaveData"},
+    {0x08360080, nullptr, "DeleteSharedExtSaveData"},
-    {0x08370040, nullptr,                  "SetCardSpiBaudRate"},
+    {0x08370040, nullptr, "SetCardSpiBaudRate"},
-    {0x08380040, nullptr,                  "SetCardSpiBusMode"},
+    {0x08380040, nullptr, "SetCardSpiBusMode"},
-    {0x08390000, nullptr,                  "SendInitializeInfoTo9"},
+    {0x08390000, nullptr, "SendInitializeInfoTo9"},
-    {0x083A0100, nullptr,                  "GetSpecialContentIndex"},
+    {0x083A0100, nullptr, "GetSpecialContentIndex"},
-    {0x083B00C2, nullptr,                  "GetLegacyRomHeader"},
+    {0x083B00C2, nullptr, "GetLegacyRomHeader"},
-    {0x083C00C2, nullptr,                  "GetLegacyBannerData"},
+    {0x083C00C2, nullptr, "GetLegacyBannerData"},
-    {0x083D0100, nullptr,                  "CheckAuthorityToAccessExtSaveData"},
+    {0x083D0100, nullptr, "CheckAuthorityToAccessExtSaveData"},
-    {0x083E00C2, nullptr,                  "QueryTotalQuotaSize"},
+    {0x083E00C2, nullptr, "QueryTotalQuotaSize"},
-    {0x083F00C0, nullptr,                  "GetExtDataBlockSize"},
+    {0x083F00C0, nullptr, "GetExtDataBlockSize"},
-    {0x08400040, nullptr,                  "AbnegateAccessRight"},
+    {0x08400040, nullptr, "AbnegateAccessRight"},
-    {0x08410000, nullptr,                  "DeleteSdmcRoot"},
+    {0x08410000, nullptr, "DeleteSdmcRoot"},
-    {0x08420040, nullptr,                  "DeleteAllExtSaveDataOnNand"},
+    {0x08420040, nullptr, "DeleteAllExtSaveDataOnNand"},
-    {0x08430000, nullptr,                  "InitializeCtrFileSystem"},
+    {0x08430000, nullptr, "InitializeCtrFileSystem"},
-    {0x08440000, nullptr,                  "CreateSeed"},
+    {0x08440000, nullptr, "CreateSeed"},
-    {0x084500C2, GetFormatInfo,            "GetFormatInfo"},
+    {0x084500C2, GetFormatInfo, "GetFormatInfo"},
-    {0x08460102, nullptr,                  "GetLegacyRomHeader2"},
+    {0x08460102, nullptr, "GetLegacyRomHeader2"},
-    {0x08470180, nullptr,                  "FormatCtrCardUserSaveData"},
+    {0x08470180, nullptr, "FormatCtrCardUserSaveData"},
-    {0x08480042, nullptr,                  "GetSdmcCtrRootPath"},
+    {0x08480042, nullptr, "GetSdmcCtrRootPath"},
-    {0x08490040, GetArchiveResource,       "GetArchiveResource"},
+    {0x08490040, GetArchiveResource, "GetArchiveResource"},
-    {0x084A0002, nullptr,                  "ExportIntegrityVerificationSeed"},
+    {0x084A0002, nullptr, "ExportIntegrityVerificationSeed"},
-    {0x084B0002, nullptr,                  "ImportIntegrityVerificationSeed"},
+    {0x084B0002, nullptr, "ImportIntegrityVerificationSeed"},
-    {0x084C0242, FormatSaveData,           "FormatSaveData"},
+    {0x084C0242, FormatSaveData, "FormatSaveData"},
-    {0x084D0102, nullptr,                  "GetLegacySubBannerData"},
+    {0x084D0102, nullptr, "GetLegacySubBannerData"},
-    {0x084E0342, nullptr,                  "UpdateSha256Context"},
+    {0x084E0342, nullptr, "UpdateSha256Context"},
-    {0x084F0102, nullptr,                  "ReadSpecialFile"},
+    {0x084F0102, nullptr, "ReadSpecialFile"},
-    {0x08500040, nullptr,                  "GetSpecialFileSize"},
+    {0x08500040, nullptr, "GetSpecialFileSize"},
-    {0x08510242, CreateExtSaveData,        "CreateExtSaveData"},
+    {0x08510242, CreateExtSaveData, "CreateExtSaveData"},
-    {0x08520100, DeleteExtSaveData,        "DeleteExtSaveData"},
+    {0x08520100, DeleteExtSaveData, "DeleteExtSaveData"},
-    {0x08530142, nullptr,                  "ReadExtSaveDataIcon"},
+    {0x08530142, nullptr, "ReadExtSaveDataIcon"},
-    {0x085400C0, nullptr,                  "GetExtDataBlockSize"},
+    {0x085400C0, nullptr, "GetExtDataBlockSize"},
-    {0x08550102, nullptr,                  "EnumerateExtSaveData"},
+    {0x08550102, nullptr, "EnumerateExtSaveData"},
-    {0x08560240, CreateSystemSaveData,     "CreateSystemSaveData"},
+    {0x08560240, CreateSystemSaveData, "CreateSystemSaveData"},
-    {0x08570080, DeleteSystemSaveData,     "DeleteSystemSaveData"},
+    {0x08570080, DeleteSystemSaveData, "DeleteSystemSaveData"},
-    {0x08580000, nullptr,                  "StartDeviceMoveAsSource"},
+    {0x08580000, nullptr, "StartDeviceMoveAsSource"},
-    {0x08590200, nullptr,                  "StartDeviceMoveAsDestination"},
+    {0x08590200, nullptr, "StartDeviceMoveAsDestination"},
-    {0x085A00C0, nullptr,                  "SetArchivePriority"},
+    {0x085A00C0, nullptr, "SetArchivePriority"},
-    {0x085B0080, nullptr,                  "GetArchivePriority"},
+    {0x085B0080, nullptr, "GetArchivePriority"},
-    {0x085C00C0, nullptr,                  "SetCtrCardLatencyParameter"},
+    {0x085C00C0, nullptr, "SetCtrCardLatencyParameter"},
-    {0x085D01C0, nullptr,                  "SetFsCompatibilityInfo"},
+    {0x085D01C0, nullptr, "SetFsCompatibilityInfo"},
-    {0x085E0040, nullptr,                  "ResetCardCompatibilityParameter"},
+    {0x085E0040, nullptr, "ResetCardCompatibilityParameter"},
-    {0x085F0040, nullptr,                  "SwitchCleanupInvalidSaveData"},
+    {0x085F0040, nullptr, "SwitchCleanupInvalidSaveData"},
-    {0x08600042, nullptr,                  "EnumerateSystemSaveData"},
+    {0x08600042, nullptr, "EnumerateSystemSaveData"},
    {0x08610042, InitializeWithSdkVersion, "InitializeWithSdkVersion"},
-    {0x08620040, SetPriority,              "SetPriority"},
+    {0x08620040, SetPriority, "SetPriority"},
-    {0x08630000, GetPriority,              "GetPriority"},
+    {0x08630000, GetPriority, "GetPriority"},
-    {0x08640000, nullptr,                  "GetNandInfo"},
+    {0x08640000, nullptr, "GetNandInfo"},
-    {0x08650140, nullptr,                  "SetSaveDataSecureValue"},
+    {0x08650140, nullptr, "SetSaveDataSecureValue"},
-    {0x086600C0, nullptr,                  "GetSaveDataSecureValue"},
+    {0x086600C0, nullptr, "GetSaveDataSecureValue"},
-    {0x086700C4, nullptr,                  "ControlSecureSave"},
+    {0x086700C4, nullptr, "ControlSecureSave"},
-    {0x08680000, nullptr,                  "GetMediaType"},
+    {0x08680000, nullptr, "GetMediaType"},
-    {0x08690000, nullptr,                  "GetNandEraseCount"},
+    {0x08690000, nullptr, "GetNandEraseCount"},
-    {0x086A0082, nullptr,                  "ReadNandReport"}
+    {0x086A0082, nullptr, "ReadNandReport"}};
-};
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Interface class
diff --git a/src/core/hle/service/gsp_gpu.cpp b/src/core/hle/service/gsp_gpu.cpp
index ec565f46d..b273aac47 100644
--- a/src/core/hle/service/gsp_gpu.cpp
+++ b/src/core/hle/service/gsp_gpu.cpp
@@ -5,16 +5,16 @@
 #include "common/bit_field.h"
 #include "common/microprofile.h"
-#include "core/memory.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/shared_memory.h"
 #include "core/hle/result.h"
-#include "core/hw/hw.h"
 #include "core/hw/gpu.h"
+#include "core/hw/hw.h"
 #include "core/hw/lcd.h"
+#include "core/memory.h"
-#include "video_core/gpu_debugger.h"
 #include "video_core/debug_utils/debug_utils.h"
+#include "video_core/gpu_debugger.h"
 #include "gsp_gpu.h"
@@ -29,12 +29,16 @@ const static u32 REGS_BEGIN = 0x1EB00000;
 namespace GSP_GPU {
-const ResultCode ERR_GSP_REGS_OUTOFRANGE_OR_MISALIGNED(ErrorDescription::OutofRangeOrMisalignedAddress, ErrorModule::GX,
+const ResultCode
-    ErrorSummary::InvalidArgument, ErrorLevel::Usage); // 0xE0E02A01
+    ERR_GSP_REGS_OUTOFRANGE_OR_MISALIGNED(ErrorDescription::OutofRangeOrMisalignedAddress,
+                                          ErrorModule::GX, ErrorSummary::InvalidArgument,
+                                          ErrorLevel::Usage); // 0xE0E02A01
 const ResultCode ERR_GSP_REGS_MISALIGNED(ErrorDescription::MisalignedSize, ErrorModule::GX,
-    ErrorSummary::InvalidArgument, ErrorLevel::Usage); // 0xE0E02BF2
+                                         ErrorSummary::InvalidArgument,
+                                         ErrorLevel::Usage); // 0xE0E02BF2
 const ResultCode ERR_GSP_REGS_INVALID_SIZE(ErrorDescription::InvalidSize, ErrorModule::GX,
-    ErrorSummary::InvalidArgument, ErrorLevel::Usage); // 0xE0E02BEC
+                                           ErrorSummary::InvalidArgument,
+                                           ErrorLevel::Usage); // 0xE0E02BEC
 /// Event triggered when GSP interrupt has been signalled
 Kernel::SharedPtr<Kernel::Event> g_interrupt_event;
@@ -73,7 +77,8 @@ static inline InterruptRelayQueue* GetInterruptRelayQueue(u32 thread_id) {
 * @param data Data to be written
 */
 static void WriteSingleHWReg(u32 base_address, u32 data) {
-    DEBUG_ASSERT_MSG((base_address & 3) == 0 && base_address < 0x420000, "Write address out of range or misaligned");
+    DEBUG_ASSERT_MSG((base_address & 3) == 0 && base_address < 0x420000,
+                     "Write address out of range or misaligned");
    HW::Write<u32>(base_address + REGS_BEGIN, data);
 }
@@ -90,7 +95,8 @@ static ResultCode WriteHWRegs(u32 base_address, u32 size_in_bytes, VAddr data_va
    const u32 max_size_in_bytes = 0x80;
    if (base_address & 3 || base_address >= 0x420000) {
-        LOG_ERROR(Service_GSP, "Write address was out of range or misaligned! (address=0x%08x, size=0x%08x)",
+        LOG_ERROR(Service_GSP,
+                  "Write address was out of range or misaligned! (address=0x%08x, size=0x%08x)",
                  base_address, size_in_bytes);
        return ERR_GSP_REGS_OUTOFRANGE_OR_MISALIGNED;
    } else if (size_in_bytes <= max_size_in_bytes) {
@@ -124,12 +130,14 @@ static ResultCode WriteHWRegs(u32 base_address, u32 size_in_bytes, VAddr data_va
 * @param masks A pointer to the masks
 * @return RESULT_SUCCESS if the parameters are valid, error code otherwise
 */
-static ResultCode WriteHWRegsWithMask(u32 base_address, u32 size_in_bytes, VAddr data_vaddr, VAddr masks_vaddr) {
+static ResultCode WriteHWRegsWithMask(u32 base_address, u32 size_in_bytes, VAddr data_vaddr,
+                                      VAddr masks_vaddr) {
    // This magic number is verified to be done by the gsp module
    const u32 max_size_in_bytes = 0x80;
    if (base_address & 3 || base_address >= 0x420000) {
-        LOG_ERROR(Service_GSP, "Write address was out of range or misaligned! (address=0x%08x, size=0x%08x)",
+        LOG_ERROR(Service_GSP,
+                  "Write address was out of range or misaligned! (address=0x%08x, size=0x%08x)",
                  base_address, size_in_bytes);
        return ERR_GSP_REGS_OUTOFRANGE_OR_MISALIGNED;
    } else if (size_in_bytes <= max_size_in_bytes) {
@@ -214,7 +222,8 @@ static void ReadHWRegs(Service::Interface* self) {
    // TODO: Return proper error codes
    if (reg_addr + size >= 0x420000) {
-        LOG_ERROR(Service_GSP, "Read address out of range! (address=0x%08x, size=0x%08x)", reg_addr, size);
+        LOG_ERROR(Service_GSP, "Read address out of range! (address=0x%08x, size=0x%08x)", reg_addr,
+                  size);
        return;
    }
@@ -243,22 +252,34 @@ ResultCode SetBufferSwap(u32 screen_id, const FrameBufferInfo& info) {
    PAddr phys_address_left = Memory::VirtualToPhysicalAddress(info.address_left);
    PAddr phys_address_right = Memory::VirtualToPhysicalAddress(info.address_right);
    if (info.active_fb == 0) {
-        WriteSingleHWReg(base_address + 4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].address_left1)),
+        WriteSingleHWReg(
-                         phys_address_left);
+            base_address +
-        WriteSingleHWReg(base_address + 4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].address_right1)),
+                4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].address_left1)),
-                         phys_address_right);
+            phys_address_left);
+        WriteSingleHWReg(
+            base_address +
+                4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].address_right1)),
+            phys_address_right);
    } else {
-        WriteSingleHWReg(base_address + 4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].address_left2)),
+        WriteSingleHWReg(
-                         phys_address_left);
+            base_address +
-        WriteSingleHWReg(base_address + 4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].address_right2)),
+                4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].address_left2)),
-                         phys_address_right);
+            phys_address_left);
+        WriteSingleHWReg(
+            base_address +
+                4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].address_right2)),
+            phys_address_right);
    }
-    WriteSingleHWReg(base_address + 4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].stride)),
+    WriteSingleHWReg(base_address +
+                         4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].stride)),
                     info.stride);
-    WriteSingleHWReg(base_address + 4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].color_format)),
+    WriteSingleHWReg(
-                     info.format);
+        base_address +
-    WriteSingleHWReg(base_address + 4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].active_fb)),
+            4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].color_format)),
-                     info.shown_fb);
+        info.format);
+    WriteSingleHWReg(
+        base_address + 4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].active_fb)),
+        info.shown_fb);
    if (Pica::g_debug_context)
        Pica::g_debug_context->OnEvent(Pica::DebugContext::Event::BufferSwapped, nullptr);
@@ -305,15 +326,15 @@ static void SetBufferSwap(Service::Interface* self) {
 static void FlushDataCache(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    u32 address = cmd_buff[1];
-    u32 size    = cmd_buff[2];
+    u32 size = cmd_buff[2];
    u32 process = cmd_buff[4];
    // TODO(purpasmart96): Verify return header on HW
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
-    LOG_DEBUG(Service_GSP, "(STUBBED) called address=0x%08X, size=0x%08X, process=0x%08X",
+    LOG_DEBUG(Service_GSP, "(STUBBED) called address=0x%08X, size=0x%08X, process=0x%08X", address,
-              address, size, process);
+              size, process);
 }
 /**
@@ -356,11 +377,12 @@ static void RegisterInterruptRelayQueue(Service::Interface* self) {
        // This specific code is required for a successful initialization, rather than 0
        first_initialization = false;
        cmd_buff[1] = ResultCode(ErrorDescription::GPU_FirstInitialization, ErrorModule::GX,
-                                 ErrorSummary::Success, ErrorLevel::Success).raw;
+                                 ErrorSummary::Success, ErrorLevel::Success)
+                          .raw;
    } else {
        cmd_buff[1] = RESULT_SUCCESS.raw;
    }
-    cmd_buff[2] = g_thread_id++; // Thread ID
+    cmd_buff[2] = g_thread_id++;                                             // Thread ID
    cmd_buff[4] = Kernel::g_handle_table.Create(g_shared_memory).MoveFrom(); // GSP shared memory
    g_interrupt_event->Signal(); // TODO(bunnei): Is this correct?
@@ -416,7 +438,8 @@ void SignalInterrupt(InterruptId interrupt_id) {
        // Update framebuffer information if requested
        // TODO(yuriks): Confirm where this code should be called. It is definitely updated without
        //               executing any GSP commands, only waiting on the event.
-        int screen_id = (interrupt_id == InterruptId::PDC0) ? 0 : (interrupt_id == InterruptId::PDC1) ? 1 : -1;
+        int screen_id =
+            (interrupt_id == InterruptId::PDC0) ? 0 : (interrupt_id == InterruptId::PDC1) ? 1 : -1;
        if (screen_id != -1) {
            FrameBufferUpdate* info = GetFrameBufferInfo(thread_id, screen_id);
            if (info->is_dirty) {
@@ -440,25 +463,27 @@ static void ExecuteCommand(const Command& command, u32 thread_id) {
    switch (command.id) {
    // GX request DMA - typically used for copying memory from GSP heap to VRAM
-    case CommandId::REQUEST_DMA:
+    case CommandId::REQUEST_DMA: {
-    {
        MICROPROFILE_SCOPE(GPU_GSP_DMA);
-        // TODO: Consider attempting rasterizer-accelerated surface blit if that usage is ever possible/likely
+        // TODO: Consider attempting rasterizer-accelerated surface blit if that usage is ever
-        Memory::RasterizerFlushRegion(Memory::VirtualToPhysicalAddress(command.dma_request.source_address),
+        // possible/likely
-                            command.dma_request.size);
+        Memory::RasterizerFlushRegion(
-        Memory::RasterizerFlushAndInvalidateRegion(Memory::VirtualToPhysicalAddress(command.dma_request.dest_address),
+            Memory::VirtualToPhysicalAddress(command.dma_request.source_address),
-                            command.dma_request.size);
+            command.dma_request.size);
+        Memory::RasterizerFlushAndInvalidateRegion(
+            Memory::VirtualToPhysicalAddress(command.dma_request.dest_address),
+            command.dma_request.size);
        // TODO(Subv): These memory accesses should not go through the application's memory mapping.
        // They should go through the GSP module's memory mapping.
-        Memory::CopyBlock(command.dma_request.dest_address, command.dma_request.source_address, command.dma_request.size);
+        Memory::CopyBlock(command.dma_request.dest_address, command.dma_request.source_address,
+                          command.dma_request.size);
        SignalInterrupt(InterruptId::DMA);
        break;
    }
    // TODO: This will need some rework in the future. (why?)
-    case CommandId::SUBMIT_GPU_CMDLIST:
+    case CommandId::SUBMIT_GPU_CMDLIST: {
-    {
        auto& params = command.submit_gpu_cmdlist;
        if (params.do_flush) {
@@ -468,10 +493,12 @@ static void ExecuteCommand(const Command& command, u32 thread_id) {
        }
        WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(command_processor_config.address)),
-                Memory::VirtualToPhysicalAddress(params.address) >> 3);
+                         Memory::VirtualToPhysicalAddress(params.address) >> 3);
-        WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(command_processor_config.size)), params.size);
+        WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(command_processor_config.size)),
+                         params.size);
-        // TODO: Not sure if we are supposed to always write this .. seems to trigger processing though
+        // TODO: Not sure if we are supposed to always write this .. seems to trigger processing
+        // though
        WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(command_processor_config.trigger)), 1);
        // TODO(yuriks): Figure out the meaning of the `flags` field.
@@ -481,67 +508,70 @@ static void ExecuteCommand(const Command& command, u32 thread_id) {
    // It's assumed that the two "blocks" behave equivalently.
    // Presumably this is done simply to allow two memory fills to run in parallel.
-    case CommandId::SET_MEMORY_FILL:
+    case CommandId::SET_MEMORY_FILL: {
-    {
        auto& params = command.memory_fill;
        if (params.start1 != 0) {
            WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[0].address_start)),
-                    Memory::VirtualToPhysicalAddress(params.start1) >> 3);
+                             Memory::VirtualToPhysicalAddress(params.start1) >> 3);
            WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[0].address_end)),
-                    Memory::VirtualToPhysicalAddress(params.end1) >> 3);
+                             Memory::VirtualToPhysicalAddress(params.end1) >> 3);
-            WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[0].value_32bit)), params.value1);
+            WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[0].value_32bit)),
-            WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[0].control)), params.control1);
+                             params.value1);
+            WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[0].control)),
+                             params.control1);
        }
        if (params.start2 != 0) {
            WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[1].address_start)),
-                    Memory::VirtualToPhysicalAddress(params.start2) >> 3);
+                             Memory::VirtualToPhysicalAddress(params.start2) >> 3);
            WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[1].address_end)),
-                    Memory::VirtualToPhysicalAddress(params.end2) >> 3);
+                             Memory::VirtualToPhysicalAddress(params.end2) >> 3);
-            WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[1].value_32bit)), params.value2);
+            WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[1].value_32bit)),
-            WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[1].control)), params.control2);
+                             params.value2);
+            WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[1].control)),
+                             params.control2);
        }
        break;
    }
-    case CommandId::SET_DISPLAY_TRANSFER:
+    case CommandId::SET_DISPLAY_TRANSFER: {
-    {
        auto& params = command.display_transfer;
        WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(display_transfer_config.input_address)),
-                Memory::VirtualToPhysicalAddress(params.in_buffer_address) >> 3);
+                         Memory::VirtualToPhysicalAddress(params.in_buffer_address) >> 3);
        WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(display_transfer_config.output_address)),
-                Memory::VirtualToPhysicalAddress(params.out_buffer_address) >> 3);
+                         Memory::VirtualToPhysicalAddress(params.out_buffer_address) >> 3);
-        WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(display_transfer_config.input_size)), params.in_buffer_size);
+        WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(display_transfer_config.input_size)),
-        WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(display_transfer_config.output_size)), params.out_buffer_size);
+                         params.in_buffer_size);
-        WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(display_transfer_config.flags)), params.flags);
+        WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(display_transfer_config.output_size)),
+                         params.out_buffer_size);
+        WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(display_transfer_config.flags)),
+                         params.flags);
        WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(display_transfer_config.trigger)), 1);
        break;
    }
-    case CommandId::SET_TEXTURE_COPY:
+    case CommandId::SET_TEXTURE_COPY: {
-    {
        auto& params = command.texture_copy;
        WriteGPURegister((u32)GPU_REG_INDEX(display_transfer_config.input_address),
-                Memory::VirtualToPhysicalAddress(params.in_buffer_address) >> 3);
+                         Memory::VirtualToPhysicalAddress(params.in_buffer_address) >> 3);
        WriteGPURegister((u32)GPU_REG_INDEX(display_transfer_config.output_address),
-                Memory::VirtualToPhysicalAddress(params.out_buffer_address) >> 3);
+                         Memory::VirtualToPhysicalAddress(params.out_buffer_address) >> 3);
        WriteGPURegister((u32)GPU_REG_INDEX(display_transfer_config.texture_copy.size),
-                params.size);
+                         params.size);
        WriteGPURegister((u32)GPU_REG_INDEX(display_transfer_config.texture_copy.input_size),
-                params.in_width_gap);
+                         params.in_width_gap);
        WriteGPURegister((u32)GPU_REG_INDEX(display_transfer_config.texture_copy.output_size),
-                params.out_width_gap);
+                         params.out_width_gap);
-        WriteGPURegister((u32)GPU_REG_INDEX(display_transfer_config.flags),
+        WriteGPURegister((u32)GPU_REG_INDEX(display_transfer_config.flags), params.flags);
-                params.flags);
-        // NOTE: Actual GSP ORs 1 with current register instead of overwriting. Doesn't seem to matter.
+        // NOTE: Actual GSP ORs 1 with current register instead of overwriting. Doesn't seem to
+        // matter.
        WriteGPURegister((u32)GPU_REG_INDEX(display_transfer_config.trigger), 1);
        break;
    }
-    case CommandId::CACHE_FLUSH:
+    case CommandId::CACHE_FLUSH: {
-    {
        // NOTE: Rasterizer flushing handled elsewhere in CPU read/write and other GPU handlers
        // Use command.cache_flush.regions to implement this handler
        break;
@@ -552,7 +582,8 @@ static void ExecuteCommand(const Command& command, u32 thread_id) {
    }
    if (Pica::g_debug_context)
-        Pica::g_debug_context->OnEvent(Pica::DebugContext::Event::GSPCommandProcessed, (void*)&command);
+        Pica::g_debug_context->OnEvent(Pica::DebugContext::Event::GSPCommandProcessed,
+                                       (void*)&command);
 }
 /**
@@ -575,7 +606,7 @@ static void SetLcdForceBlack(Service::Interface* self) {
    // the color to black (all zero).
    data.is_enabled.Assign(enable_black);
-    LCD::Write(HW::VADDR_LCD + 4 * LCD_REG_INDEX(color_fill_top), data.raw); // Top LCD
+    LCD::Write(HW::VADDR_LCD + 4 * LCD_REG_INDEX(color_fill_top), data.raw);    // Top LCD
    LCD::Write(HW::VADDR_LCD + 4 * LCD_REG_INDEX(color_fill_bottom), data.raw); // Bottom LCD
    cmd_buff[1] = RESULT_SUCCESS.raw;
@@ -679,37 +710,37 @@ static void ReleaseRight(Service::Interface* self) {
 }
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010082, WriteHWRegs,                   "WriteHWRegs"},
+    {0x00010082, WriteHWRegs, "WriteHWRegs"},
-    {0x00020084, WriteHWRegsWithMask,           "WriteHWRegsWithMask"},
+    {0x00020084, WriteHWRegsWithMask, "WriteHWRegsWithMask"},
-    {0x00030082, nullptr,                       "WriteHWRegRepeat"},
+    {0x00030082, nullptr, "WriteHWRegRepeat"},
-    {0x00040080, ReadHWRegs,                    "ReadHWRegs"},
+    {0x00040080, ReadHWRegs, "ReadHWRegs"},
-    {0x00050200, SetBufferSwap,                 "SetBufferSwap"},
+    {0x00050200, SetBufferSwap, "SetBufferSwap"},
-    {0x00060082, nullptr,                       "SetCommandList"},
+    {0x00060082, nullptr, "SetCommandList"},
-    {0x000700C2, nullptr,                       "RequestDma"},
+    {0x000700C2, nullptr, "RequestDma"},
-    {0x00080082, FlushDataCache,                "FlushDataCache"},
+    {0x00080082, FlushDataCache, "FlushDataCache"},
-    {0x00090082, nullptr,                       "InvalidateDataCache"},
+    {0x00090082, nullptr, "InvalidateDataCache"},
-    {0x000A0044, nullptr,                       "RegisterInterruptEvents"},
+    {0x000A0044, nullptr, "RegisterInterruptEvents"},
-    {0x000B0040, SetLcdForceBlack,              "SetLcdForceBlack"},
+    {0x000B0040, SetLcdForceBlack, "SetLcdForceBlack"},
-    {0x000C0000, TriggerCmdReqQueue,            "TriggerCmdReqQueue"},
+    {0x000C0000, TriggerCmdReqQueue, "TriggerCmdReqQueue"},
-    {0x000D0140, nullptr,                       "SetDisplayTransfer"},
+    {0x000D0140, nullptr, "SetDisplayTransfer"},
-    {0x000E0180, nullptr,                       "SetTextureCopy"},
+    {0x000E0180, nullptr, "SetTextureCopy"},
-    {0x000F0200, nullptr,                       "SetMemoryFill"},
+    {0x000F0200, nullptr, "SetMemoryFill"},
-    {0x00100040, SetAxiConfigQoSMode,           "SetAxiConfigQoSMode"},
+    {0x00100040, SetAxiConfigQoSMode, "SetAxiConfigQoSMode"},
-    {0x00110040, nullptr,                       "SetPerfLogMode"},
+    {0x00110040, nullptr, "SetPerfLogMode"},
-    {0x00120000, nullptr,                       "GetPerfLog"},
+    {0x00120000, nullptr, "GetPerfLog"},
-    {0x00130042, RegisterInterruptRelayQueue,   "RegisterInterruptRelayQueue"},
+    {0x00130042, RegisterInterruptRelayQueue, "RegisterInterruptRelayQueue"},
    {0x00140000, UnregisterInterruptRelayQueue, "UnregisterInterruptRelayQueue"},
-    {0x00150002, nullptr,                       "TryAcquireRight"},
+    {0x00150002, nullptr, "TryAcquireRight"},
-    {0x00160042, AcquireRight,                  "AcquireRight"},
+    {0x00160042, AcquireRight, "AcquireRight"},
-    {0x00170000, ReleaseRight,                  "ReleaseRight"},
+    {0x00170000, ReleaseRight, "ReleaseRight"},
-    {0x00180000, ImportDisplayCaptureInfo,      "ImportDisplayCaptureInfo"},
+    {0x00180000, ImportDisplayCaptureInfo, "ImportDisplayCaptureInfo"},
-    {0x00190000, nullptr,                       "SaveVramSysArea"},
+    {0x00190000, nullptr, "SaveVramSysArea"},
-    {0x001A0000, nullptr,                       "RestoreVramSysArea"},
+    {0x001A0000, nullptr, "RestoreVramSysArea"},
-    {0x001B0000, nullptr,                       "ResetGpuCore"},
+    {0x001B0000, nullptr, "ResetGpuCore"},
-    {0x001C0040, nullptr,                       "SetLedForceOff"},
+    {0x001C0040, nullptr, "SetLedForceOff"},
-    {0x001D0040, nullptr,                       "SetTestCommand"},
+    {0x001D0040, nullptr, "SetTestCommand"},
-    {0x001E0080, nullptr,                       "SetInternalPriorities"},
+    {0x001E0080, nullptr, "SetInternalPriorities"},
-    {0x001F0082, nullptr,                       "StoreDataCache"},
+    {0x001F0082, nullptr, "StoreDataCache"},
 };
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -721,9 +752,9 @@ Interface::Interface() {
    g_interrupt_event = nullptr;
    using Kernel::MemoryPermission;
-    g_shared_memory = Kernel::SharedMemory::Create(nullptr, 0x1000,
+    g_shared_memory = Kernel::SharedMemory::Create(nullptr, 0x1000, MemoryPermission::ReadWrite,
-                                                   MemoryPermission::ReadWrite, MemoryPermission::ReadWrite,
+                                                   MemoryPermission::ReadWrite, 0,
-                                                   0, Kernel::MemoryRegion::BASE, "GSP:SharedMemory");
+                                                   Kernel::MemoryRegion::BASE, "GSP:SharedMemory");
    g_thread_id = 0;
    gpu_right_acquired = false;
diff --git a/src/core/hle/service/gsp_gpu.h b/src/core/hle/service/gsp_gpu.h
index 3b4b678a3..e028123f3 100644
--- a/src/core/hle/service/gsp_gpu.h
+++ b/src/core/hle/service/gsp_gpu.h
@@ -20,30 +20,30 @@ namespace GSP_GPU {
 /// GSP interrupt ID
 enum class InterruptId : u8 {
-    PSC0    = 0x00,
+    PSC0 = 0x00,
-    PSC1    = 0x01,
+    PSC1 = 0x01,
-    PDC0    = 0x02, // Seems called every vertical screen line
+    PDC0 = 0x02, // Seems called every vertical screen line
-    PDC1    = 0x03, // Seems called every frame
+    PDC1 = 0x03, // Seems called every frame
-    PPF     = 0x04,
+    PPF = 0x04,
-    P3D     = 0x05,
+    P3D = 0x05,
-    DMA     = 0x06,
+    DMA = 0x06,
 };
 /// GSP command ID
 enum class CommandId : u32 {
-    REQUEST_DMA            = 0x00,
+    REQUEST_DMA = 0x00,
    /// Submits a commandlist for execution by the GPU.
    SUBMIT_GPU_CMDLIST = 0x01,
    // Fills a given memory range with a particular value
-    SET_MEMORY_FILL        = 0x02,
+    SET_MEMORY_FILL = 0x02,
    // Copies an image and optionally performs color-conversion or scaling.
    // This is highly similar to the GameCube's EFB copy feature
-    SET_DISPLAY_TRANSFER   = 0x03,
+    SET_DISPLAY_TRANSFER = 0x03,
    // Conceptionally similar to SET_DISPLAY_TRANSFER and presumable uses the same hardware path
-    SET_TEXTURE_COPY       = 0x04,
+    SET_TEXTURE_COPY = 0x04,
    /// Flushes up to 3 cache regions in a single command.
    CACHE_FLUSH = 0x05,
 };
@@ -61,19 +61,18 @@ struct InterruptRelayQueue {
    u32 missed_PDC0;
    u32 missed_PDC1;
-    InterruptId slot[0x34];   ///< Interrupt ID slots
+    InterruptId slot[0x34]; ///< Interrupt ID slots
 };
-static_assert(sizeof(InterruptRelayQueue) == 0x40,
+static_assert(sizeof(InterruptRelayQueue) == 0x40, "InterruptRelayQueue struct has incorrect size");
-    "InterruptRelayQueue struct has incorrect size");
 struct FrameBufferInfo {
    BitField<0, 1, u32> active_fb; // 0 = first, 1 = second
    u32 address_left;
    u32 address_right;
-    u32 stride;    // maps to 0x1EF00X90 ?
+    u32 stride;   // maps to 0x1EF00X90 ?
-    u32 format;    // maps to 0x1EF00X70 ?
+    u32 format;   // maps to 0x1EF00X70 ?
-    u32 shown_fb;  // maps to 0x1EF00X78 ?
+    u32 shown_fb; // maps to 0x1EF00X78 ?
    u32 unknown;
 };
 static_assert(sizeof(FrameBufferInfo) == 0x1c, "Struct has incorrect size");
@@ -91,7 +90,8 @@ static_assert(sizeof(FrameBufferUpdate) == 0x40, "Struct has incorrect size");
 // TODO: Not sure if this padding is correct.
 // Chances are the second block is stored at offset 0x24 rather than 0x20.
 #ifndef _MSC_VER
-static_assert(offsetof(FrameBufferUpdate, framebuffer_info[1]) == 0x20, "FrameBufferInfo element has incorrect alignment");
+static_assert(offsetof(FrameBufferUpdate, framebuffer_info[1]) == 0x20,
+              "FrameBufferInfo element has incorrect alignment");
 #endif
 /// GSP command
@@ -163,13 +163,13 @@ struct CommandBuffer {
        // Current command index. This index is updated by GSP module after loading the command
        // data, right before the command is processed. When this index is updated by GSP module,
        // the total commands field is decreased by one as well.
-        BitField<0,8,u32>   index;
+        BitField<0, 8, u32> index;
        // Total commands to process, must not be value 0 when GSP module handles commands. This
        // must be <=15 when writing a command to shared memory. This is incremented by the
        // application when writing a command to shared memory, after increasing this value
        // TriggerCmdReqQueue is only used if this field is value 1.
-        BitField<8,8,u32>   number_commands;
+        BitField<8, 8, u32> number_commands;
    };
    u32 unk[7];
diff --git a/src/core/hle/service/gsp_lcd.cpp b/src/core/hle/service/gsp_lcd.cpp
index c700c21c5..3922cd197 100644
--- a/src/core/hle/service/gsp_lcd.cpp
+++ b/src/core/hle/service/gsp_lcd.cpp
@@ -9,13 +9,11 @@
 namespace GSP_LCD {
-const Interface::FunctionInfo FunctionTable[] = {
+const Interface::FunctionInfo FunctionTable[] = {{0x000F0000, nullptr, "PowerOnAllBacklights"},
-    {0x000F0000, nullptr, "PowerOnAllBacklights"},
+                                                 {0x00100000, nullptr, "PowerOffAllBacklights"},
-    {0x00100000, nullptr, "PowerOffAllBacklights"},
+                                                 {0x00110040, nullptr, "PowerOnBacklight"},
-    {0x00110040, nullptr, "PowerOnBacklight"},
+                                                 {0x00120040, nullptr, "PowerOffBacklight"},
-    {0x00120040, nullptr, "PowerOffBacklight"},
+                                                 {0x00130040, nullptr, "SetLedForceOff"}};
-    {0x00130040, nullptr, "SetLedForceOff"}
-};
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Interface class
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index cdec11388..d915a3105 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -4,13 +4,13 @@
 #include <cmath>
-#include "common/logging/log.h"
 #include "common/emu_window.h"
+#include "common/logging/log.h"
-#include "core/hle/service/service.h"
 #include "core/hle/service/hid/hid.h"
 #include "core/hle/service/hid/hid_spvr.h"
 #include "core/hle/service/hid/hid_user.h"
+#include "core/hle/service/service.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/event.h"
@@ -37,11 +37,14 @@ static u32 next_accelerometer_index;
 static u32 next_gyroscope_index;
 static int enable_accelerometer_count = 0; // positive means enabled
-static int enable_gyroscope_count = 0; // positive means enabled
+static int enable_gyroscope_count = 0;     // positive means enabled
 static PadState GetCirclePadDirectionState(s16 circle_pad_x, s16 circle_pad_y) {
-    constexpr float TAN30 = 0.577350269, TAN60 = 1 / TAN30; // 30 degree and 60 degree are angular thresholds for directions
+    constexpr float TAN30 = 0.577350269,
-    constexpr int CIRCLE_PAD_THRESHOLD_SQUARE = 40 * 40; // a circle pad radius greater than 40 will trigger circle pad direction
+                    TAN60 =
+                        1 / TAN30; // 30 degree and 60 degree are angular thresholds for directions
+    constexpr int CIRCLE_PAD_THRESHOLD_SQUARE =
+        40 * 40; // a circle pad radius greater than 40 will trigger circle pad direction
    PadState state;
    state.hex = 0;
@@ -90,7 +93,7 @@ void Update() {
    PadState old_state = mem->pad.entries[last_entry_index].current_state;
    // Compute bitmask with 1s for bits different from the old state
-    PadState changed = { { (state.hex ^ old_state.hex) } };
+    PadState changed = {{(state.hex ^ old_state.hex)}};
    // Get the current Pad entry
    PadDataEntry& pad_entry = mem->pad.entries[mem->pad.index];
@@ -135,11 +138,13 @@ void Update() {
    // Update accelerometer
    if (enable_accelerometer_count > 0) {
        mem->accelerometer.index = next_accelerometer_index;
-        next_accelerometer_index = (next_accelerometer_index + 1) % mem->accelerometer.entries.size();
+        next_accelerometer_index =
+            (next_accelerometer_index + 1) % mem->accelerometer.entries.size();
-        AccelerometerDataEntry& accelerometer_entry = mem->accelerometer.entries[mem->accelerometer.index];
+        AccelerometerDataEntry& accelerometer_entry =
-        std::tie(accelerometer_entry.x, accelerometer_entry.y, accelerometer_entry.z)
+            mem->accelerometer.entries[mem->accelerometer.index];
-            = VideoCore::g_emu_window->GetAccelerometerState();
+        std::tie(accelerometer_entry.x, accelerometer_entry.y, accelerometer_entry.z) =
+            VideoCore::g_emu_window->GetAccelerometerState();
        // Make up "raw" entry
        // TODO(wwylele):
@@ -167,8 +172,8 @@ void Update() {
        next_gyroscope_index = (next_gyroscope_index + 1) % mem->gyroscope.entries.size();
        GyroscopeDataEntry& gyroscope_entry = mem->gyroscope.entries[mem->gyroscope.index];
-        std::tie(gyroscope_entry.x, gyroscope_entry.y, gyroscope_entry.z)
+        std::tie(gyroscope_entry.x, gyroscope_entry.y, gyroscope_entry.z) =
-            = VideoCore::g_emu_window->GetGyroscopeState();
+            VideoCore::g_emu_window->GetGyroscopeState();
        // Make up "raw" entry
        mem->gyroscope.raw_entry.x = gyroscope_entry.x;
@@ -188,7 +193,7 @@ void Update() {
 void GetIPCHandles(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
-    cmd_buff[1] = 0; // No error
+    cmd_buff[1] = 0;          // No error
    cmd_buff[2] = 0x14000000; // IPC Command Structure translate-header
    // TODO(yuriks): Return error from SendSyncRequest is this fails (part of IPC marshalling)
    cmd_buff[3] = Kernel::g_handle_table.Create(Service::HID::shared_mem).MoveFrom();
@@ -259,9 +264,7 @@ void GetGyroscopeLowCalibrateParam(Service::Interface* self) {
    const s16 param_unit = 6700; // an approximate value taken from hw
    GyroscopeCalibrateParam param = {
-        { 0, param_unit, -param_unit },
+        {0, param_unit, -param_unit}, {0, param_unit, -param_unit}, {0, param_unit, -param_unit},
-        { 0, param_unit, -param_unit },
-        { 0, param_unit, -param_unit },
    };
    memcpy(&cmd_buff[2], &param, sizeof(param));
@@ -286,9 +289,9 @@ void Init() {
    AddService(new HID_SPVR_Interface);
    using Kernel::MemoryPermission;
-    shared_mem = SharedMemory::Create(nullptr, 0x1000,
+    shared_mem =
-                                      MemoryPermission::ReadWrite, MemoryPermission::Read,
+        SharedMemory::Create(nullptr, 0x1000, MemoryPermission::ReadWrite, MemoryPermission::Read,
-                                      0, Kernel::MemoryRegion::BASE, "HID:SharedMemory");
+                             0, Kernel::MemoryRegion::BASE, "HID:SharedMemory");
    next_pad_index = 0;
    next_touch_index = 0;
@@ -296,9 +299,9 @@ void Init() {
    // Create event handles
    event_pad_or_touch_1 = Event::Create(ResetType::OneShot, "HID:EventPadOrTouch1");
    event_pad_or_touch_2 = Event::Create(ResetType::OneShot, "HID:EventPadOrTouch2");
-    event_accelerometer  = Event::Create(ResetType::OneShot, "HID:EventAccelerometer");
+    event_accelerometer = Event::Create(ResetType::OneShot, "HID:EventAccelerometer");
-    event_gyroscope      = Event::Create(ResetType::OneShot, "HID:EventGyroscope");
+    event_gyroscope = Event::Create(ResetType::OneShot, "HID:EventGyroscope");
-    event_debug_pad      = Event::Create(ResetType::OneShot, "HID:EventDebugPad");
+    event_debug_pad = Event::Create(ResetType::OneShot, "HID:EventDebugPad");
 }
 void Shutdown() {
diff --git a/src/core/hle/service/hid/hid.h b/src/core/hle/service/hid/hid.h
index 669b1f723..f54ffd8be 100644
--- a/src/core/hle/service/hid/hid.h
+++ b/src/core/hle/service/hid/hid.h
@@ -9,10 +9,10 @@
 #ifndef _MSC_VER
 #include <cstddef>
 #endif
-#include "core/settings.h"
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "core/settings.h"
 namespace Service {
@@ -103,7 +103,7 @@ struct SharedMem {
    struct {
        s64 index_reset_ticks; ///< CPU tick count for when HID module updated entry index 0
        s64 index_reset_ticks_previous; ///< Previous `index_reset_ticks`
-        u32 index; ///< Index of the last updated pad state entry
+        u32 index;                      ///< Index of the last updated pad state entry
        INSERT_PADDING_WORDS(0x2);
@@ -121,7 +121,7 @@ struct SharedMem {
    struct {
        s64 index_reset_ticks; ///< CPU tick count for when HID module updated entry index 0
        s64 index_reset_ticks_previous; ///< Previous `index_reset_ticks`
-        u32 index; ///< Index of the last updated touch entry
+        u32 index;                      ///< Index of the last updated touch entry
        INSERT_PADDING_WORDS(0x1);
@@ -135,7 +135,7 @@ struct SharedMem {
    struct {
        s64 index_reset_ticks; ///< CPU tick count for when HID module updated entry index 0
        s64 index_reset_ticks_previous; ///< Previous `index_reset_ticks`
-        u32 index; ///< Index of the last updated accelerometer entry
+        u32 index;                      ///< Index of the last updated accelerometer entry
        INSERT_PADDING_WORDS(0x1);
@@ -149,7 +149,7 @@ struct SharedMem {
    struct {
        s64 index_reset_ticks; ///< CPU tick count for when HID module updated entry index 0
        s64 index_reset_ticks_previous; ///< Previous `index_reset_ticks`
-        u32 index; ///< Index of the last updated accelerometer entry
+        u32 index;                      ///< Index of the last updated accelerometer entry
        INSERT_PADDING_WORDS(0x1);
@@ -176,9 +176,9 @@ struct GyroscopeCalibrateParam {
 //       is technically allowed since C++11. This macro should be enabled once MSVC adds
 //       support for that.
 #ifndef _MSC_VER
-#define ASSERT_REG_POSITION(field_name, position)                  \
+#define ASSERT_REG_POSITION(field_name, position)                                                  \
-    static_assert(offsetof(SharedMem, field_name) == position * 4, \
+    static_assert(offsetof(SharedMem, field_name) == position * 4,                                 \
-                  "Field "#field_name" has invalid position")
+                  "Field " #field_name " has invalid position")
 ASSERT_REG_POSITION(pad.index_reset_ticks, 0x0);
 ASSERT_REG_POSITION(touch.index_reset_ticks, 0x2A);
@@ -187,33 +187,33 @@ ASSERT_REG_POSITION(touch.index_reset_ticks, 0x2A);
 #endif // !defined(_MSC_VER)
 // Pre-defined PadStates for single button presses
-const PadState PAD_NONE         = {{0}};
+const PadState PAD_NONE = {{0}};
-const PadState PAD_A            = {{1u << 0}};
+const PadState PAD_A = {{1u << 0}};
-const PadState PAD_B            = {{1u << 1}};
+const PadState PAD_B = {{1u << 1}};
-const PadState PAD_SELECT       = {{1u << 2}};
+const PadState PAD_SELECT = {{1u << 2}};
-const PadState PAD_START        = {{1u << 3}};
+const PadState PAD_START = {{1u << 3}};
-const PadState PAD_RIGHT        = {{1u << 4}};
+const PadState PAD_RIGHT = {{1u << 4}};
-const PadState PAD_LEFT         = {{1u << 5}};
+const PadState PAD_LEFT = {{1u << 5}};
-const PadState PAD_UP           = {{1u << 6}};
+const PadState PAD_UP = {{1u << 6}};
-const PadState PAD_DOWN         = {{1u << 7}};
+const PadState PAD_DOWN = {{1u << 7}};
-const PadState PAD_R            = {{1u << 8}};
+const PadState PAD_R = {{1u << 8}};
-const PadState PAD_L            = {{1u << 9}};
+const PadState PAD_L = {{1u << 9}};
-const PadState PAD_X            = {{1u << 10}};
+const PadState PAD_X = {{1u << 10}};
-const PadState PAD_Y            = {{1u << 11}};
+const PadState PAD_Y = {{1u << 11}};
-const PadState PAD_ZL           = {{1u << 14}};
+const PadState PAD_ZL = {{1u << 14}};
-const PadState PAD_ZR           = {{1u << 15}};
+const PadState PAD_ZR = {{1u << 15}};
-const PadState PAD_TOUCH        = {{1u << 20}};
+const PadState PAD_TOUCH = {{1u << 20}};
-const PadState PAD_C_RIGHT      = {{1u << 24}};
+const PadState PAD_C_RIGHT = {{1u << 24}};
-const PadState PAD_C_LEFT       = {{1u << 25}};
+const PadState PAD_C_LEFT = {{1u << 25}};
-const PadState PAD_C_UP         = {{1u << 26}};
+const PadState PAD_C_UP = {{1u << 26}};
-const PadState PAD_C_DOWN       = {{1u << 27}};
+const PadState PAD_C_DOWN = {{1u << 27}};
 const PadState PAD_CIRCLE_RIGHT = {{1u << 28}};
-const PadState PAD_CIRCLE_LEFT  = {{1u << 29}};
+const PadState PAD_CIRCLE_LEFT = {{1u << 29}};
-const PadState PAD_CIRCLE_UP    = {{1u << 30}};
+const PadState PAD_CIRCLE_UP = {{1u << 30}};
-const PadState PAD_CIRCLE_DOWN  = {{1u << 31}};
+const PadState PAD_CIRCLE_DOWN = {{1u << 31}};
 /**
 * HID::GetIPCHandles service function
@@ -305,6 +305,5 @@ void Init();
 /// Shutdown HID service
 void Shutdown();
 }
 }
diff --git a/src/core/hle/service/hid/hid_spvr.cpp b/src/core/hle/service/hid/hid_spvr.cpp
index 046e65b11..09007e304 100644
--- a/src/core/hle/service/hid/hid_spvr.cpp
+++ b/src/core/hle/service/hid/hid_spvr.cpp
@@ -9,16 +9,16 @@ namespace Service {
 namespace HID {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x000A0000, GetIPCHandles,                      "GetIPCHandles"},
+    {0x000A0000, GetIPCHandles, "GetIPCHandles"},
-    {0x000B0000, nullptr,                            "StartAnalogStickCalibration"},
+    {0x000B0000, nullptr, "StartAnalogStickCalibration"},
-    {0x000E0000, nullptr,                            "GetAnalogStickCalibrateParam"},
+    {0x000E0000, nullptr, "GetAnalogStickCalibrateParam"},
-    {0x00110000, EnableAccelerometer,                "EnableAccelerometer"},
+    {0x00110000, EnableAccelerometer, "EnableAccelerometer"},
-    {0x00120000, DisableAccelerometer,               "DisableAccelerometer"},
+    {0x00120000, DisableAccelerometer, "DisableAccelerometer"},
-    {0x00130000, EnableGyroscopeLow,                 "EnableGyroscopeLow"},
+    {0x00130000, EnableGyroscopeLow, "EnableGyroscopeLow"},
-    {0x00140000, DisableGyroscopeLow,                "DisableGyroscopeLow"},
+    {0x00140000, DisableGyroscopeLow, "DisableGyroscopeLow"},
    {0x00150000, GetGyroscopeLowRawToDpsCoefficient, "GetGyroscopeLowRawToDpsCoefficient"},
-    {0x00160000, GetGyroscopeLowCalibrateParam,      "GetGyroscopeLowCalibrateParam"},
+    {0x00160000, GetGyroscopeLowCalibrateParam, "GetGyroscopeLowCalibrateParam"},
-    {0x00170000, GetSoundVolume,                     "GetSoundVolume"},
+    {0x00170000, GetSoundVolume, "GetSoundVolume"},
 };
 HID_SPVR_Interface::HID_SPVR_Interface() {
diff --git a/src/core/hle/service/hid/hid_user.cpp b/src/core/hle/service/hid/hid_user.cpp
index bb157b83d..42591543c 100644
--- a/src/core/hle/service/hid/hid_user.cpp
+++ b/src/core/hle/service/hid/hid_user.cpp
@@ -9,16 +9,16 @@ namespace Service {
 namespace HID {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x000A0000, GetIPCHandles,                      "GetIPCHandles"},
+    {0x000A0000, GetIPCHandles, "GetIPCHandles"},
-    {0x000B0000, nullptr,                            "StartAnalogStickCalibration"},
+    {0x000B0000, nullptr, "StartAnalogStickCalibration"},
-    {0x000E0000, nullptr,                            "GetAnalogStickCalibrateParam"},
+    {0x000E0000, nullptr, "GetAnalogStickCalibrateParam"},
-    {0x00110000, EnableAccelerometer,                "EnableAccelerometer"},
+    {0x00110000, EnableAccelerometer, "EnableAccelerometer"},
-    {0x00120000, DisableAccelerometer,               "DisableAccelerometer"},
+    {0x00120000, DisableAccelerometer, "DisableAccelerometer"},
-    {0x00130000, EnableGyroscopeLow,                 "EnableGyroscopeLow"},
+    {0x00130000, EnableGyroscopeLow, "EnableGyroscopeLow"},
-    {0x00140000, DisableGyroscopeLow,                "DisableGyroscopeLow"},
+    {0x00140000, DisableGyroscopeLow, "DisableGyroscopeLow"},
    {0x00150000, GetGyroscopeLowRawToDpsCoefficient, "GetGyroscopeLowRawToDpsCoefficient"},
-    {0x00160000, GetGyroscopeLowCalibrateParam,      "GetGyroscopeLowCalibrateParam"},
+    {0x00160000, GetGyroscopeLowCalibrateParam, "GetGyroscopeLowCalibrateParam"},
-    {0x00170000, GetSoundVolume,                     "GetSoundVolume"},
+    {0x00170000, GetSoundVolume, "GetSoundVolume"},
 };
 HID_U_Interface::HID_U_Interface() {
diff --git a/src/core/hle/service/http_c.cpp b/src/core/hle/service/http_c.cpp
index 0855ab227..3cf62a4b8 100644
--- a/src/core/hle/service/http_c.cpp
+++ b/src/core/hle/service/http_c.cpp
@@ -10,56 +10,56 @@
 namespace HTTP_C {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010044, nullptr,                 "Initialize"},
+    {0x00010044, nullptr, "Initialize"},
-    {0x00020082, nullptr,                 "CreateContext"},
+    {0x00020082, nullptr, "CreateContext"},
-    {0x00030040, nullptr,                 "CloseContext"},
+    {0x00030040, nullptr, "CloseContext"},
-    {0x00040040, nullptr,                 "CancelConnection"},
+    {0x00040040, nullptr, "CancelConnection"},
-    {0x00050040, nullptr,                 "GetRequestState"},
+    {0x00050040, nullptr, "GetRequestState"},
-    {0x00060040, nullptr,                 "GetDownloadSizeState"},
+    {0x00060040, nullptr, "GetDownloadSizeState"},
-    {0x00070040, nullptr,                 "GetRequestError"},
+    {0x00070040, nullptr, "GetRequestError"},
-    {0x00080042, nullptr,                 "InitializeConnectionSession"},
+    {0x00080042, nullptr, "InitializeConnectionSession"},
-    {0x00090040, nullptr,                 "BeginRequest"},
+    {0x00090040, nullptr, "BeginRequest"},
-    {0x000A0040, nullptr,                 "BeginRequestAsync"},
+    {0x000A0040, nullptr, "BeginRequestAsync"},
-    {0x000B0082, nullptr,                 "ReceiveData"},
+    {0x000B0082, nullptr, "ReceiveData"},
-    {0x000C0102, nullptr,                 "ReceiveDataTimeout"},
+    {0x000C0102, nullptr, "ReceiveDataTimeout"},
-    {0x000D0146, nullptr,                 "SetProxy"},
+    {0x000D0146, nullptr, "SetProxy"},
-    {0x000E0040, nullptr,                 "SetProxyDefault"},
+    {0x000E0040, nullptr, "SetProxyDefault"},
-    {0x000F00C4, nullptr,                 "SetBasicAuthorization"},
+    {0x000F00C4, nullptr, "SetBasicAuthorization"},
-    {0x00100080, nullptr,                 "SetSocketBufferSize"},
+    {0x00100080, nullptr, "SetSocketBufferSize"},
-    {0x001100C4, nullptr,                 "AddRequestHeader"},
+    {0x001100C4, nullptr, "AddRequestHeader"},
-    {0x001200C4, nullptr,                 "AddPostDataAscii"},
+    {0x001200C4, nullptr, "AddPostDataAscii"},
-    {0x001300C4, nullptr,                 "AddPostDataBinary"},
+    {0x001300C4, nullptr, "AddPostDataBinary"},
-    {0x00140082, nullptr,                 "AddPostDataRaw"},
+    {0x00140082, nullptr, "AddPostDataRaw"},
-    {0x00150080, nullptr,                 "SetPostDataType"},
+    {0x00150080, nullptr, "SetPostDataType"},
-    {0x001600C4, nullptr,                 "SendPostDataAscii"},
+    {0x001600C4, nullptr, "SendPostDataAscii"},
-    {0x00170144, nullptr,                 "SendPostDataAsciiTimeout"},
+    {0x00170144, nullptr, "SendPostDataAsciiTimeout"},
-    {0x001800C4, nullptr,                 "SendPostDataBinary"},
+    {0x001800C4, nullptr, "SendPostDataBinary"},
-    {0x00190144, nullptr,                 "SendPostDataBinaryTimeout"},
+    {0x00190144, nullptr, "SendPostDataBinaryTimeout"},
-    {0x001A0082, nullptr,                 "SendPostDataRaw"},
+    {0x001A0082, nullptr, "SendPostDataRaw"},
-    {0x001B0102, nullptr,                 "SendPOSTDataRawTimeout"},
+    {0x001B0102, nullptr, "SendPOSTDataRawTimeout"},
-    {0x001C0080, nullptr,                 "SetPostDataEncoding"},
+    {0x001C0080, nullptr, "SetPostDataEncoding"},
-    {0x001D0040, nullptr,                 "NotifyFinishSendPostData"},
+    {0x001D0040, nullptr, "NotifyFinishSendPostData"},
-    {0x001E00C4, nullptr,                 "GetResponseHeader"},
+    {0x001E00C4, nullptr, "GetResponseHeader"},
-    {0x001F0144, nullptr,                 "GetResponseHeaderTimeout"},
+    {0x001F0144, nullptr, "GetResponseHeaderTimeout"},
-    {0x00200082, nullptr,                 "GetResponseData"},
+    {0x00200082, nullptr, "GetResponseData"},
-    {0x00210102, nullptr,                 "GetResponseDataTimeout"},
+    {0x00210102, nullptr, "GetResponseDataTimeout"},
-    {0x00220040, nullptr,                 "GetResponseStatusCode"},
+    {0x00220040, nullptr, "GetResponseStatusCode"},
-    {0x002300C0, nullptr,                 "GetResponseStatusCodeTimeout"},
+    {0x002300C0, nullptr, "GetResponseStatusCodeTimeout"},
-    {0x00240082, nullptr,                 "AddTrustedRootCA"},
+    {0x00240082, nullptr, "AddTrustedRootCA"},
-    {0x00250080, nullptr,                 "AddDefaultCert"},
+    {0x00250080, nullptr, "AddDefaultCert"},
-    {0x00260080, nullptr,                 "SelectRootCertChain"},
+    {0x00260080, nullptr, "SelectRootCertChain"},
-    {0x002700C4, nullptr,                 "SetClientCert"},
+    {0x002700C4, nullptr, "SetClientCert"},
-    {0x002B0080, nullptr,                 "SetSSLOpt"},
+    {0x002B0080, nullptr, "SetSSLOpt"},
-    {0x002C0080, nullptr,                 "SetSSLClearOpt"},
+    {0x002C0080, nullptr, "SetSSLClearOpt"},
-    {0x002D0000, nullptr,                 "CreateRootCertChain"},
+    {0x002D0000, nullptr, "CreateRootCertChain"},
-    {0x002E0040, nullptr,                 "DestroyRootCertChain"},
+    {0x002E0040, nullptr, "DestroyRootCertChain"},
-    {0x002F0082, nullptr,                 "RootCertChainAddCert"},
+    {0x002F0082, nullptr, "RootCertChainAddCert"},
-    {0x00300080, nullptr,                 "RootCertChainAddDefaultCert"},
+    {0x00300080, nullptr, "RootCertChainAddDefaultCert"},
-    {0x00350186, nullptr,                 "SetDefaultProxy"},
+    {0x00350186, nullptr, "SetDefaultProxy"},
-    {0x00360000, nullptr,                 "ClearDNSCache"},
+    {0x00360000, nullptr, "ClearDNSCache"},
-    {0x00370080, nullptr,                 "SetKeepAlive"},
+    {0x00370080, nullptr, "SetKeepAlive"},
-    {0x003800C0, nullptr,                 "SetPostDataTypeSize"},
+    {0x003800C0, nullptr, "SetPostDataTypeSize"},
-    {0x00390000, nullptr,                 "Finalize"},
+    {0x00390000, nullptr, "Finalize"},
 };
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/ir/ir.cpp b/src/core/hle/service/ir/ir.cpp
index 079a87e48..fc048ae88 100644
--- a/src/core/hle/service/ir/ir.cpp
+++ b/src/core/hle/service/ir/ir.cpp
@@ -5,11 +5,11 @@
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/shared_memory.h"
-#include "core/hle/service/service.h"
 #include "core/hle/service/ir/ir.h"
 #include "core/hle/service/ir/ir_rst.h"
 #include "core/hle/service/ir/ir_u.h"
 #include "core/hle/service/ir/ir_user.h"
+#include "core/hle/service/service.h"
 namespace Service {
 namespace IR {
@@ -32,14 +32,14 @@ void InitializeIrNopShared(Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    u32 transfer_buff_size = cmd_buff[1];
-    u32 recv_buff_size     = cmd_buff[2];
+    u32 recv_buff_size = cmd_buff[2];
-    u32 unk1               = cmd_buff[3];
+    u32 unk1 = cmd_buff[3];
-    u32 send_buff_size     = cmd_buff[4];
+    u32 send_buff_size = cmd_buff[4];
-    u32 unk2               = cmd_buff[5];
+    u32 unk2 = cmd_buff[5];
-    u8  baud_rate          = cmd_buff[6] & 0xFF;
+    u8 baud_rate = cmd_buff[6] & 0xFF;
-    Handle handle          = cmd_buff[8];
+    Handle handle = cmd_buff[8];
-    if(Kernel::g_handle_table.IsValid(handle)) {
+    if (Kernel::g_handle_table.IsValid(handle)) {
        transfer_shared_memory = Kernel::g_handle_table.Get<Kernel::SharedMemory>(handle);
        transfer_shared_memory->name = "IR:TransferSharedMemory";
    }
@@ -47,7 +47,7 @@ void InitializeIrNopShared(Interface* self) {
    cmd_buff[1] = RESULT_SUCCESS.raw;
    LOG_WARNING(Service_IR, "(STUBBED) called, transfer_buff_size=%d, recv_buff_size=%d, "
-                "unk1=%d, send_buff_size=%d, unk2=%d, baud_rate=%u, handle=0x%08X",
+                            "unk1=%d, send_buff_size=%d, unk2=%d, baud_rate=%u, handle=0x%08X",
                transfer_buff_size, recv_buff_size, unk1, send_buff_size, unk2, baud_rate, handle);
 }
@@ -94,13 +94,13 @@ void Init() {
    AddService(new IR_User_Interface);
    using Kernel::MemoryPermission;
-    shared_memory = SharedMemory::Create(nullptr, 0x1000,
+    shared_memory = SharedMemory::Create(nullptr, 0x1000, Kernel::MemoryPermission::ReadWrite,
-                                         Kernel::MemoryPermission::ReadWrite, Kernel::MemoryPermission::ReadWrite,
+                                         Kernel::MemoryPermission::ReadWrite, 0,
-                                         0, Kernel::MemoryRegion::BASE, "IR:SharedMemory");
+                                         Kernel::MemoryRegion::BASE, "IR:SharedMemory");
    transfer_shared_memory = nullptr;
    // Create event handle(s)
-    handle_event  = Event::Create(ResetType::OneShot, "IR:HandleEvent");
+    handle_event = Event::Create(ResetType::OneShot, "IR:HandleEvent");
    conn_status_event = Event::Create(ResetType::OneShot, "IR:ConnectionStatusEvent");
 }
diff --git a/src/core/hle/service/ir/ir_rst.cpp b/src/core/hle/service/ir/ir_rst.cpp
index c0300f109..1f10ebd3d 100644
--- a/src/core/hle/service/ir/ir_rst.cpp
+++ b/src/core/hle/service/ir/ir_rst.cpp
@@ -9,10 +9,10 @@ namespace Service {
 namespace IR {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010000, GetHandles,              "GetHandles"},
+    {0x00010000, GetHandles, "GetHandles"},
-    {0x00020080, nullptr,                 "Initialize"},
+    {0x00020080, nullptr, "Initialize"},
-    {0x00030000, nullptr,                 "Shutdown"},
+    {0x00030000, nullptr, "Shutdown"},
-    {0x00090000, nullptr,                 "WriteToTwoFields"},
+    {0x00090000, nullptr, "WriteToTwoFields"},
 };
 IR_RST_Interface::IR_RST_Interface() {
diff --git a/src/core/hle/service/ir/ir_u.cpp b/src/core/hle/service/ir/ir_u.cpp
index 96f76cb83..be4049da9 100644
--- a/src/core/hle/service/ir/ir_u.cpp
+++ b/src/core/hle/service/ir/ir_u.cpp
@@ -8,24 +8,15 @@ namespace Service {
 namespace IR {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010000, nullptr,                 "Initialize"},
+    {0x00010000, nullptr, "Initialize"},           {0x00020000, nullptr, "Shutdown"},
-    {0x00020000, nullptr,                 "Shutdown"},
+    {0x00030042, nullptr, "StartSendTransfer"},    {0x00040000, nullptr, "WaitSendTransfer"},
-    {0x00030042, nullptr,                 "StartSendTransfer"},
+    {0x000500C2, nullptr, "StartRecvTransfer"},    {0x00060000, nullptr, "WaitRecvTransfer"},
-    {0x00040000, nullptr,                 "WaitSendTransfer"},
+    {0x00070080, nullptr, "GetRecvTransferCount"}, {0x00080000, nullptr, "GetSendState"},
-    {0x000500C2, nullptr,                 "StartRecvTransfer"},
+    {0x00090040, nullptr, "SetBitRate"},           {0x000A0000, nullptr, "GetBitRate"},
-    {0x00060000, nullptr,                 "WaitRecvTransfer"},
+    {0x000B0040, nullptr, "SetIRLEDState"},        {0x000C0000, nullptr, "GetIRLEDRecvState"},
-    {0x00070080, nullptr,                 "GetRecvTransferCount"},
+    {0x000D0000, nullptr, "GetSendFinishedEvent"}, {0x000E0000, nullptr, "GetRecvFinishedEvent"},
-    {0x00080000, nullptr,                 "GetSendState"},
+    {0x000F0000, nullptr, "GetTransferState"},     {0x00100000, nullptr, "GetErrorStatus"},
-    {0x00090040, nullptr,                 "SetBitRate"},
+    {0x00110040, nullptr, "SetSleepModeActive"},   {0x00120040, nullptr, "SetSleepModeState"},
-    {0x000A0000, nullptr,                 "GetBitRate"},
-    {0x000B0040, nullptr,                 "SetIRLEDState"},
-    {0x000C0000, nullptr,                 "GetIRLEDRecvState"},
-    {0x000D0000, nullptr,                 "GetSendFinishedEvent"},
-    {0x000E0000, nullptr,                 "GetRecvFinishedEvent"},
-    {0x000F0000, nullptr,                 "GetTransferState"},
-    {0x00100000, nullptr,                 "GetErrorStatus"},
-    {0x00110040, nullptr,                 "SetSleepModeActive"},
-    {0x00120040, nullptr,                 "SetSleepModeState"},
 };
 IR_U_Interface::IR_U_Interface() {
diff --git a/src/core/hle/service/ir/ir_user.cpp b/src/core/hle/service/ir/ir_user.cpp
index 06a601029..6cff1d544 100644
--- a/src/core/hle/service/ir/ir_user.cpp
+++ b/src/core/hle/service/ir/ir_user.cpp
@@ -9,32 +9,32 @@ namespace Service {
 namespace IR {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010182, nullptr,                  "InitializeIrNop"},
+    {0x00010182, nullptr, "InitializeIrNop"},
-    {0x00020000, FinalizeIrNop,            "FinalizeIrNop"},
+    {0x00020000, FinalizeIrNop, "FinalizeIrNop"},
-    {0x00030000, nullptr,                  "ClearReceiveBuffer"},
+    {0x00030000, nullptr, "ClearReceiveBuffer"},
-    {0x00040000, nullptr,                  "ClearSendBuffer"},
+    {0x00040000, nullptr, "ClearSendBuffer"},
-    {0x000500C0, nullptr,                  "WaitConnection"},
+    {0x000500C0, nullptr, "WaitConnection"},
-    {0x00060040, RequireConnection,        "RequireConnection"},
+    {0x00060040, RequireConnection, "RequireConnection"},
-    {0x000702C0, nullptr,                  "AutoConnection"},
+    {0x000702C0, nullptr, "AutoConnection"},
-    {0x00080000, nullptr,                  "AnyConnection"},
+    {0x00080000, nullptr, "AnyConnection"},
-    {0x00090000, Disconnect,               "Disconnect"},
+    {0x00090000, Disconnect, "Disconnect"},
-    {0x000A0000, nullptr,                  "GetReceiveEvent"},
+    {0x000A0000, nullptr, "GetReceiveEvent"},
-    {0x000B0000, nullptr,                  "GetSendEvent"},
+    {0x000B0000, nullptr, "GetSendEvent"},
    {0x000C0000, GetConnectionStatusEvent, "GetConnectionStatusEvent"},
-    {0x000D0042, nullptr,                  "SendIrNop"},
+    {0x000D0042, nullptr, "SendIrNop"},
-    {0x000E0042, nullptr,                  "SendIrNopLarge"},
+    {0x000E0042, nullptr, "SendIrNopLarge"},
-    {0x000F0040, nullptr,                  "ReceiveIrnop"},
+    {0x000F0040, nullptr, "ReceiveIrnop"},
-    {0x00100042, nullptr,                  "ReceiveIrnopLarge"},
+    {0x00100042, nullptr, "ReceiveIrnopLarge"},
-    {0x00110040, nullptr,                  "GetLatestReceiveErrorResult"},
+    {0x00110040, nullptr, "GetLatestReceiveErrorResult"},
-    {0x00120040, nullptr,                  "GetLatestSendErrorResult"},
+    {0x00120040, nullptr, "GetLatestSendErrorResult"},
-    {0x00130000, nullptr,                  "GetConnectionStatus"},
+    {0x00130000, nullptr, "GetConnectionStatus"},
-    {0x00140000, nullptr,                  "GetTryingToConnectStatus"},
+    {0x00140000, nullptr, "GetTryingToConnectStatus"},
-    {0x00150000, nullptr,                  "GetReceiveSizeFreeAndUsed"},
+    {0x00150000, nullptr, "GetReceiveSizeFreeAndUsed"},
-    {0x00160000, nullptr,                  "GetSendSizeFreeAndUsed"},
+    {0x00160000, nullptr, "GetSendSizeFreeAndUsed"},
-    {0x00170000, nullptr,                  "GetConnectionRole"},
+    {0x00170000, nullptr, "GetConnectionRole"},
-    {0x00180182, InitializeIrNopShared,    "InitializeIrNopShared"},
+    {0x00180182, InitializeIrNopShared, "InitializeIrNopShared"},
-    {0x00190040, nullptr,                  "ReleaseReceivedData"},
+    {0x00190040, nullptr, "ReleaseReceivedData"},
-    {0x001A0040, nullptr,                  "SetOwnMachineId"},
+    {0x001A0040, nullptr, "SetOwnMachineId"},
 };
 IR_User_Interface::IR_User_Interface() {
diff --git a/src/core/hle/service/ldr_ro/cro_helper.cpp b/src/core/hle/service/ldr_ro/cro_helper.cpp
index 3d2a613ee..5757a4e64 100644
--- a/src/core/hle/service/ldr_ro/cro_helper.cpp
+++ b/src/core/hle/service/ldr_ro/cro_helper.cpp
@@ -14,38 +14,29 @@
 namespace LDR_RO {
 static const ResultCode ERROR_BUFFER_TOO_SMALL = // 0xE0E12C1F
-    ResultCode(static_cast<ErrorDescription>(31), ErrorModule::RO, ErrorSummary::InvalidArgument, ErrorLevel::Usage);
+    ResultCode(static_cast<ErrorDescription>(31), ErrorModule::RO, ErrorSummary::InvalidArgument,
+               ErrorLevel::Usage);
 static ResultCode CROFormatError(u32 description) {
-    return ResultCode(static_cast<ErrorDescription>(description), ErrorModule::RO, ErrorSummary::WrongArgument, ErrorLevel::Permanent);
+    return ResultCode(static_cast<ErrorDescription>(description), ErrorModule::RO,
+                      ErrorSummary::WrongArgument, ErrorLevel::Permanent);
 }
-const std::array<int, 17> CROHelper::ENTRY_SIZE {{
+const std::array<int, 17> CROHelper::ENTRY_SIZE{
-    1, // code
+    {1, // code
-    1, // data
+     1, // data
-    1, // module name
+     1, // module name
-    sizeof(SegmentEntry),
+     sizeof(SegmentEntry), sizeof(ExportNamedSymbolEntry), sizeof(ExportIndexedSymbolEntry),
-    sizeof(ExportNamedSymbolEntry),
+     1, // export strings
-    sizeof(ExportIndexedSymbolEntry),
+     sizeof(ExportTreeEntry), sizeof(ImportModuleEntry), sizeof(ExternalRelocationEntry),
-    1, // export strings
+     sizeof(ImportNamedSymbolEntry), sizeof(ImportIndexedSymbolEntry),
-    sizeof(ExportTreeEntry),
+     sizeof(ImportAnonymousSymbolEntry),
-    sizeof(ImportModuleEntry),
+     1, // import strings
-    sizeof(ExternalRelocationEntry),
+     sizeof(StaticAnonymousSymbolEntry), sizeof(InternalRelocationEntry),
-    sizeof(ImportNamedSymbolEntry),
+     sizeof(StaticRelocationEntry)}};
-    sizeof(ImportIndexedSymbolEntry),
-    sizeof(ImportAnonymousSymbolEntry),
+const std::array<CROHelper::HeaderField, 4> CROHelper::FIX_BARRIERS{
-    1, // import strings
+    {Fix0Barrier, Fix1Barrier, Fix2Barrier, Fix3Barrier}};
-    sizeof(StaticAnonymousSymbolEntry),
-    sizeof(InternalRelocationEntry),
-    sizeof(StaticRelocationEntry)
-}};
-const std::array<CROHelper::HeaderField, 4> CROHelper::FIX_BARRIERS {{
-    Fix0Barrier,
-    Fix1Barrier,
-    Fix2Barrier,
-    Fix3Barrier
-}};
 VAddr CROHelper::SegmentTagToAddress(SegmentTag segment_tag) const {
    u32 segment_num = GetField(SegmentNum);
@@ -63,7 +54,7 @@ VAddr CROHelper::SegmentTagToAddress(SegmentTag segment_tag) const {
 }
 ResultCode CROHelper::ApplyRelocation(VAddr target_address, RelocationType relocation_type,
-    u32 addend, u32 symbol_address, u32 target_future_address) {
+                                      u32 addend, u32 symbol_address, u32 target_future_address) {
    switch (relocation_type) {
    case RelocationType::Nothing:
@@ -124,7 +115,8 @@ ResultCode CROHelper::ApplyRelocationBatch(VAddr batch, u32 symbol_address, bool
            return CROFormatError(0x12);
        }
-        ResultCode result = ApplyRelocation(relocation_target, relocation.type, relocation.addend, symbol_address, relocation_target);
+        ResultCode result = ApplyRelocation(relocation_target, relocation.type, relocation.addend,
+                                            symbol_address, relocation_target);
        if (result.IsError()) {
            LOG_ERROR(Service_LDR, "Error applying relocation %08X", result.raw);
            return result;
@@ -167,7 +159,7 @@ VAddr CROHelper::FindExportNamedSymbol(const std::string& name) const {
        if (test_byte >= len) {
            next.raw = entry.left.raw;
-        } else if((name[test_byte] >> test_bit_in_byte) & 1) {
+        } else if ((name[test_byte] >> test_bit_in_byte) & 1) {
            next.raw = entry.right.raw;
        } else {
            next.raw = entry.left.raw;
@@ -212,26 +204,13 @@ ResultCode CROHelper::RebaseHeader(u32 cro_size) {
        return error;
    // verifies that all offsets are in the correct order
-    constexpr std::array<HeaderField, 18> OFFSET_ORDER = {{
+    constexpr std::array<HeaderField, 18> OFFSET_ORDER = {
-        CodeOffset,
+        {CodeOffset, ModuleNameOffset, SegmentTableOffset, ExportNamedSymbolTableOffset,
-        ModuleNameOffset,
+         ExportTreeTableOffset, ExportIndexedSymbolTableOffset, ExportStringsOffset,
-        SegmentTableOffset,
+         ImportModuleTableOffset, ExternalRelocationTableOffset, ImportNamedSymbolTableOffset,
-        ExportNamedSymbolTableOffset,
+         ImportIndexedSymbolTableOffset, ImportAnonymousSymbolTableOffset, ImportStringsOffset,
-        ExportTreeTableOffset,
+         StaticAnonymousSymbolTableOffset, InternalRelocationTableOffset,
-        ExportIndexedSymbolTableOffset,
+         StaticRelocationTableOffset, DataOffset, FileSize}};
-        ExportStringsOffset,
-        ImportModuleTableOffset,
-        ExternalRelocationTableOffset,
-        ImportNamedSymbolTableOffset,
-        ImportIndexedSymbolTableOffset,
-        ImportAnonymousSymbolTableOffset,
-        ImportStringsOffset,
-        StaticAnonymousSymbolTableOffset,
-        InternalRelocationTableOffset,
-        StaticRelocationTableOffset,
-        DataOffset,
-        FileSize
-    }};
    u32 prev_offset = GetField(OFFSET_ORDER[0]);
    u32 cur_offset;
@@ -266,9 +245,9 @@ ResultCode CROHelper::RebaseHeader(u32 cro_size) {
    return RESULT_SUCCESS;
 }
-ResultVal<VAddr> CROHelper::RebaseSegmentTable(u32 cro_size,
+ResultVal<VAddr> CROHelper::RebaseSegmentTable(u32 cro_size, VAddr data_segment_address,
-    VAddr data_segment_address, u32 data_segment_size,
+                                               u32 data_segment_size, VAddr bss_segment_address,
-    VAddr bss_segment_address, u32 bss_segment_size) {
+                                               u32 bss_segment_size) {
    u32 prev_data_segment = 0;
    u32 segment_num = GetField(SegmentNum);
@@ -309,8 +288,8 @@ ResultCode CROHelper::RebaseExportNamedSymbolTable() {
        if (entry.name_offset != 0) {
            entry.name_offset += module_address;
-            if (entry.name_offset < export_strings_offset
+            if (entry.name_offset < export_strings_offset ||
-                || entry.name_offset >= export_strings_end) {
+                entry.name_offset >= export_strings_end) {
                return CROFormatError(0x11);
            }
        }
@@ -337,9 +316,13 @@ ResultCode CROHelper::RebaseImportModuleTable() {
    VAddr import_strings_offset = GetField(ImportStringsOffset);
    VAddr import_strings_end = import_strings_offset + GetField(ImportStringsSize);
    VAddr import_indexed_symbol_table_offset = GetField(ImportIndexedSymbolTableOffset);
-    VAddr index_import_table_end = import_indexed_symbol_table_offset + GetField(ImportIndexedSymbolNum) * sizeof(ImportIndexedSymbolEntry);
+    VAddr index_import_table_end =
+        import_indexed_symbol_table_offset +
+        GetField(ImportIndexedSymbolNum) * sizeof(ImportIndexedSymbolEntry);
    VAddr import_anonymous_symbol_table_offset = GetField(ImportAnonymousSymbolTableOffset);
-    VAddr offset_import_table_end = import_anonymous_symbol_table_offset + GetField(ImportAnonymousSymbolNum) * sizeof(ImportAnonymousSymbolEntry);
+    VAddr offset_import_table_end =
+        import_anonymous_symbol_table_offset +
+        GetField(ImportAnonymousSymbolNum) * sizeof(ImportAnonymousSymbolEntry);
    u32 module_num = GetField(ImportModuleNum);
    for (u32 i = 0; i < module_num; ++i) {
@@ -348,24 +331,24 @@ ResultCode CROHelper::RebaseImportModuleTable() {
        if (entry.name_offset != 0) {
            entry.name_offset += module_address;
-            if (entry.name_offset < import_strings_offset
+            if (entry.name_offset < import_strings_offset ||
-                || entry.name_offset >= import_strings_end) {
+                entry.name_offset >= import_strings_end) {
                return CROFormatError(0x18);
            }
        }
        if (entry.import_indexed_symbol_table_offset != 0) {
            entry.import_indexed_symbol_table_offset += module_address;
-            if (entry.import_indexed_symbol_table_offset < import_indexed_symbol_table_offset
+            if (entry.import_indexed_symbol_table_offset < import_indexed_symbol_table_offset ||
-                || entry.import_indexed_symbol_table_offset > index_import_table_end) {
+                entry.import_indexed_symbol_table_offset > index_import_table_end) {
                return CROFormatError(0x18);
            }
        }
        if (entry.import_anonymous_symbol_table_offset != 0) {
            entry.import_anonymous_symbol_table_offset += module_address;
-            if (entry.import_anonymous_symbol_table_offset < import_anonymous_symbol_table_offset
+            if (entry.import_anonymous_symbol_table_offset < import_anonymous_symbol_table_offset ||
-                || entry.import_anonymous_symbol_table_offset > offset_import_table_end) {
+                entry.import_anonymous_symbol_table_offset > offset_import_table_end) {
                return CROFormatError(0x18);
            }
        }
@@ -379,25 +362,27 @@ ResultCode CROHelper::RebaseImportNamedSymbolTable() {
    VAddr import_strings_offset = GetField(ImportStringsOffset);
    VAddr import_strings_end = import_strings_offset + GetField(ImportStringsSize);
    VAddr external_relocation_table_offset = GetField(ExternalRelocationTableOffset);
-    VAddr external_relocation_table_end = external_relocation_table_offset + GetField(ExternalRelocationNum) * sizeof(ExternalRelocationEntry);
+    VAddr external_relocation_table_end =
+        external_relocation_table_offset +
+        GetField(ExternalRelocationNum) * sizeof(ExternalRelocationEntry);
    u32 num = GetField(ImportNamedSymbolNum);
-    for (u32 i = 0; i < num ; ++i) {
+    for (u32 i = 0; i < num; ++i) {
        ImportNamedSymbolEntry entry;
        GetEntry(i, entry);
        if (entry.name_offset != 0) {
            entry.name_offset += module_address;
-            if (entry.name_offset < import_strings_offset
+            if (entry.name_offset < import_strings_offset ||
-                || entry.name_offset >= import_strings_end) {
+                entry.name_offset >= import_strings_end) {
                return CROFormatError(0x1B);
            }
        }
        if (entry.relocation_batch_offset != 0) {
            entry.relocation_batch_offset += module_address;
-            if (entry.relocation_batch_offset < external_relocation_table_offset
+            if (entry.relocation_batch_offset < external_relocation_table_offset ||
-                || entry.relocation_batch_offset > external_relocation_table_end) {
+                entry.relocation_batch_offset > external_relocation_table_end) {
                return CROFormatError(0x1B);
            }
        }
@@ -409,17 +394,19 @@ ResultCode CROHelper::RebaseImportNamedSymbolTable() {
 ResultCode CROHelper::RebaseImportIndexedSymbolTable() {
    VAddr external_relocation_table_offset = GetField(ExternalRelocationTableOffset);
-    VAddr external_relocation_table_end = external_relocation_table_offset + GetField(ExternalRelocationNum) * sizeof(ExternalRelocationEntry);
+    VAddr external_relocation_table_end =
+        external_relocation_table_offset +
+        GetField(ExternalRelocationNum) * sizeof(ExternalRelocationEntry);
    u32 num = GetField(ImportIndexedSymbolNum);
-    for (u32 i = 0; i < num ; ++i) {
+    for (u32 i = 0; i < num; ++i) {
        ImportIndexedSymbolEntry entry;
        GetEntry(i, entry);
        if (entry.relocation_batch_offset != 0) {
            entry.relocation_batch_offset += module_address;
-            if (entry.relocation_batch_offset < external_relocation_table_offset
+            if (entry.relocation_batch_offset < external_relocation_table_offset ||
-                || entry.relocation_batch_offset > external_relocation_table_end) {
+                entry.relocation_batch_offset > external_relocation_table_end) {
                return CROFormatError(0x14);
            }
        }
@@ -431,17 +418,19 @@ ResultCode CROHelper::RebaseImportIndexedSymbolTable() {
 ResultCode CROHelper::RebaseImportAnonymousSymbolTable() {
    VAddr external_relocation_table_offset = GetField(ExternalRelocationTableOffset);
-    VAddr external_relocation_table_end = external_relocation_table_offset + GetField(ExternalRelocationNum) * sizeof(ExternalRelocationEntry);
+    VAddr external_relocation_table_end =
+        external_relocation_table_offset +
+        GetField(ExternalRelocationNum) * sizeof(ExternalRelocationEntry);
    u32 num = GetField(ImportAnonymousSymbolNum);
-    for (u32 i = 0; i < num ; ++i) {
+    for (u32 i = 0; i < num; ++i) {
        ImportAnonymousSymbolEntry entry;
        GetEntry(i, entry);
        if (entry.relocation_batch_offset != 0) {
            entry.relocation_batch_offset += module_address;
-            if (entry.relocation_batch_offset < external_relocation_table_offset
+            if (entry.relocation_batch_offset < external_relocation_table_offset ||
-                || entry.relocation_batch_offset > external_relocation_table_end) {
+                entry.relocation_batch_offset > external_relocation_table_end) {
                return CROFormatError(0x17);
            }
        }
@@ -475,7 +464,8 @@ ResultCode CROHelper::ResetExternalRelocations() {
            return CROFormatError(0x12);
        }
-        ResultCode result = ApplyRelocation(relocation_target, relocation.type, relocation.addend, unresolved_symbol, relocation_target);
+        ResultCode result = ApplyRelocation(relocation_target, relocation.type, relocation.addend,
+                                            unresolved_symbol, relocation_target);
        if (result.IsError()) {
            LOG_ERROR(Service_LDR, "Error applying relocation %08X", result.raw);
            return result;
@@ -528,23 +518,27 @@ ResultCode CROHelper::ClearExternalRelocations() {
 ResultCode CROHelper::ApplyStaticAnonymousSymbolToCRS(VAddr crs_address) {
    VAddr static_relocation_table_offset = GetField(StaticRelocationTableOffset);
-    VAddr static_relocation_table_end = static_relocation_table_offset + GetField(StaticRelocationNum) * sizeof(StaticRelocationEntry);
+    VAddr static_relocation_table_end =
+        static_relocation_table_offset +
+        GetField(StaticRelocationNum) * sizeof(StaticRelocationEntry);
    CROHelper crs(crs_address);
    u32 offset_export_num = GetField(StaticAnonymousSymbolNum);
-    LOG_INFO(Service_LDR, "CRO \"%s\" exports %d static anonymous symbols", ModuleName().data(), offset_export_num);
+    LOG_INFO(Service_LDR, "CRO \"%s\" exports %d static anonymous symbols", ModuleName().data(),
+             offset_export_num);
    for (u32 i = 0; i < offset_export_num; ++i) {
        StaticAnonymousSymbolEntry entry;
        GetEntry(i, entry);
        u32 batch_address = entry.relocation_batch_offset + module_address;
-        if (batch_address < static_relocation_table_offset
+        if (batch_address < static_relocation_table_offset ||
-            || batch_address > static_relocation_table_end) {
+            batch_address > static_relocation_table_end) {
            return CROFormatError(0x16);
        }
        u32 symbol_address = SegmentTagToAddress(entry.symbol_position);
-        LOG_TRACE(Service_LDR, "CRO \"%s\" exports 0x%08X to the static module", ModuleName().data(), symbol_address);
+        LOG_TRACE(Service_LDR, "CRO \"%s\" exports 0x%08X to the static module",
+                  ModuleName().data(), symbol_address);
        ResultCode result = crs.ApplyRelocationBatch(batch_address, symbol_address);
        if (result.IsError()) {
            LOG_ERROR(Service_LDR, "Error applying relocation batch %08X", result.raw);
@@ -571,7 +565,8 @@ ResultCode CROHelper::ApplyInternalRelocations(u32 old_data_segment_address) {
        if (target_segment.type == SegmentType::Data) {
            // If the relocation is to the .data segment, we need to relocate it in the old buffer
-            target_address = old_data_segment_address + relocation.target_position.offset_into_segment;
+            target_address =
+                old_data_segment_address + relocation.target_position.offset_into_segment;
        } else {
            target_address = target_addressB;
        }
@@ -582,8 +577,10 @@ ResultCode CROHelper::ApplyInternalRelocations(u32 old_data_segment_address) {
        SegmentEntry symbol_segment;
        GetEntry(relocation.symbol_segment, symbol_segment);
-        LOG_TRACE(Service_LDR, "Internally relocates 0x%08X with 0x%08X", target_address, symbol_segment.offset);
+        LOG_TRACE(Service_LDR, "Internally relocates 0x%08X with 0x%08X", target_address,
-        ResultCode result = ApplyRelocation(target_address, relocation.type, relocation.addend, symbol_segment.offset, target_addressB);
+                  symbol_segment.offset);
+        ResultCode result = ApplyRelocation(target_address, relocation.type, relocation.addend,
+                                            symbol_segment.offset, target_addressB);
        if (result.IsError()) {
            LOG_ERROR(Service_LDR, "Error applying relocation %08X", result.raw);
            return result;
@@ -734,25 +731,29 @@ ResultCode CROHelper::ApplyImportNamedSymbol(VAddr crs_address) {
        Memory::ReadBlock(relocation_addr, &relocation_entry, sizeof(ExternalRelocationEntry));
        if (!relocation_entry.is_batch_resolved) {
-            ResultCode result = ForEachAutoLinkCRO(crs_address, [&](CROHelper source) -> ResultVal<bool> {
+            ResultCode result =
-                std::string symbol_name = Memory::ReadCString(entry.name_offset, import_strings_size);
+                ForEachAutoLinkCRO(crs_address, [&](CROHelper source) -> ResultVal<bool> {
-                u32 symbol_address = source.FindExportNamedSymbol(symbol_name);
+                    std::string symbol_name =
+                        Memory::ReadCString(entry.name_offset, import_strings_size);
-                if (symbol_address != 0) {
+                    u32 symbol_address = source.FindExportNamedSymbol(symbol_name);
-                    LOG_TRACE(Service_LDR, "CRO \"%s\" imports \"%s\" from \"%s\"",
-                        ModuleName().data(), symbol_name.data(), source.ModuleName().data());
+                    if (symbol_address != 0) {
+                        LOG_TRACE(Service_LDR, "CRO \"%s\" imports \"%s\" from \"%s\"",
-                    ResultCode result = ApplyRelocationBatch(relocation_addr, symbol_address);
+                                  ModuleName().data(), symbol_name.data(),
-                    if (result.IsError()) {
+                                  source.ModuleName().data());
-                        LOG_ERROR(Service_LDR, "Error applying relocation batch %08X", result.raw);
-                        return result;
+                        ResultCode result = ApplyRelocationBatch(relocation_addr, symbol_address);
+                        if (result.IsError()) {
+                            LOG_ERROR(Service_LDR, "Error applying relocation batch %08X",
+                                      result.raw);
+                            return result;
+                        }
+                        return MakeResult<bool>(false);
                    }
-                    return MakeResult<bool>(false);
+                    return MakeResult<bool>(true);
-                }
+                });
-                return MakeResult<bool>(true);
-            });
            if (result.IsError()) {
                return result;
            }
@@ -777,7 +778,6 @@ ResultCode CROHelper::ResetImportNamedSymbol() {
            LOG_ERROR(Service_LDR, "Error reseting relocation batch %08X", result.raw);
            return result;
        }
    }
    return RESULT_SUCCESS;
 }
@@ -831,40 +831,47 @@ ResultCode CROHelper::ApplyModuleImport(VAddr crs_address) {
        GetEntry(i, entry);
        std::string want_cro_name = Memory::ReadCString(entry.name_offset, import_strings_size);
-        ResultCode result = ForEachAutoLinkCRO(crs_address, [&](CROHelper source) -> ResultVal<bool> {
+        ResultCode result =
-            if (want_cro_name == source.ModuleName()) {
+            ForEachAutoLinkCRO(crs_address, [&](CROHelper source) -> ResultVal<bool> {
-                LOG_INFO(Service_LDR, "CRO \"%s\" imports %d indexed symbols from \"%s\"",
+                if (want_cro_name == source.ModuleName()) {
-                    ModuleName().data(), entry.import_indexed_symbol_num, source.ModuleName().data());
+                    LOG_INFO(Service_LDR, "CRO \"%s\" imports %d indexed symbols from \"%s\"",
-                for (u32 j = 0; j < entry.import_indexed_symbol_num; ++j) {
+                             ModuleName().data(), entry.import_indexed_symbol_num,
-                    ImportIndexedSymbolEntry im;
+                             source.ModuleName().data());
-                    entry.GetImportIndexedSymbolEntry(j, im);
+                    for (u32 j = 0; j < entry.import_indexed_symbol_num; ++j) {
-                    ExportIndexedSymbolEntry ex;
+                        ImportIndexedSymbolEntry im;
-                    source.GetEntry(im.index, ex);
+                        entry.GetImportIndexedSymbolEntry(j, im);
-                    u32 symbol_address = source.SegmentTagToAddress(ex.symbol_position);
+                        ExportIndexedSymbolEntry ex;
-                    LOG_TRACE(Service_LDR, "    Imports 0x%08X", symbol_address);
+                        source.GetEntry(im.index, ex);
-                    ResultCode result = ApplyRelocationBatch(im.relocation_batch_offset, symbol_address);
+                        u32 symbol_address = source.SegmentTagToAddress(ex.symbol_position);
-                    if (result.IsError()) {
+                        LOG_TRACE(Service_LDR, "    Imports 0x%08X", symbol_address);
-                        LOG_ERROR(Service_LDR, "Error applying relocation batch %08X", result.raw);
+                        ResultCode result =
-                        return result;
+                            ApplyRelocationBatch(im.relocation_batch_offset, symbol_address);
+                        if (result.IsError()) {
+                            LOG_ERROR(Service_LDR, "Error applying relocation batch %08X",
+                                      result.raw);
+                            return result;
+                        }
                    }
-                }
+                    LOG_INFO(Service_LDR, "CRO \"%s\" imports %d anonymous symbols from \"%s\"",
-                LOG_INFO(Service_LDR, "CRO \"%s\" imports %d anonymous symbols from \"%s\"",
+                             ModuleName().data(), entry.import_anonymous_symbol_num,
-                    ModuleName().data(), entry.import_anonymous_symbol_num, source.ModuleName().data());
+                             source.ModuleName().data());
-                for (u32 j = 0; j < entry.import_anonymous_symbol_num; ++j) {
+                    for (u32 j = 0; j < entry.import_anonymous_symbol_num; ++j) {
-                    ImportAnonymousSymbolEntry im;
+                        ImportAnonymousSymbolEntry im;
-                    entry.GetImportAnonymousSymbolEntry(j, im);
+                        entry.GetImportAnonymousSymbolEntry(j, im);
-                    u32 symbol_address = source.SegmentTagToAddress(im.symbol_position);
+                        u32 symbol_address = source.SegmentTagToAddress(im.symbol_position);
-                    LOG_TRACE(Service_LDR, "    Imports 0x%08X", symbol_address);
+                        LOG_TRACE(Service_LDR, "    Imports 0x%08X", symbol_address);
-                    ResultCode result = ApplyRelocationBatch(im.relocation_batch_offset, symbol_address);
+                        ResultCode result =
-                    if (result.IsError()) {
+                            ApplyRelocationBatch(im.relocation_batch_offset, symbol_address);
-                        LOG_ERROR(Service_LDR, "Error applying relocation batch %08X", result.raw);
+                        if (result.IsError()) {
-                        return result;
+                            LOG_ERROR(Service_LDR, "Error applying relocation batch %08X",
+                                      result.raw);
+                            return result;
+                        }
                    }
+                    return MakeResult<bool>(false);
                }
-                return MakeResult<bool>(false);
+                return MakeResult<bool>(true);
-            }
+            });
-            return MakeResult<bool>(true);
-        });
        if (result.IsError()) {
            return result;
        }
@@ -873,8 +880,8 @@ ResultCode CROHelper::ApplyModuleImport(VAddr crs_address) {
 }
 ResultCode CROHelper::ApplyExportNamedSymbol(CROHelper target) {
-    LOG_DEBUG(Service_LDR, "CRO \"%s\" exports named symbols to \"%s\"",
+    LOG_DEBUG(Service_LDR, "CRO \"%s\" exports named symbols to \"%s\"", ModuleName().data(),
-        ModuleName().data(), target.ModuleName().data());
+              target.ModuleName().data());
    u32 target_import_strings_size = target.GetField(ImportStringsSize);
    u32 target_symbol_import_num = target.GetField(ImportNamedSymbolNum);
    for (u32 i = 0; i < target_symbol_import_num; ++i) {
@@ -885,7 +892,8 @@ ResultCode CROHelper::ApplyExportNamedSymbol(CROHelper target) {
        Memory::ReadBlock(relocation_addr, &relocation_entry, sizeof(ExternalRelocationEntry));
        if (!relocation_entry.is_batch_resolved) {
-            std::string symbol_name = Memory::ReadCString(entry.name_offset, target_import_strings_size);
+            std::string symbol_name =
+                Memory::ReadCString(entry.name_offset, target_import_strings_size);
            u32 symbol_address = FindExportNamedSymbol(symbol_name);
            if (symbol_address != 0) {
                LOG_TRACE(Service_LDR, "    exports symbol \"%s\"", symbol_name.data());
@@ -901,8 +909,8 @@ ResultCode CROHelper::ApplyExportNamedSymbol(CROHelper target) {
 }
 ResultCode CROHelper::ResetExportNamedSymbol(CROHelper target) {
-    LOG_DEBUG(Service_LDR, "CRO \"%s\" unexports named symbols to \"%s\"",
+    LOG_DEBUG(Service_LDR, "CRO \"%s\" unexports named symbols to \"%s\"", ModuleName().data(),
-        ModuleName().data(), target.ModuleName().data());
+              target.ModuleName().data());
    u32 unresolved_symbol = target.GetOnUnresolvedAddress();
    u32 target_import_strings_size = target.GetField(ImportStringsSize);
    u32 target_symbol_import_num = target.GetField(ImportNamedSymbolNum);
@@ -914,11 +922,13 @@ ResultCode CROHelper::ResetExportNamedSymbol(CROHelper target) {
        Memory::ReadBlock(relocation_addr, &relocation_entry, sizeof(ExternalRelocationEntry));
        if (relocation_entry.is_batch_resolved) {
-            std::string symbol_name = Memory::ReadCString(entry.name_offset, target_import_strings_size);
+            std::string symbol_name =
+                Memory::ReadCString(entry.name_offset, target_import_strings_size);
            u32 symbol_address = FindExportNamedSymbol(symbol_name);
            if (symbol_address != 0) {
                LOG_TRACE(Service_LDR, "    unexports symbol \"%s\"", symbol_name.data());
-                ResultCode result = target.ApplyRelocationBatch(relocation_addr, unresolved_symbol, true);
+                ResultCode result =
+                    target.ApplyRelocationBatch(relocation_addr, unresolved_symbol, true);
                if (result.IsError()) {
                    LOG_ERROR(Service_LDR, "Error applying relocation batch %08X", result.raw);
                    return result;
@@ -940,8 +950,8 @@ ResultCode CROHelper::ApplyModuleExport(CROHelper target) {
        if (Memory::ReadCString(entry.name_offset, target_import_string_size) != module_name)
            continue;
-        LOG_INFO(Service_LDR, "CRO \"%s\" exports %d indexed symbols to \"%s\"",
+        LOG_INFO(Service_LDR, "CRO \"%s\" exports %d indexed symbols to \"%s\"", module_name.data(),
-            module_name.data(), entry.import_indexed_symbol_num, target.ModuleName().data());
+                 entry.import_indexed_symbol_num, target.ModuleName().data());
        for (u32 j = 0; j < entry.import_indexed_symbol_num; ++j) {
            ImportIndexedSymbolEntry im;
            entry.GetImportIndexedSymbolEntry(j, im);
@@ -949,7 +959,8 @@ ResultCode CROHelper::ApplyModuleExport(CROHelper target) {
            GetEntry(im.index, ex);
            u32 symbol_address = SegmentTagToAddress(ex.symbol_position);
            LOG_TRACE(Service_LDR, "    exports symbol 0x%08X", symbol_address);
-            ResultCode result = target.ApplyRelocationBatch(im.relocation_batch_offset, symbol_address);
+            ResultCode result =
+                target.ApplyRelocationBatch(im.relocation_batch_offset, symbol_address);
            if (result.IsError()) {
                LOG_ERROR(Service_LDR, "Error applying relocation batch %08X", result.raw);
                return result;
@@ -957,13 +968,14 @@ ResultCode CROHelper::ApplyModuleExport(CROHelper target) {
        }
        LOG_INFO(Service_LDR, "CRO \"%s\" exports %d anonymous symbols to \"%s\"",
-            module_name.data(), entry.import_anonymous_symbol_num, target.ModuleName().data());
+                 module_name.data(), entry.import_anonymous_symbol_num, target.ModuleName().data());
        for (u32 j = 0; j < entry.import_anonymous_symbol_num; ++j) {
            ImportAnonymousSymbolEntry im;
            entry.GetImportAnonymousSymbolEntry(j, im);
            u32 symbol_address = SegmentTagToAddress(im.symbol_position);
            LOG_TRACE(Service_LDR, "    exports symbol 0x%08X", symbol_address);
-            ResultCode result = target.ApplyRelocationBatch(im.relocation_batch_offset, symbol_address);
+            ResultCode result =
+                target.ApplyRelocationBatch(im.relocation_batch_offset, symbol_address);
            if (result.IsError()) {
                LOG_ERROR(Service_LDR, "Error applying relocation batch %08X", result.raw);
                return result;
@@ -987,12 +999,13 @@ ResultCode CROHelper::ResetModuleExport(CROHelper target) {
        if (Memory::ReadCString(entry.name_offset, target_import_string_size) != module_name)
            continue;
-        LOG_DEBUG(Service_LDR, "CRO \"%s\" unexports indexed symbols to \"%s\"",
+        LOG_DEBUG(Service_LDR, "CRO \"%s\" unexports indexed symbols to \"%s\"", module_name.data(),
-            module_name.data(), target.ModuleName().data());
+                  target.ModuleName().data());
        for (u32 j = 0; j < entry.import_indexed_symbol_num; ++j) {
            ImportIndexedSymbolEntry im;
            entry.GetImportIndexedSymbolEntry(j, im);
-            ResultCode result = target.ApplyRelocationBatch(im.relocation_batch_offset, unresolved_symbol, true);
+            ResultCode result =
+                target.ApplyRelocationBatch(im.relocation_batch_offset, unresolved_symbol, true);
            if (result.IsError()) {
                LOG_ERROR(Service_LDR, "Error applying relocation batch %08X", result.raw);
                return result;
@@ -1000,11 +1013,12 @@ ResultCode CROHelper::ResetModuleExport(CROHelper target) {
        }
        LOG_DEBUG(Service_LDR, "CRO \"%s\" unexports anonymous symbols to \"%s\"",
-            module_name.data(), target.ModuleName().data());
+                  module_name.data(), target.ModuleName().data());
        for (u32 j = 0; j < entry.import_anonymous_symbol_num; ++j) {
            ImportAnonymousSymbolEntry im;
            entry.GetImportAnonymousSymbolEntry(j, im);
-            ResultCode result = target.ApplyRelocationBatch(im.relocation_batch_offset, unresolved_symbol, true);
+            ResultCode result =
+                target.ApplyRelocationBatch(im.relocation_batch_offset, unresolved_symbol, true);
            if (result.IsError()) {
                LOG_ERROR(Service_LDR, "Error applying relocation batch %08X", result.raw);
                return result;
@@ -1025,25 +1039,27 @@ ResultCode CROHelper::ApplyExitRelocations(VAddr crs_address) {
        ExternalRelocationEntry relocation_entry;
        Memory::ReadBlock(relocation_addr, &relocation_entry, sizeof(ExternalRelocationEntry));
-        if (Memory::ReadCString(entry.name_offset, import_strings_size) == "__aeabi_atexit"){
+        if (Memory::ReadCString(entry.name_offset, import_strings_size) == "__aeabi_atexit") {
-            ResultCode result = ForEachAutoLinkCRO(crs_address, [&](CROHelper source) -> ResultVal<bool> {
+            ResultCode result =
-                u32 symbol_address = source.FindExportNamedSymbol("nnroAeabiAtexit_");
+                ForEachAutoLinkCRO(crs_address, [&](CROHelper source) -> ResultVal<bool> {
+                    u32 symbol_address = source.FindExportNamedSymbol("nnroAeabiAtexit_");
-                if (symbol_address != 0) {
+                    if (symbol_address != 0) {
-                    LOG_DEBUG(Service_LDR, "CRO \"%s\" import exit function from \"%s\"",
+                        LOG_DEBUG(Service_LDR, "CRO \"%s\" import exit function from \"%s\"",
-                        ModuleName().data(), source.ModuleName().data());
+                                  ModuleName().data(), source.ModuleName().data());
-                    ResultCode result = ApplyRelocationBatch(relocation_addr, symbol_address);
+                        ResultCode result = ApplyRelocationBatch(relocation_addr, symbol_address);
-                    if (result.IsError()) {
+                        if (result.IsError()) {
-                        LOG_ERROR(Service_LDR, "Error applying relocation batch %08X", result.raw);
+                            LOG_ERROR(Service_LDR, "Error applying relocation batch %08X",
-                        return result;
+                                      result.raw);
-                    }
+                            return result;
+                        }
-                    return MakeResult<bool>(false);
+                        return MakeResult<bool>(false);
-                }
+                    }
-                return MakeResult<bool>(true);
+                    return MakeResult<bool>(true);
-            });
+                });
            if (result.IsError()) {
                LOG_ERROR(Service_LDR, "Error applying exit relocation %08X", result.raw);
                return result;
@@ -1070,9 +1086,9 @@ static ResultCode VerifyStringTableLength(VAddr address, u32 size) {
    return RESULT_SUCCESS;
 }
-ResultCode CROHelper::Rebase(VAddr crs_address, u32 cro_size,
+ResultCode CROHelper::Rebase(VAddr crs_address, u32 cro_size, VAddr data_segment_addresss,
-    VAddr data_segment_addresss, u32 data_segment_size,
+                             u32 data_segment_size, VAddr bss_segment_address, u32 bss_segment_size,
-    VAddr bss_segment_address, u32 bss_segment_size, bool is_crs) {
+                             bool is_crs) {
    ResultCode result = RebaseHeader(cro_size);
    if (result.IsError()) {
@@ -1088,9 +1104,8 @@ ResultCode CROHelper::Rebase(VAddr crs_address, u32 cro_size,
    u32 prev_data_segment_address = 0;
    if (!is_crs) {
-        auto result_val = RebaseSegmentTable(cro_size,
+        auto result_val = RebaseSegmentTable(cro_size, data_segment_addresss, data_segment_size,
-            data_segment_addresss, data_segment_size,
+                                             bss_segment_address, bss_segment_size);
-            bss_segment_address, bss_segment_size);
        if (result_val.Failed()) {
            LOG_ERROR(Service_LDR, "Error rebasing segment table %08X", result_val.Code().raw);
            return result_val.Code();
@@ -1374,7 +1389,8 @@ void CROHelper::Unregister(VAddr crs_address) {
    CROHelper next_head(crs.NextModule()), previous_head(crs.PreviousModule());
    CROHelper next(NextModule()), previous(PreviousModule());
-    if (module_address == next_head.module_address || module_address == previous_head.module_address) {
+    if (module_address == next_head.module_address ||
+        module_address == previous_head.module_address) {
        // removing head
        if (next.module_address) {
            // the next is new head
@@ -1400,7 +1416,8 @@ void CROHelper::Unregister(VAddr crs_address) {
        // let head's previous point to the new tail
        if (next_head.module_address && next_head.PreviousModule() == module_address) {
            next_head.SetPreviousModule(previous.module_address);
-        } else if (previous_head.module_address && previous_head.PreviousModule() == module_address) {
+        } else if (previous_head.module_address &&
+                   previous_head.PreviousModule() == module_address) {
            previous_head.SetPreviousModule(previous.module_address);
        } else {
            UNREACHABLE();
@@ -1419,9 +1436,9 @@ u32 CROHelper::GetFixEnd(u32 fix_level) const {
    u32 entry_size_i = 2;
    int field = ModuleNameOffset;
    while (true) {
-        end = std::max<u32>(end,
+        end = std::max<u32>(end, GetField(static_cast<HeaderField>(field)) +
-            GetField(static_cast<HeaderField>(field)) +
+                                     GetField(static_cast<HeaderField>(field + 1)) *
-            GetField(static_cast<HeaderField>(field + 1)) * ENTRY_SIZE[entry_size_i]);
+                                         ENTRY_SIZE[entry_size_i]);
        ++entry_size_i;
        field += 2;
diff --git a/src/core/hle/service/ldr_ro/cro_helper.h b/src/core/hle/service/ldr_ro/cro_helper.h
index 34e357afd..e4457d4be 100644
--- a/src/core/hle/service/ldr_ro/cro_helper.h
+++ b/src/core/hle/service/ldr_ro/cro_helper.h
@@ -10,8 +10,8 @@
 #include "common/common_types.h"
 #include "common/swap.h"
-#include "core/memory.h"
 #include "core/hle/result.h"
+#include "core/memory.h"
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Namespace LDR_RO
@@ -21,14 +21,17 @@ namespace LDR_RO {
 // GCC versions < 5.0 do not implement std::is_trivially_copyable.
 // Excluding MSVC because it has weird behaviour for std::is_trivially_copyable.
 #if (__GNUC__ >= 5) || defined(__clang__)
-    #define ASSERT_CRO_STRUCT(name, size) \
+#define ASSERT_CRO_STRUCT(name, size)                                                              \
-        static_assert(std::is_standard_layout<name>::value, "CRO structure " #name " doesn't use standard layout"); \
+    static_assert(std::is_standard_layout<name>::value,                                            \
-        static_assert(std::is_trivially_copyable<name>::value, "CRO structure " #name " isn't trivially copyable"); \
+                  "CRO structure " #name " doesn't use standard layout");                          \
-        static_assert(sizeof(name) == (size), "Unexpected struct size for CRO structure " #name)
+    static_assert(std::is_trivially_copyable<name>::value,                                         \
+                  "CRO structure " #name " isn't trivially copyable");                             \
+    static_assert(sizeof(name) == (size), "Unexpected struct size for CRO structure " #name)
 #else
-    #define ASSERT_CRO_STRUCT(name, size) \
+#define ASSERT_CRO_STRUCT(name, size)                                                              \
-        static_assert(std::is_standard_layout<name>::value, "CRO structure " #name " doesn't use standard layout"); \
+    static_assert(std::is_standard_layout<name>::value,                                            \
-        static_assert(sizeof(name) == (size), "Unexpected struct size for CRO structure " #name)
+                  "CRO structure " #name " doesn't use standard layout");                          \
+    static_assert(sizeof(name) == (size), "Unexpected struct size for CRO structure " #name)
 #endif
 static constexpr u32 CRO_HEADER_SIZE = 0x138;
@@ -59,9 +62,9 @@ public:
     * @param is_crs true if the module itself is the static module
     * @returns ResultCode RESULT_SUCCESS on success, otherwise error code.
     */
-    ResultCode Rebase(VAddr crs_address, u32 cro_size,
+    ResultCode Rebase(VAddr crs_address, u32 cro_size, VAddr data_segment_addresss,
-        VAddr data_segment_addresss, u32 data_segment_size,
+                      u32 data_segment_size, VAddr bss_segment_address, u32 bss_segment_size,
-        VAddr bss_segment_address, u32 bss_segment_size, bool is_crs);
+                      bool is_crs);
    /**
     * Unrebases the module.
@@ -148,8 +151,10 @@ private:
    const VAddr module_address; ///< the virtual address of this module
    /**
-     * Each item in this enum represents a u32 field in the header begin from address+0x80, successively.
+     * Each item in this enum represents a u32 field in the header begin from address+0x80,
-     * We don't directly use a struct here, to avoid GetPointer, reinterpret_cast, or Read/WriteBlock repeatedly.
+     * successively.
+     * We don't directly use a struct here, to avoid GetPointer, reinterpret_cast, or
+     * Read/WriteBlock repeatedly.
     */
    enum HeaderField {
        Magic = 0,
@@ -208,18 +213,20 @@ private:
        Fix2Barrier = ImportModuleTableOffset,
        Fix1Barrier = StaticAnonymousSymbolTableOffset,
    };
-    static_assert(Fix0Barrier == (CRO_HEADER_SIZE - CRO_HASH_SIZE) / 4, "CRO Header fields are wrong!");
+    static_assert(Fix0Barrier == (CRO_HEADER_SIZE - CRO_HASH_SIZE) / 4,
+                  "CRO Header fields are wrong!");
    enum class SegmentType : u32 {
-        Code   = 0,
+        Code = 0,
        ROData = 1,
-        Data   = 2,
+        Data = 2,
-        BSS    = 3,
+        BSS = 3,
    };
    /**
     * Identifies a program location inside of a segment.
-     * Required to refer to program locations because individual segments may be relocated independently of each other.
+     * Required to refer to program locations because individual segments may be relocated
+     * independently of each other.
     */
    union SegmentTag {
        u32_le raw;
@@ -227,7 +234,8 @@ private:
        BitField<4, 28, u32_le> offset_into_segment;
        SegmentTag() = default;
-        explicit SegmentTag(u32 raw_) : raw(raw_) {}
+        explicit SegmentTag(u32 raw_) : raw(raw_) {
+        }
    };
    /// Information of a segment in this module.
@@ -282,7 +290,7 @@ private:
    /// Identifies an indexed symbol imported from another module.
    struct ImportIndexedSymbolEntry {
-        u32_le index;                   // index of an ExportIndexedSymbolEntry in the exporting module
+        u32_le index; // index of an ExportIndexedSymbolEntry in the exporting module
        u32_le relocation_batch_offset; // pointing to a relocation batch in ExternalRelocationTable
        static constexpr HeaderField TABLE_OFFSET_FIELD = ImportIndexedSymbolTableOffset;
@@ -291,8 +299,8 @@ private:
    /// Identifies an anonymous symbol imported from another module.
    struct ImportAnonymousSymbolEntry {
-        SegmentTag symbol_position;      // in the exporting segment
+        SegmentTag symbol_position;     // in the exporting segment
-        u32_le relocation_batch_offset;  // pointing to a relocation batch in ExternalRelocationTable
+        u32_le relocation_batch_offset; // pointing to a relocation batch in ExternalRelocationTable
        static constexpr HeaderField TABLE_OFFSET_FIELD = ImportAnonymousSymbolTableOffset;
    };
@@ -300,42 +308,47 @@ private:
    /// Information of a imported module and symbols imported from it.
    struct ImportModuleEntry {
-        u32_le name_offset;                          // pointing to a substring in ImportStrings
+        u32_le name_offset;                        // pointing to a substring in ImportStrings
-        u32_le import_indexed_symbol_table_offset;   // pointing to a subtable in ImportIndexedSymbolTable
+        u32_le import_indexed_symbol_table_offset; // pointing to a subtable in
+                                                   // ImportIndexedSymbolTable
        u32_le import_indexed_symbol_num;
-        u32_le import_anonymous_symbol_table_offset; // pointing to a subtable in ImportAnonymousSymbolTable
+        u32_le import_anonymous_symbol_table_offset; // pointing to a subtable in
+                                                     // ImportAnonymousSymbolTable
        u32_le import_anonymous_symbol_num;
        static constexpr HeaderField TABLE_OFFSET_FIELD = ImportModuleTableOffset;
        void GetImportIndexedSymbolEntry(u32 index, ImportIndexedSymbolEntry& entry) {
-            Memory::ReadBlock(import_indexed_symbol_table_offset + index * sizeof(ImportIndexedSymbolEntry),
+            Memory::ReadBlock(import_indexed_symbol_table_offset +
-                &entry, sizeof(ImportIndexedSymbolEntry));
+                                  index * sizeof(ImportIndexedSymbolEntry),
+                              &entry, sizeof(ImportIndexedSymbolEntry));
        }
        void GetImportAnonymousSymbolEntry(u32 index, ImportAnonymousSymbolEntry& entry) {
-            Memory::ReadBlock(import_anonymous_symbol_table_offset + index * sizeof(ImportAnonymousSymbolEntry),
+            Memory::ReadBlock(import_anonymous_symbol_table_offset +
-                &entry, sizeof(ImportAnonymousSymbolEntry));
+                                  index * sizeof(ImportAnonymousSymbolEntry),
+                              &entry, sizeof(ImportAnonymousSymbolEntry));
        }
    };
    ASSERT_CRO_STRUCT(ImportModuleEntry, 20);
    enum class RelocationType : u8 {
-        Nothing                = 0,
+        Nothing = 0,
-        AbsoluteAddress        = 2,
+        AbsoluteAddress = 2,
-        RelativeAddress        = 3,
+        RelativeAddress = 3,
-        ThumbBranch            = 10,
+        ThumbBranch = 10,
-        ArmBranch              = 28,
+        ArmBranch = 28,
-        ModifyArmBranch        = 29,
+        ModifyArmBranch = 29,
-        AbsoluteAddress2       = 38,
+        AbsoluteAddress2 = 38,
        AlignedRelativeAddress = 42,
    };
    struct RelocationEntry {
-        SegmentTag target_position; // to self's segment as an ExternalRelocationEntry; to static module segment as a StaticRelocationEntry
+        SegmentTag target_position; // to self's segment as an ExternalRelocationEntry; to static
+                                    // module segment as a StaticRelocationEntry
        RelocationType type;
        u8 is_batch_end;
-        u8 is_batch_resolved;       // set at a batch beginning if the batch is resolved
+        u8 is_batch_resolved; // set at a batch beginning if the batch is resolved
        INSERT_PADDING_BYTES(1);
        u32_le addend;
    };
@@ -366,8 +379,8 @@ private:
    /// Identifies a special static anonymous symbol (no game is known using this).
    struct StaticAnonymousSymbolEntry {
-        SegmentTag symbol_position;      // to self's segment
+        SegmentTag symbol_position;     // to self's segment
-        u32_le relocation_batch_offset;  // pointing to a relocation batch in StaticRelocationTable
+        u32_le relocation_batch_offset; // pointing to a relocation batch in StaticRelocationTable
        static constexpr HeaderField TABLE_OFFSET_FIELD = StaticAnonymousSymbolTableOffset;
    };
@@ -446,12 +459,15 @@ private:
    }
    /**
-     * A helper function iterating over all registered auto-link modules, including the static module.
+     * A helper function iterating over all registered auto-link modules, including the static
+     * module.
     * @param crs_address the virtual address of the static module
     * @param func a function object to operate on a module. It accepts one parameter
-     *        CROHelper and returns ResultVal<bool>. It should return true to continue the iteration,
+     *        CROHelper and returns ResultVal<bool>. It should return true to continue the
+     * iteration,
     *        false to stop the iteration, or an error code (which will also stop the iteration).
-     * @returns ResultCode indicating the result of the operation, RESULT_SUCCESS if all iteration success,
+     * @returns ResultCode indicating the result of the operation, RESULT_SUCCESS if all iteration
+     * success,
     *         otherwise error code of the last iteration.
     */
    template <typename FunctionObject>
@@ -477,8 +493,8 @@ private:
     *        Usually equals to target_address, but will be different for a target in .data segment
     * @returns ResultCode RESULT_SUCCESS on success, otherwise error code.
     */
-    ResultCode ApplyRelocation(VAddr target_address, RelocationType relocation_type,
+    ResultCode ApplyRelocation(VAddr target_address, RelocationType relocation_type, u32 addend,
-        u32 addend, u32 symbol_address, u32 target_future_address);
+                               u32 symbol_address, u32 target_future_address);
    /**
     * Clears a relocation to zero
@@ -492,7 +508,8 @@ private:
     * Applies or resets a batch of relocations
     * @param batch the virtual address of the first relocation in the batch
     * @param symbol_address the symbol address to be relocated with
-     * @param reset false to set the batch to resolved state, true to reset the batch to unresolved state
+     * @param reset false to set the batch to resolved state, true to reset the batch to unresolved
+     * state
     * @returns ResultCode RESULT_SUCCESS on success, otherwise error code.
     */
    ResultCode ApplyRelocationBatch(VAddr batch, u32 symbol_address, bool reset = false);
@@ -507,7 +524,8 @@ private:
    /**
     * Rebases offsets in module header according to module address.
     * @param cro_size the size of the CRO file
-     * @returns ResultCode RESULT_SUCCESS if all offsets are verified as valid, otherwise error code.
+     * @returns ResultCode RESULT_SUCCESS if all offsets are verified as valid, otherwise error
+     * code.
     */
    ResultCode RebaseHeader(u32 cro_size);
@@ -520,43 +538,49 @@ private:
     * @param bss_segment_size the buffer size for .bss segment
     * @returns ResultVal<VAddr> with the virtual address of .data segment in CRO.
     */
-    ResultVal<VAddr> RebaseSegmentTable(u32 cro_size,
+    ResultVal<VAddr> RebaseSegmentTable(u32 cro_size, VAddr data_segment_address,
-        VAddr data_segment_address, u32 data_segment_size,
+                                        u32 data_segment_size, VAddr bss_segment_address,
-        VAddr bss_segment_address, u32 bss_segment_size);
+                                        u32 bss_segment_size);
    /**
     * Rebases offsets in exported named symbol table according to module address.
-     * @returns ResultCode RESULT_SUCCESS if all offsets are verified as valid, otherwise error code.
+     * @returns ResultCode RESULT_SUCCESS if all offsets are verified as valid, otherwise error
+     * code.
     */
    ResultCode RebaseExportNamedSymbolTable();
    /**
     * Verifies indices in export tree table.
-     * @returns ResultCode RESULT_SUCCESS if all indices are verified as valid, otherwise error code.
+     * @returns ResultCode RESULT_SUCCESS if all indices are verified as valid, otherwise error
+     * code.
     */
    ResultCode VerifyExportTreeTable() const;
    /**
     * Rebases offsets in exported module table according to module address.
-     * @returns ResultCode RESULT_SUCCESS if all offsets are verified as valid, otherwise error code.
+     * @returns ResultCode RESULT_SUCCESS if all offsets are verified as valid, otherwise error
+     * code.
     */
    ResultCode RebaseImportModuleTable();
    /**
     * Rebases offsets in imported named symbol table according to module address.
-     * @returns ResultCode RESULT_SUCCESS if all offsets are verified as valid, otherwise error code.
+     * @returns ResultCode RESULT_SUCCESS if all offsets are verified as valid, otherwise error
+     * code.
     */
    ResultCode RebaseImportNamedSymbolTable();
    /**
     * Rebases offsets in imported indexed symbol table according to module address.
-     * @returns ResultCode RESULT_SUCCESS if all offsets are verified as valid, otherwise error code.
+     * @returns ResultCode RESULT_SUCCESS if all offsets are verified as valid, otherwise error
+     * code.
     */
    ResultCode RebaseImportIndexedSymbolTable();
    /**
     * Rebases offsets in imported anonymous symbol table according to module address.
-     * @returns ResultCode RESULT_SUCCESS if all offsets are verified as valid, otherwise error code.
+     * @returns ResultCode RESULT_SUCCESS if all offsets are verified as valid, otherwise error
+     * code.
     */
    ResultCode RebaseImportAnonymousSymbolTable();
@@ -621,7 +645,8 @@ private:
    void UnrebaseHeader();
    /**
-     * Looks up all imported named symbols of this module in all registered auto-link modules, and resolves them if found.
+     * Looks up all imported named symbols of this module in all registered auto-link modules, and
+     * resolves them if found.
     * @param crs_address the virtual address of the static module
     * @returns ResultCode RESULT_SUCCESS on success, otherwise error code.
     */
@@ -646,7 +671,8 @@ private:
    ResultCode ResetImportAnonymousSymbol();
    /**
-     * Finds registered auto-link modules that this module imports, and resolves indexed and anonymous symbols exported by them.
+     * Finds registered auto-link modules that this module imports, and resolves indexed and
+     * anonymous symbols exported by them.
     * @param crs_address the virtual address of the static module
     * @returns ResultCode RESULT_SUCCESS on success, otherwise error code.
     */
@@ -667,7 +693,8 @@ private:
    ResultCode ResetExportNamedSymbol(CROHelper target);
    /**
-     * Resolves imported indexed and anonymous symbols in the target module which imports this module.
+     * Resolves imported indexed and anonymous symbols in the target module which imports this
+     * module.
     * @param target the module to resolve.
     * @returns ResultCode RESULT_SUCCESS on success, otherwise error code.
     */
diff --git a/src/core/hle/service/ldr_ro/ldr_ro.cpp b/src/core/hle/service/ldr_ro/ldr_ro.cpp
index 8ba73ea8d..ae5d3921f 100644
--- a/src/core/hle/service/ldr_ro/ldr_ro.cpp
+++ b/src/core/hle/service/ldr_ro/ldr_ro.cpp
@@ -18,24 +18,33 @@
 namespace LDR_RO {
-static const ResultCode ERROR_ALREADY_INITIALIZED =   // 0xD9612FF9
+static const ResultCode ERROR_ALREADY_INITIALIZED = // 0xD9612FF9
-    ResultCode(ErrorDescription::AlreadyInitialized,         ErrorModule::RO, ErrorSummary::Internal,        ErrorLevel::Permanent);
+    ResultCode(ErrorDescription::AlreadyInitialized, ErrorModule::RO, ErrorSummary::Internal,
-static const ResultCode ERROR_NOT_INITIALIZED =       // 0xD9612FF8
+               ErrorLevel::Permanent);
-    ResultCode(ErrorDescription::NotInitialized,             ErrorModule::RO, ErrorSummary::Internal,        ErrorLevel::Permanent);
+static const ResultCode ERROR_NOT_INITIALIZED = // 0xD9612FF8
-static const ResultCode ERROR_BUFFER_TOO_SMALL =      // 0xE0E12C1F
+    ResultCode(ErrorDescription::NotInitialized, ErrorModule::RO, ErrorSummary::Internal,
-    ResultCode(static_cast<ErrorDescription>(31),            ErrorModule::RO, ErrorSummary::InvalidArgument, ErrorLevel::Usage);
+               ErrorLevel::Permanent);
-static const ResultCode ERROR_MISALIGNED_ADDRESS =    // 0xD9012FF1
+static const ResultCode ERROR_BUFFER_TOO_SMALL = // 0xE0E12C1F
-    ResultCode(ErrorDescription::MisalignedAddress,          ErrorModule::RO, ErrorSummary::WrongArgument,   ErrorLevel::Permanent);
+    ResultCode(static_cast<ErrorDescription>(31), ErrorModule::RO, ErrorSummary::InvalidArgument,
-static const ResultCode ERROR_MISALIGNED_SIZE =       // 0xD9012FF2
+               ErrorLevel::Usage);
-    ResultCode(ErrorDescription::MisalignedSize,             ErrorModule::RO, ErrorSummary::WrongArgument,   ErrorLevel::Permanent);
+static const ResultCode ERROR_MISALIGNED_ADDRESS = // 0xD9012FF1
-static const ResultCode ERROR_ILLEGAL_ADDRESS =       // 0xE1612C0F
+    ResultCode(ErrorDescription::MisalignedAddress, ErrorModule::RO, ErrorSummary::WrongArgument,
-    ResultCode(static_cast<ErrorDescription>(15),            ErrorModule::RO, ErrorSummary::Internal,        ErrorLevel::Usage);
+               ErrorLevel::Permanent);
-static const ResultCode ERROR_INVALID_MEMORY_STATE =  // 0xD8A12C08
+static const ResultCode ERROR_MISALIGNED_SIZE = // 0xD9012FF2
-    ResultCode(static_cast<ErrorDescription>(8),             ErrorModule::RO, ErrorSummary::InvalidState,    ErrorLevel::Permanent);
+    ResultCode(ErrorDescription::MisalignedSize, ErrorModule::RO, ErrorSummary::WrongArgument,
-static const ResultCode ERROR_NOT_LOADED =            // 0xD8A12C0D
+               ErrorLevel::Permanent);
-    ResultCode(static_cast<ErrorDescription>(13),            ErrorModule::RO, ErrorSummary::InvalidState,    ErrorLevel::Permanent);
+static const ResultCode ERROR_ILLEGAL_ADDRESS = // 0xE1612C0F
-static const ResultCode ERROR_INVALID_DESCRIPTOR =    // 0xD9001830
+    ResultCode(static_cast<ErrorDescription>(15), ErrorModule::RO, ErrorSummary::Internal,
-    ResultCode(ErrorDescription::OS_InvalidBufferDescriptor, ErrorModule::OS, ErrorSummary::WrongArgument,   ErrorLevel::Permanent);
+               ErrorLevel::Usage);
+static const ResultCode ERROR_INVALID_MEMORY_STATE = // 0xD8A12C08
+    ResultCode(static_cast<ErrorDescription>(8), ErrorModule::RO, ErrorSummary::InvalidState,
+               ErrorLevel::Permanent);
+static const ResultCode ERROR_NOT_LOADED = // 0xD8A12C0D
+    ResultCode(static_cast<ErrorDescription>(13), ErrorModule::RO, ErrorSummary::InvalidState,
+               ErrorLevel::Permanent);
+static const ResultCode ERROR_INVALID_DESCRIPTOR = // 0xD9001830
+    ResultCode(ErrorDescription::OS_InvalidBufferDescriptor, ErrorModule::OS,
+               ErrorSummary::WrongArgument, ErrorLevel::Permanent);
 static MemorySynchronizer memory_synchronizer;
@@ -44,10 +53,10 @@ static VAddr loaded_crs; ///< the virtual address of the static module
 static bool VerifyBufferState(VAddr buffer_ptr, u32 size) {
    auto vma = Kernel::g_current_process->vm_manager.FindVMA(buffer_ptr);
-    return vma != Kernel::g_current_process->vm_manager.vma_map.end()
+    return vma != Kernel::g_current_process->vm_manager.vma_map.end() &&
-        && vma->second.base + vma->second.size >= buffer_ptr + size
+           vma->second.base + vma->second.size >= buffer_ptr + size &&
-        && vma->second.permissions == Kernel::VMAPermission::ReadWrite
+           vma->second.permissions == Kernel::VMAPermission::ReadWrite &&
-        && vma->second.meminfo_state == Kernel::MemoryState::Private;
+           vma->second.meminfo_state == Kernel::MemoryState::Private;
 }
 /**
@@ -66,13 +75,14 @@ static bool VerifyBufferState(VAddr buffer_ptr, u32 size) {
 static void Initialize(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    VAddr crs_buffer_ptr = cmd_buff[1];
-    u32 crs_size         = cmd_buff[2];
+    u32 crs_size = cmd_buff[2];
-    VAddr crs_address    = cmd_buff[3];
+    VAddr crs_address = cmd_buff[3];
-    u32 descriptor       = cmd_buff[4];
+    u32 descriptor = cmd_buff[4];
-    u32 process          = cmd_buff[5];
+    u32 process = cmd_buff[5];
-    LOG_DEBUG(Service_LDR, "called, crs_buffer_ptr=0x%08X, crs_address=0x%08X, crs_size=0x%X, descriptor=0x%08X, process=0x%08X",
+    LOG_DEBUG(Service_LDR, "called, crs_buffer_ptr=0x%08X, crs_address=0x%08X, crs_size=0x%X, "
-                crs_buffer_ptr, crs_address, crs_size, descriptor, process);
+                           "descriptor=0x%08X, process=0x%08X",
+              crs_buffer_ptr, crs_address, crs_size, descriptor, process);
    if (descriptor != 0) {
        LOG_ERROR(Service_LDR, "IPC handle descriptor failed validation (0x%X)", descriptor);
@@ -119,7 +129,8 @@ static void Initialize(Service::Interface* self) {
        return;
    }
-    if (crs_address < Memory::PROCESS_IMAGE_VADDR || crs_address + crs_size > Memory::PROCESS_IMAGE_VADDR_END) {
+    if (crs_address < Memory::PROCESS_IMAGE_VADDR ||
+        crs_address + crs_size > Memory::PROCESS_IMAGE_VADDR_END) {
        LOG_ERROR(Service_LDR, "CRS mapping address is not in the process image region");
        cmd_buff[1] = ERROR_ILLEGAL_ADDRESS.raw;
        return;
@@ -131,14 +142,17 @@ static void Initialize(Service::Interface* self) {
        // TODO(wwylele): should be memory aliasing
        std::shared_ptr<std::vector<u8>> crs_mem = std::make_shared<std::vector<u8>>(crs_size);
        Memory::ReadBlock(crs_buffer_ptr, crs_mem->data(), crs_size);
-        result = Kernel::g_current_process->vm_manager.MapMemoryBlock(crs_address, crs_mem, 0, crs_size, Kernel::MemoryState::Code).Code();
+        result = Kernel::g_current_process->vm_manager
+                     .MapMemoryBlock(crs_address, crs_mem, 0, crs_size, Kernel::MemoryState::Code)
+                     .Code();
        if (result.IsError()) {
            LOG_ERROR(Service_LDR, "Error mapping memory block %08X", result.raw);
            cmd_buff[1] = result.raw;
            return;
        }
-        result = Kernel::g_current_process->vm_manager.ReprotectRange(crs_address, crs_size, Kernel::VMAPermission::Read);
+        result = Kernel::g_current_process->vm_manager.ReprotectRange(crs_address, crs_size,
+                                                                      Kernel::VMAPermission::Read);
        if (result.IsError()) {
            LOG_ERROR(Service_LDR, "Error reprotecting memory block %08X", result.raw);
            cmd_buff[1] = result.raw;
@@ -186,9 +200,9 @@ static void Initialize(Service::Interface* self) {
 static void LoadCRR(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    u32 crr_buffer_ptr = cmd_buff[1];
-    u32 crr_size       = cmd_buff[2];
+    u32 crr_size = cmd_buff[2];
-    u32 descriptor     = cmd_buff[3];
+    u32 descriptor = cmd_buff[3];
-    u32 process        = cmd_buff[4];
+    u32 process = cmd_buff[4];
    if (descriptor != 0) {
        LOG_ERROR(Service_LDR, "IPC handle descriptor failed validation (0x%X)", descriptor);
@@ -200,7 +214,8 @@ static void LoadCRR(Service::Interface* self) {
    cmd_buff[0] = IPC::MakeHeader(2, 1, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
-    LOG_WARNING(Service_LDR, "(STUBBED) called, crr_buffer_ptr=0x%08X, crr_size=0x%08X, descriptor=0x%08X, process=0x%08X",
+    LOG_WARNING(Service_LDR, "(STUBBED) called, crr_buffer_ptr=0x%08X, crr_size=0x%08X, "
+                             "descriptor=0x%08X, process=0x%08X",
                crr_buffer_ptr, crr_size, descriptor, process);
 }
@@ -218,8 +233,8 @@ static void LoadCRR(Service::Interface* self) {
 static void UnloadCRR(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    u32 crr_buffer_ptr = cmd_buff[1];
-    u32 descriptor     = cmd_buff[2];
+    u32 descriptor = cmd_buff[2];
-    u32 process        = cmd_buff[3];
+    u32 process = cmd_buff[3];
    if (descriptor != 0) {
        LOG_ERROR(Service_LDR, "IPC handle descriptor failed validation (0x%X)", descriptor);
@@ -231,7 +246,8 @@ static void UnloadCRR(Service::Interface* self) {
    cmd_buff[0] = IPC::MakeHeader(3, 1, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
-    LOG_WARNING(Service_LDR, "(STUBBED) called, crr_buffer_ptr=0x%08X, descriptor=0x%08X, process=0x%08X",
+    LOG_WARNING(Service_LDR,
+                "(STUBBED) called, crr_buffer_ptr=0x%08X, descriptor=0x%08X, process=0x%08X",
                crr_buffer_ptr, descriptor, process);
 }
@@ -263,27 +279,28 @@ static void UnloadCRR(Service::Interface* self) {
 */
 static void LoadCRO(Service::Interface* self, bool link_on_load_bug_fix) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
-    VAddr cro_buffer_ptr       = cmd_buff[1];
+    VAddr cro_buffer_ptr = cmd_buff[1];
-    VAddr cro_address          = cmd_buff[2];
+    VAddr cro_address = cmd_buff[2];
-    u32 cro_size               = cmd_buff[3];
+    u32 cro_size = cmd_buff[3];
    VAddr data_segment_address = cmd_buff[4];
-    u32 zero                   = cmd_buff[5];
+    u32 zero = cmd_buff[5];
-    u32 data_segment_size      = cmd_buff[6];
+    u32 data_segment_size = cmd_buff[6];
-    u32 bss_segment_address    = cmd_buff[7];
+    u32 bss_segment_address = cmd_buff[7];
-    u32 bss_segment_size       = cmd_buff[8];
+    u32 bss_segment_size = cmd_buff[8];
-    bool auto_link             = (cmd_buff[9] & 0xFF) != 0;
+    bool auto_link = (cmd_buff[9] & 0xFF) != 0;
-    u32 fix_level              = cmd_buff[10];
+    u32 fix_level = cmd_buff[10];
-    VAddr crr_address          = cmd_buff[11];
+    VAddr crr_address = cmd_buff[11];
-    u32 descriptor             = cmd_buff[12];
+    u32 descriptor = cmd_buff[12];
-    u32 process                = cmd_buff[13];
+    u32 process = cmd_buff[13];
-    LOG_DEBUG(Service_LDR, "called (%s), cro_buffer_ptr=0x%08X, cro_address=0x%08X, cro_size=0x%X, "
+    LOG_DEBUG(Service_LDR,
-        "data_segment_address=0x%08X, zero=%d, data_segment_size=0x%X, bss_segment_address=0x%08X, bss_segment_size=0x%X, "
+              "called (%s), cro_buffer_ptr=0x%08X, cro_address=0x%08X, cro_size=0x%X, "
-        "auto_link=%s, fix_level=%d, crr_address=0x%08X, descriptor=0x%08X, process=0x%08X",
+              "data_segment_address=0x%08X, zero=%d, data_segment_size=0x%X, "
-        link_on_load_bug_fix ? "new" : "old", cro_buffer_ptr, cro_address, cro_size,
+              "bss_segment_address=0x%08X, bss_segment_size=0x%X, "
-        data_segment_address, zero, data_segment_size, bss_segment_address, bss_segment_size,
+              "auto_link=%s, fix_level=%d, crr_address=0x%08X, descriptor=0x%08X, process=0x%08X",
-        auto_link ? "true" : "false", fix_level, crr_address, descriptor, process
+              link_on_load_bug_fix ? "new" : "old", cro_buffer_ptr, cro_address, cro_size,
-        );
+              data_segment_address, zero, data_segment_size, bss_segment_address, bss_segment_size,
+              auto_link ? "true" : "false", fix_level, crr_address, descriptor, process);
    if (descriptor != 0) {
        LOG_ERROR(Service_LDR, "IPC handle descriptor failed validation (0x%X)", descriptor);
@@ -330,8 +347,8 @@ static void LoadCRO(Service::Interface* self, bool link_on_load_bug_fix) {
        return;
    }
-    if (cro_address < Memory::PROCESS_IMAGE_VADDR
+    if (cro_address < Memory::PROCESS_IMAGE_VADDR ||
-        || cro_address + cro_size > Memory::PROCESS_IMAGE_VADDR_END) {
+        cro_address + cro_size > Memory::PROCESS_IMAGE_VADDR_END) {
        LOG_ERROR(Service_LDR, "CRO mapping address is not in the process image region");
        cmd_buff[1] = ERROR_ILLEGAL_ADDRESS.raw;
        return;
@@ -339,7 +356,9 @@ static void LoadCRO(Service::Interface* self, bool link_on_load_bug_fix) {
    if (zero) {
        LOG_ERROR(Service_LDR, "Zero is not zero %d", zero);
-        cmd_buff[1] = ResultCode(static_cast<ErrorDescription>(29), ErrorModule::RO, ErrorSummary::Internal, ErrorLevel::Usage).raw;
+        cmd_buff[1] = ResultCode(static_cast<ErrorDescription>(29), ErrorModule::RO,
+                                 ErrorSummary::Internal, ErrorLevel::Usage)
+                          .raw;
        return;
    }
@@ -349,14 +368,17 @@ static void LoadCRO(Service::Interface* self, bool link_on_load_bug_fix) {
        // TODO(wwylele): should be memory aliasing
        std::shared_ptr<std::vector<u8>> cro_mem = std::make_shared<std::vector<u8>>(cro_size);
        Memory::ReadBlock(cro_buffer_ptr, cro_mem->data(), cro_size);
-        result = Kernel::g_current_process->vm_manager.MapMemoryBlock(cro_address, cro_mem, 0, cro_size, Kernel::MemoryState::Code).Code();
+        result = Kernel::g_current_process->vm_manager
+                     .MapMemoryBlock(cro_address, cro_mem, 0, cro_size, Kernel::MemoryState::Code)
+                     .Code();
        if (result.IsError()) {
            LOG_ERROR(Service_LDR, "Error mapping memory block %08X", result.raw);
            cmd_buff[1] = result.raw;
            return;
        }
-        result = Kernel::g_current_process->vm_manager.ReprotectRange(cro_address, cro_size, Kernel::VMAPermission::Read);
+        result = Kernel::g_current_process->vm_manager.ReprotectRange(cro_address, cro_size,
+                                                                      Kernel::VMAPermission::Read);
        if (result.IsError()) {
            LOG_ERROR(Service_LDR, "Error reprotecting memory block %08X", result.raw);
            Kernel::g_current_process->vm_manager.UnmapRange(cro_address, cro_size);
@@ -384,7 +406,8 @@ static void LoadCRO(Service::Interface* self, bool link_on_load_bug_fix) {
        return;
    }
-    result = cro.Rebase(loaded_crs, cro_size, data_segment_address, data_segment_size, bss_segment_address, bss_segment_size, false);
+    result = cro.Rebase(loaded_crs, cro_size, data_segment_address, data_segment_size,
+                        bss_segment_address, bss_segment_size, false);
    if (result.IsError()) {
        LOG_ERROR(Service_LDR, "Error rebasing CRO %08X", result.raw);
        Kernel::g_current_process->vm_manager.UnmapRange(cro_address, cro_size);
@@ -409,7 +432,8 @@ static void LoadCRO(Service::Interface* self, bool link_on_load_bug_fix) {
    // TODO(wwylele): verify the behaviour when buffer_ptr == address
    if (cro_buffer_ptr != cro_address) {
        if (fix_size != cro_size) {
-            result = Kernel::g_current_process->vm_manager.UnmapRange(cro_address + fix_size, cro_size - fix_size);
+            result = Kernel::g_current_process->vm_manager.UnmapRange(cro_address + fix_size,
+                                                                      cro_size - fix_size);
            if (result.IsError()) {
                LOG_ERROR(Service_LDR, "Error unmapping memory block %08X", result.raw);
                Kernel::g_current_process->vm_manager.UnmapRange(cro_address, cro_size);
@@ -426,7 +450,8 @@ static void LoadCRO(Service::Interface* self, bool link_on_load_bug_fix) {
    u32 exe_size;
    std::tie(exe_begin, exe_size) = cro.GetExecutablePages();
    if (exe_begin) {
-        result = Kernel::g_current_process->vm_manager.ReprotectRange(exe_begin, exe_size, Kernel::VMAPermission::ReadExecute);
+        result = Kernel::g_current_process->vm_manager.ReprotectRange(
+            exe_begin, exe_size, Kernel::VMAPermission::ReadExecute);
        if (result.IsError()) {
            LOG_ERROR(Service_LDR, "Error reprotecting memory block %08X", result.raw);
            Kernel::g_current_process->vm_manager.UnmapRange(cro_address, fix_size);
@@ -437,8 +462,8 @@ static void LoadCRO(Service::Interface* self, bool link_on_load_bug_fix) {
    Core::g_app_core->ClearInstructionCache();
-    LOG_INFO(Service_LDR, "CRO \"%s\" loaded at 0x%08X, fixed_end=0x%08X",
+    LOG_INFO(Service_LDR, "CRO \"%s\" loaded at 0x%08X, fixed_end=0x%08X", cro.ModuleName().data(),
-        cro.ModuleName().data(), cro_address, cro_address+fix_size);
+             cro_address, cro_address + fix_size);
    cmd_buff[1] = RESULT_SUCCESS.raw;
    cmd_buff[2] = fix_size;
@@ -464,14 +489,15 @@ static void LoadCRO(Service::Interface* self) {
 */
 static void UnloadCRO(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
-    VAddr cro_address      = cmd_buff[1];
+    VAddr cro_address = cmd_buff[1];
-    u32 zero               = cmd_buff[2];
+    u32 zero = cmd_buff[2];
-    VAddr cro_buffer_ptr   = cmd_buff[3];
+    VAddr cro_buffer_ptr = cmd_buff[3];
-    u32 descriptor         = cmd_buff[4];
+    u32 descriptor = cmd_buff[4];
-    u32 process            = cmd_buff[5];
+    u32 process = cmd_buff[5];
-    LOG_DEBUG(Service_LDR, "called, cro_address=0x%08X, zero=%d, cro_buffer_ptr=0x%08X, descriptor=0x%08X, process=0x%08X",
+    LOG_DEBUG(Service_LDR, "called, cro_address=0x%08X, zero=%d, cro_buffer_ptr=0x%08X, "
-        cro_address, zero, cro_buffer_ptr, descriptor, process);
+                           "descriptor=0x%08X, process=0x%08X",
+              cro_address, zero, cro_buffer_ptr, descriptor, process);
    if (descriptor != 0) {
        LOG_ERROR(Service_LDR, "IPC handle descriptor failed validation (0x%X)", descriptor);
@@ -558,11 +584,11 @@ static void UnloadCRO(Service::Interface* self) {
 static void LinkCRO(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    VAddr cro_address = cmd_buff[1];
-    u32 descriptor    = cmd_buff[2];
+    u32 descriptor = cmd_buff[2];
-    u32 process       = cmd_buff[3];
+    u32 process = cmd_buff[3];
    LOG_DEBUG(Service_LDR, "called, cro_address=0x%08X, descriptor=0x%08X, process=0x%08X",
-        cro_address, descriptor, process);
+              cro_address, descriptor, process);
    if (descriptor != 0) {
        LOG_ERROR(Service_LDR, "IPC handle descriptor failed validation (0x%X)", descriptor);
@@ -620,11 +646,11 @@ static void LinkCRO(Service::Interface* self) {
 static void UnlinkCRO(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    VAddr cro_address = cmd_buff[1];
-    u32 descriptor    = cmd_buff[2];
+    u32 descriptor = cmd_buff[2];
-    u32 process       = cmd_buff[3];
+    u32 process = cmd_buff[3];
    LOG_DEBUG(Service_LDR, "called, cro_address=0x%08X, descriptor=0x%08X, process=0x%08X",
-        cro_address, descriptor, process);
+              cro_address, descriptor, process);
    if (descriptor != 0) {
        LOG_ERROR(Service_LDR, "IPC handle descriptor failed validation (0x%X)", descriptor);
@@ -682,11 +708,11 @@ static void UnlinkCRO(Service::Interface* self) {
 static void Shutdown(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    VAddr crs_buffer_ptr = cmd_buff[1];
-    u32 descriptor       = cmd_buff[2];
+    u32 descriptor = cmd_buff[2];
-    u32 process          = cmd_buff[3];
+    u32 process = cmd_buff[3];
    LOG_DEBUG(Service_LDR, "called, crs_buffer_ptr=0x%08X, descriptor=0x%08X, process=0x%08X",
-        crs_buffer_ptr, descriptor, process);
+              crs_buffer_ptr, descriptor, process);
    if (descriptor != 0) {
        LOG_ERROR(Service_LDR, "IPC handle descriptor failed validation (0x%X)", descriptor);
@@ -724,15 +750,11 @@ static void Shutdown(Service::Interface* self) {
 }
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x000100C2, Initialize,            "Initialize"},
+    {0x000100C2, Initialize, "Initialize"},     {0x00020082, LoadCRR, "LoadCRR"},
-    {0x00020082, LoadCRR,               "LoadCRR"},
+    {0x00030042, UnloadCRR, "UnloadCRR"},       {0x000402C2, LoadCRO<false>, "LoadCRO"},
-    {0x00030042, UnloadCRR,             "UnloadCRR"},
+    {0x000500C2, UnloadCRO, "UnloadCRO"},       {0x00060042, LinkCRO, "LinkCRO"},
-    {0x000402C2, LoadCRO<false>,        "LoadCRO"},
+    {0x00070042, UnlinkCRO, "UnlinkCRO"},       {0x00080042, Shutdown, "Shutdown"},
-    {0x000500C2, UnloadCRO,             "UnloadCRO"},
+    {0x000902C2, LoadCRO<true>, "LoadCRO_New"},
-    {0x00060042, LinkCRO,               "LinkCRO"},
-    {0x00070042, UnlinkCRO,             "UnlinkCRO"},
-    {0x00080042, Shutdown,              "Shutdown"},
-    {0x000902C2, LoadCRO<true>,         "LoadCRO_New"},
 };
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/ldr_ro/memory_synchronizer.cpp b/src/core/hle/service/ldr_ro/memory_synchronizer.cpp
index 4402876e6..aed6d3365 100644
--- a/src/core/hle/service/ldr_ro/memory_synchronizer.cpp
+++ b/src/core/hle/service/ldr_ro/memory_synchronizer.cpp
@@ -14,9 +14,8 @@
 namespace LDR_RO {
 auto MemorySynchronizer::FindMemoryBlock(VAddr mapping, VAddr original) {
-    auto block = std::find_if(memory_blocks.begin(), memory_blocks.end(), [=](MemoryBlock& b){
+    auto block = std::find_if(memory_blocks.begin(), memory_blocks.end(),
-        return b.original == original;
+                              [=](MemoryBlock& b) { return b.original == original; });
-    });
    ASSERT(block->mapping == mapping);
    return block;
 }
diff --git a/src/core/hle/service/mic_u.cpp b/src/core/hle/service/mic_u.cpp
index f792bc9cd..edd1ea97b 100644
--- a/src/core/hle/service/mic_u.cpp
+++ b/src/core/hle/service/mic_u.cpp
@@ -10,22 +10,22 @@
 namespace MIC_U {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010042, nullptr,               "MapSharedMem"},
+    {0x00010042, nullptr, "MapSharedMem"},
-    {0x00020000, nullptr,               "UnmapSharedMem"},
+    {0x00020000, nullptr, "UnmapSharedMem"},
-    {0x00030140, nullptr,               "Initialize"},
+    {0x00030140, nullptr, "Initialize"},
-    {0x00040040, nullptr,               "AdjustSampling"},
+    {0x00040040, nullptr, "AdjustSampling"},
-    {0x00050000, nullptr,               "StopSampling"},
+    {0x00050000, nullptr, "StopSampling"},
-    {0x00060000, nullptr,               "IsSampling"},
+    {0x00060000, nullptr, "IsSampling"},
-    {0x00070000, nullptr,               "GetEventHandle"},
+    {0x00070000, nullptr, "GetEventHandle"},
-    {0x00080040, nullptr,               "SetGain"},
+    {0x00080040, nullptr, "SetGain"},
-    {0x00090000, nullptr,               "GetGain"},
+    {0x00090000, nullptr, "GetGain"},
-    {0x000A0040, nullptr,               "SetPower"},
+    {0x000A0040, nullptr, "SetPower"},
-    {0x000B0000, nullptr,               "GetPower"},
+    {0x000B0000, nullptr, "GetPower"},
-    {0x000C0042, nullptr,               "size"},
+    {0x000C0042, nullptr, "size"},
-    {0x000D0040, nullptr,               "SetClamp"},
+    {0x000D0040, nullptr, "SetClamp"},
-    {0x000E0000, nullptr,               "GetClamp"},
+    {0x000E0000, nullptr, "GetClamp"},
-    {0x000F0040, nullptr,               "SetAllowShellClosed"},
+    {0x000F0040, nullptr, "SetAllowShellClosed"},
-    {0x00100040, nullptr,               "unknown_input2"},
+    {0x00100040, nullptr, "unknown_input2"},
 };
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/ndm/ndm.cpp b/src/core/hle/service/ndm/ndm.cpp
index bc9c3413d..9f1536aef 100644
--- a/src/core/hle/service/ndm/ndm.cpp
+++ b/src/core/hle/service/ndm/ndm.cpp
@@ -2,23 +2,21 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
+#include "core/hle/service/ndm/ndm.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "core/hle/service/service.h"
-#include "core/hle/service/ndm/ndm.h"
 #include "core/hle/service/ndm/ndm_u.h"
+#include "core/hle/service/service.h"
 namespace Service {
 namespace NDM {
-enum : u32 {
+enum : u32 { DEFAULT_RETRY_INTERVAL = 10, DEFAULT_SCAN_INTERVAL = 30 };
-    DEFAULT_RETRY_INTERVAL = 10,
-    DEFAULT_SCAN_INTERVAL  = 30
-};
 static DaemonMask daemon_bit_mask = DaemonMask::Default;
 static DaemonMask default_daemon_bit_mask = DaemonMask::Default;
-static std::array<DaemonStatus, 4> daemon_status = { DaemonStatus::Idle, DaemonStatus::Idle, DaemonStatus::Idle, DaemonStatus::Idle };
+static std::array<DaemonStatus, 4> daemon_status = {DaemonStatus::Idle, DaemonStatus::Idle,
+                                                    DaemonStatus::Idle, DaemonStatus::Idle};
 static ExclusiveState exclusive_state = ExclusiveState::None;
 static u32 scan_interval = DEFAULT_SCAN_INTERVAL;
 static u32 retry_interval = DEFAULT_RETRY_INTERVAL;
@@ -72,7 +70,8 @@ void UnlockState(Service::Interface* self) {
 void SuspendDaemons(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    u32 bit_mask = cmd_buff[1] & 0xF;
-    daemon_bit_mask = static_cast<DaemonMask>(static_cast<u32>(default_daemon_bit_mask) & ~bit_mask);
+    daemon_bit_mask =
+        static_cast<DaemonMask>(static_cast<u32>(default_daemon_bit_mask) & ~bit_mask);
    for (size_t index = 0; index < daemon_status.size(); ++index) {
        if (bit_mask & (1 << index)) {
            daemon_status[index] = DaemonStatus::Suspended;
@@ -229,8 +228,7 @@ void Init() {
 }
 void Shutdown() {
 }
-}// namespace NDM
+} // namespace NDM
-}// namespace Service
+} // namespace Service
diff --git a/src/core/hle/service/ndm/ndm.h b/src/core/hle/service/ndm/ndm.h
index 5c2b968dc..fb574541d 100644
--- a/src/core/hle/service/ndm/ndm.h
+++ b/src/core/hle/service/ndm/ndm.h
@@ -12,36 +12,26 @@ class Interface;
 namespace NDM {
-enum class Daemon : u32 {
+enum class Daemon : u32 { Cec = 0, Boss = 1, Nim = 2, Friend = 3 };
-    Cec    = 0,
-    Boss   = 1,
-    Nim    = 2,
-    Friend = 3
-};
 enum class DaemonMask : u32 {
-    None    =  0,
+    None = 0,
-    Cec     = (1 << static_cast<u32>(Daemon::Cec)),
+    Cec = (1 << static_cast<u32>(Daemon::Cec)),
-    Boss    = (1 << static_cast<u32>(Daemon::Boss)),
+    Boss = (1 << static_cast<u32>(Daemon::Boss)),
-    Nim     = (1 << static_cast<u32>(Daemon::Nim)),
+    Nim = (1 << static_cast<u32>(Daemon::Nim)),
-    Friend  = (1 << static_cast<u32>(Daemon::Friend)),
+    Friend = (1 << static_cast<u32>(Daemon::Friend)),
    Default = Cec | Friend,
-    All     = Cec | Boss | Nim | Friend
+    All = Cec | Boss | Nim | Friend
 };
-enum class DaemonStatus : u32 {
+enum class DaemonStatus : u32 { Busy = 0, Idle = 1, Suspending = 2, Suspended = 3 };
-    Busy       = 0,
-    Idle       = 1,
-    Suspending = 2,
-    Suspended  = 3
-};
 enum class ExclusiveState : u32 {
-    None                = 0,
+    None = 0,
-    Infrastructure      = 1,
+    Infrastructure = 1,
    LocalCommunications = 2,
-    Streetpass          = 3,
+    Streetpass = 3,
-    StreetpassData      = 4,
+    StreetpassData = 4,
 };
 /**
@@ -205,7 +195,6 @@ void SetRetryInterval(Service::Interface* self);
 */
 void GetRetryInterval(Service::Interface* self);
 /**
 *  NDM::OverrideDefaultDaemons service function
 *  Inputs:
@@ -233,7 +222,8 @@ void ResetDefaultDaemons(Service::Interface* self);
 *      1 : Result, 0 on success, otherwise error code
 *      2 : Daemon bit mask
 *  Note:
- *      Gets the current default daemon bit mask. The default value is (DAEMONMASK_CEC | DAEMONMASK_FRIENDS)
+ *      Gets the current default daemon bit mask. The default value is (DAEMONMASK_CEC |
+ * DAEMONMASK_FRIENDS)
 */
 void GetDefaultDaemons(Service::Interface* self);
@@ -252,5 +242,5 @@ void Init();
 /// Shutdown NDM service
 void Shutdown();
-}// namespace NDM
+} // namespace NDM
-}// namespace Service
+} // namespace Service
diff --git a/src/core/hle/service/ndm/ndm_u.cpp b/src/core/hle/service/ndm/ndm_u.cpp
index 3ff0744ee..f5c7a341a 100644
--- a/src/core/hle/service/ndm/ndm_u.cpp
+++ b/src/core/hle/service/ndm/ndm_u.cpp
@@ -9,28 +9,28 @@ namespace Service {
 namespace NDM {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010042, EnterExclusiveState,     "EnterExclusiveState"},
+    {0x00010042, EnterExclusiveState, "EnterExclusiveState"},
-    {0x00020002, LeaveExclusiveState,     "LeaveExclusiveState"},
+    {0x00020002, LeaveExclusiveState, "LeaveExclusiveState"},
-    {0x00030000, QueryExclusiveMode,      "QueryExclusiveMode"},
+    {0x00030000, QueryExclusiveMode, "QueryExclusiveMode"},
-    {0x00040002, LockState,               "LockState"},
+    {0x00040002, LockState, "LockState"},
-    {0x00050002, UnlockState,             "UnlockState"},
+    {0x00050002, UnlockState, "UnlockState"},
-    {0x00060040, SuspendDaemons,          "SuspendDaemons"},
+    {0x00060040, SuspendDaemons, "SuspendDaemons"},
-    {0x00070040, ResumeDaemons,           "ResumeDaemons"},
+    {0x00070040, ResumeDaemons, "ResumeDaemons"},
-    {0x00080040, SuspendScheduler,        "SuspendScheduler"},
+    {0x00080040, SuspendScheduler, "SuspendScheduler"},
-    {0x00090000, ResumeScheduler,         "ResumeScheduler"},
+    {0x00090000, ResumeScheduler, "ResumeScheduler"},
-    {0x000A0000, nullptr,                 "GetCurrentState"},
+    {0x000A0000, nullptr, "GetCurrentState"},
-    {0x000B0000, nullptr,                 "GetTargetState"},
+    {0x000B0000, nullptr, "GetTargetState"},
-    {0x000C0000, nullptr,                 "<Stubbed>"},
+    {0x000C0000, nullptr, "<Stubbed>"},
-    {0x000D0040, QueryStatus,             "QueryStatus"},
+    {0x000D0040, QueryStatus, "QueryStatus"},
-    {0x000E0040, GetDaemonDisableCount,   "GetDaemonDisableCount"},
+    {0x000E0040, GetDaemonDisableCount, "GetDaemonDisableCount"},
-    {0x000F0000, GetSchedulerDisableCount,"GetSchedulerDisableCount"},
+    {0x000F0000, GetSchedulerDisableCount, "GetSchedulerDisableCount"},
-    {0x00100040, SetScanInterval,         "SetScanInterval"},
+    {0x00100040, SetScanInterval, "SetScanInterval"},
-    {0x00110000, GetScanInterval,         "GetScanInterval"},
+    {0x00110000, GetScanInterval, "GetScanInterval"},
-    {0x00120040, SetRetryInterval,        "SetRetryInterval"},
+    {0x00120040, SetRetryInterval, "SetRetryInterval"},
-    {0x00130000, GetRetryInterval,        "GetRetryInterval"},
+    {0x00130000, GetRetryInterval, "GetRetryInterval"},
-    {0x00140040, OverrideDefaultDaemons,  "OverrideDefaultDaemons"},
+    {0x00140040, OverrideDefaultDaemons, "OverrideDefaultDaemons"},
-    {0x00150000, ResetDefaultDaemons,     "ResetDefaultDaemons"},
+    {0x00150000, ResetDefaultDaemons, "ResetDefaultDaemons"},
-    {0x00160000, GetDefaultDaemons,       "GetDefaultDaemons"},
+    {0x00160000, GetDefaultDaemons, "GetDefaultDaemons"},
    {0x00170000, ClearHalfAwakeMacFilter, "ClearHalfAwakeMacFilter"},
 };
diff --git a/src/core/hle/service/news/news.cpp b/src/core/hle/service/news/news.cpp
index b3f500694..983e0777c 100644
--- a/src/core/hle/service/news/news.cpp
+++ b/src/core/hle/service/news/news.cpp
@@ -4,10 +4,10 @@
 #include "common/logging/log.h"
-#include "core/hle/service/service.h"
 #include "core/hle/service/news/news.h"
 #include "core/hle/service/news/news_s.h"
 #include "core/hle/service/news/news_u.h"
+#include "core/hle/service/service.h"
 namespace Service {
 namespace NEWS {
diff --git a/src/core/hle/service/news/news_s.cpp b/src/core/hle/service/news/news_s.cpp
index 39b5a50f8..dda3d0f6a 100644
--- a/src/core/hle/service/news/news_s.cpp
+++ b/src/core/hle/service/news/news_s.cpp
@@ -9,19 +9,19 @@ namespace Service {
 namespace NEWS {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x000100C6, nullptr,               "AddNotification"},
+    {0x000100C6, nullptr, "AddNotification"},
-    {0x00050000, nullptr,               "GetTotalNotifications"},
+    {0x00050000, nullptr, "GetTotalNotifications"},
-    {0x00060042, nullptr,               "SetNewsDBHeader"},
+    {0x00060042, nullptr, "SetNewsDBHeader"},
-    {0x00070082, nullptr,               "SetNotificationHeader"},
+    {0x00070082, nullptr, "SetNotificationHeader"},
-    {0x00080082, nullptr,               "SetNotificationMessage"},
+    {0x00080082, nullptr, "SetNotificationMessage"},
-    {0x00090082, nullptr,               "SetNotificationImage"},
+    {0x00090082, nullptr, "SetNotificationImage"},
-    {0x000A0042, nullptr,               "GetNewsDBHeader"},
+    {0x000A0042, nullptr, "GetNewsDBHeader"},
-    {0x000B0082, nullptr,               "GetNotificationHeader"},
+    {0x000B0082, nullptr, "GetNotificationHeader"},
-    {0x000C0082, nullptr,               "GetNotificationMessage"},
+    {0x000C0082, nullptr, "GetNotificationMessage"},
-    {0x000D0082, nullptr,               "GetNotificationImage"},
+    {0x000D0082, nullptr, "GetNotificationImage"},
-    {0x000E0040, nullptr,               "SetInfoLEDPattern"},
+    {0x000E0040, nullptr, "SetInfoLEDPattern"},
-    {0x00120082, nullptr,               "GetNotificationHeaderOther"},
+    {0x00120082, nullptr, "GetNotificationHeaderOther"},
-    {0x00130000, nullptr,               "WriteNewsDBSavedata"},
+    {0x00130000, nullptr, "WriteNewsDBSavedata"},
 };
 NEWS_S_Interface::NEWS_S_Interface() {
diff --git a/src/core/hle/service/news/news_u.cpp b/src/core/hle/service/news/news_u.cpp
index 6b75cc24e..a07e466de 100644
--- a/src/core/hle/service/news/news_u.cpp
+++ b/src/core/hle/service/news/news_u.cpp
@@ -8,7 +8,7 @@ namespace Service {
 namespace NEWS {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x000100C6, nullptr,               "AddNotification"},
+    {0x000100C6, nullptr, "AddNotification"},
 };
 NEWS_U_Interface::NEWS_U_Interface() {
diff --git a/src/core/hle/service/nim/nim.cpp b/src/core/hle/service/nim/nim.cpp
index ed42464ce..f3c01d6e6 100644
--- a/src/core/hle/service/nim/nim.cpp
+++ b/src/core/hle/service/nim/nim.cpp
@@ -5,11 +5,11 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "core/hle/service/service.h"
 #include "core/hle/service/nim/nim.h"
 #include "core/hle/service/nim/nim_aoc.h"
 #include "core/hle/service/nim/nim_s.h"
 #include "core/hle/service/nim/nim_u.h"
+#include "core/hle/service/service.h"
 namespace Service {
 namespace NIM {
diff --git a/src/core/hle/service/nim/nim_aoc.cpp b/src/core/hle/service/nim/nim_aoc.cpp
index 4a4818d57..2d0fb6fc4 100644
--- a/src/core/hle/service/nim/nim_aoc.cpp
+++ b/src/core/hle/service/nim/nim_aoc.cpp
@@ -8,14 +8,14 @@ namespace Service {
 namespace NIM {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00030042, nullptr,               "SetApplicationId"},
+    {0x00030042, nullptr, "SetApplicationId"},
-    {0x00040042, nullptr,               "SetTin"},
+    {0x00040042, nullptr, "SetTin"},
-    {0x000902D0, nullptr,               "ListContentSetsEx"},
+    {0x000902D0, nullptr, "ListContentSetsEx"},
-    {0x00180000, nullptr,               "GetBalance"},
+    {0x00180000, nullptr, "GetBalance"},
-    {0x001D0000, nullptr,               "GetCustomerSupportCode"},
+    {0x001D0000, nullptr, "GetCustomerSupportCode"},
-    {0x00210000, nullptr,               "Initialize"},
+    {0x00210000, nullptr, "Initialize"},
-    {0x00240282, nullptr,               "CalculateContentsRequiredSize"},
+    {0x00240282, nullptr, "CalculateContentsRequiredSize"},
-    {0x00250000, nullptr,               "RefreshServerTime"},
+    {0x00250000, nullptr, "RefreshServerTime"},
 };
 NIM_AOC_Interface::NIM_AOC_Interface() {
diff --git a/src/core/hle/service/nim/nim_s.cpp b/src/core/hle/service/nim/nim_s.cpp
index dcaa0255a..e2ba693c9 100644
--- a/src/core/hle/service/nim/nim_s.cpp
+++ b/src/core/hle/service/nim/nim_s.cpp
@@ -8,10 +8,10 @@ namespace Service {
 namespace NIM {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x000A0000, nullptr,                      "CheckSysupdateAvailableSOAP"},
+    {0x000A0000, nullptr, "CheckSysupdateAvailableSOAP"},
-    {0x0016020A, nullptr,                      "ListTitles"},
+    {0x0016020A, nullptr, "ListTitles"},
-    {0x002D0042, nullptr,                      "DownloadTickets"},
+    {0x002D0042, nullptr, "DownloadTickets"},
-    {0x00420240, nullptr,                      "StartDownload"},
+    {0x00420240, nullptr, "StartDownload"},
 };
 NIM_S_Interface::NIM_S_Interface() {
@@ -20,4 +20,3 @@ NIM_S_Interface::NIM_S_Interface() {
 } // namespace NIM
 } // namespace Service
diff --git a/src/core/hle/service/nim/nim_u.cpp b/src/core/hle/service/nim/nim_u.cpp
index eae45ebc0..7e07d02e8 100644
--- a/src/core/hle/service/nim/nim_u.cpp
+++ b/src/core/hle/service/nim/nim_u.cpp
@@ -9,12 +9,12 @@ namespace Service {
 namespace NIM {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010000, nullptr,                  "StartSysUpdate"},
+    {0x00010000, nullptr, "StartSysUpdate"},
-    {0x00020000, nullptr,                  "GetUpdateDownloadProgress"},
+    {0x00020000, nullptr, "GetUpdateDownloadProgress"},
-    {0x00040000, nullptr,                  "FinishTitlesInstall"},
+    {0x00040000, nullptr, "FinishTitlesInstall"},
-    {0x00050000, nullptr,                  "CheckForSysUpdateEvent"},
+    {0x00050000, nullptr, "CheckForSysUpdateEvent"},
-    {0x00090000, CheckSysUpdateAvailable,  "CheckSysUpdateAvailable"},
+    {0x00090000, CheckSysUpdateAvailable, "CheckSysUpdateAvailable"},
-    {0x000A0000, nullptr,                  "GetState"},
+    {0x000A0000, nullptr, "GetState"},
 };
 NIM_U_Interface::NIM_U_Interface() {
@@ -23,4 +23,3 @@ NIM_U_Interface::NIM_U_Interface() {
 } // namespace NIM
 } // namespace Service
diff --git a/src/core/hle/service/ns_s.cpp b/src/core/hle/service/ns_s.cpp
index 072918d62..6693f7c08 100644
--- a/src/core/hle/service/ns_s.cpp
+++ b/src/core/hle/service/ns_s.cpp
@@ -10,21 +10,21 @@
 namespace NS_S {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x000100C0, nullptr,                      "LaunchFIRM"},
+    {0x000100C0, nullptr, "LaunchFIRM"},
-    {0x000200C0, nullptr,                      "LaunchTitle"},
+    {0x000200C0, nullptr, "LaunchTitle"},
-    {0x00030000, nullptr,                      "TerminateApplication"},
+    {0x00030000, nullptr, "TerminateApplication"},
-    {0x00040040, nullptr,                      "TerminateProcess"},
+    {0x00040040, nullptr, "TerminateProcess"},
-    {0x000500C0, nullptr,                      "LaunchApplicationFIRM"},
+    {0x000500C0, nullptr, "LaunchApplicationFIRM"},
-    {0x00060042, nullptr,                      "SetFIRMParams4A0"},
+    {0x00060042, nullptr, "SetFIRMParams4A0"},
-    {0x00070042, nullptr,                      "CardUpdateInitialize"},
+    {0x00070042, nullptr, "CardUpdateInitialize"},
-    {0x00080000, nullptr,                      "CardUpdateShutdown"},
+    {0x00080000, nullptr, "CardUpdateShutdown"},
-    {0x000D0140, nullptr,                      "SetTWLBannerHMAC"},
+    {0x000D0140, nullptr, "SetTWLBannerHMAC"},
-    {0x000E0000, nullptr,                      "ShutdownAsync"},
+    {0x000E0000, nullptr, "ShutdownAsync"},
-    {0x00100180, nullptr,                      "RebootSystem"},
+    {0x00100180, nullptr, "RebootSystem"},
-    {0x00110100, nullptr,                      "TerminateTitle"},
+    {0x00110100, nullptr, "TerminateTitle"},
-    {0x001200C0, nullptr,                      "SetApplicationCpuTimeLimit"},
+    {0x001200C0, nullptr, "SetApplicationCpuTimeLimit"},
-    {0x00150140, nullptr,                      "LaunchApplication"},
+    {0x00150140, nullptr, "LaunchApplication"},
-    {0x00160000, nullptr,                      "RebootSystemClean"},
+    {0x00160000, nullptr, "RebootSystemClean"},
 };
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/nwm_uds.cpp b/src/core/hle/service/nwm_uds.cpp
index ae4640409..ed417fa9a 100644
--- a/src/core/hle/service/nwm_uds.cpp
+++ b/src/core/hle/service/nwm_uds.cpp
@@ -54,22 +54,23 @@ static void Shutdown(Service::Interface* self) {
 static void RecvBeaconBroadcastData(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    u32 out_buffer_size = cmd_buff[1];
-    u32 unk1            = cmd_buff[2];
+    u32 unk1 = cmd_buff[2];
-    u32 unk2            = cmd_buff[3];
+    u32 unk2 = cmd_buff[3];
-    u32 mac_address     = cmd_buff[4];
+    u32 mac_address = cmd_buff[4];
-    u32 unk3            = cmd_buff[6];
+    u32 unk3 = cmd_buff[6];
-    u32 wlan_comm_id    = cmd_buff[15];
+    u32 wlan_comm_id = cmd_buff[15];
-    u32 ctr_gen_id      = cmd_buff[16];
+    u32 ctr_gen_id = cmd_buff[16];
-    u32 value           = cmd_buff[17];
+    u32 value = cmd_buff[17];
-    u32 input_handle    = cmd_buff[18];
+    u32 input_handle = cmd_buff[18];
    u32 new_buffer_size = cmd_buff[19];
-    u32 out_buffer_ptr  = cmd_buff[20];
+    u32 out_buffer_ptr = cmd_buff[20];
    cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_WARNING(Service_NWM, "(STUBBED) called out_buffer_size=0x%08X, unk1=0x%08X, unk2=0x%08X,"
+    LOG_WARNING(Service_NWM,
+                "(STUBBED) called out_buffer_size=0x%08X, unk1=0x%08X, unk2=0x%08X,"
                "mac_address=0x%08X, unk3=0x%08X, wlan_comm_id=0x%08X, ctr_gen_id=0x%08X,"
                "value=%u, input_handle=0x%08X, new_buffer_size=0x%08X, out_buffer_ptr=0x%08X",
                out_buffer_size, unk1, unk2, mac_address, unk3, wlan_comm_id, ctr_gen_id, value,
@@ -92,46 +93,47 @@ static void RecvBeaconBroadcastData(Service::Interface* self) {
 */
 static void Initialize(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
-    u32 unk1   = cmd_buff[1];
+    u32 unk1 = cmd_buff[1];
-    u32 unk2   = cmd_buff[12];
+    u32 unk2 = cmd_buff[12];
-    u32 value  = cmd_buff[13];
+    u32 value = cmd_buff[13];
    u32 handle = cmd_buff[14];
    cmd_buff[1] = RESULT_SUCCESS.raw;
    cmd_buff[2] = 0;
-    cmd_buff[3] = Kernel::g_handle_table.Create(handle_event).MoveFrom(); //TODO(purpasmart): Verify if this is a event handle
+    cmd_buff[3] = Kernel::g_handle_table.Create(handle_event)
+                      .MoveFrom(); // TODO(purpasmart): Verify if this is a event handle
    LOG_WARNING(Service_NWM, "(STUBBED) called unk1=0x%08X, unk2=0x%08X, value=%u, handle=0x%08X",
                unk1, unk2, value, handle);
 }
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00020000, nullptr,                   "Scrap"},
+    {0x00020000, nullptr, "Scrap"},
-    {0x00030000, Shutdown,                  "Shutdown"},
+    {0x00030000, Shutdown, "Shutdown"},
-    {0x00040402, nullptr,                   "CreateNetwork"},
+    {0x00040402, nullptr, "CreateNetwork"},
-    {0x00050040, nullptr,                   "EjectClient"},
+    {0x00050040, nullptr, "EjectClient"},
-    {0x00060000, nullptr,                   "EjectSpectator"},
+    {0x00060000, nullptr, "EjectSpectator"},
-    {0x00070080, nullptr,                   "UpdateNetworkAttribute"},
+    {0x00070080, nullptr, "UpdateNetworkAttribute"},
-    {0x00080000, nullptr,                   "DestroyNetwork"},
+    {0x00080000, nullptr, "DestroyNetwork"},
-    {0x000A0000, nullptr,                   "DisconnectNetwork"},
+    {0x000A0000, nullptr, "DisconnectNetwork"},
-    {0x000B0000, nullptr,                   "GetConnectionStatus"},
+    {0x000B0000, nullptr, "GetConnectionStatus"},
-    {0x000D0040, nullptr,                   "GetNodeInformation"},
+    {0x000D0040, nullptr, "GetNodeInformation"},
-    {0x000F0404, RecvBeaconBroadcastData,   "RecvBeaconBroadcastData"},
+    {0x000F0404, RecvBeaconBroadcastData, "RecvBeaconBroadcastData"},
-    {0x00100042, nullptr,                   "SetBeaconAdditionalData"},
+    {0x00100042, nullptr, "SetBeaconAdditionalData"},
-    {0x00110040, nullptr,                   "GetApplicationData"},
+    {0x00110040, nullptr, "GetApplicationData"},
-    {0x00120100, nullptr,                   "Bind"},
+    {0x00120100, nullptr, "Bind"},
-    {0x00130040, nullptr,                   "Unbind"},
+    {0x00130040, nullptr, "Unbind"},
-    {0x001400C0, nullptr,                   "RecvBroadcastDataFrame"},
+    {0x001400C0, nullptr, "RecvBroadcastDataFrame"},
-    {0x00150080, nullptr,                   "SetMaxSendDelay"},
+    {0x00150080, nullptr, "SetMaxSendDelay"},
-    {0x00170182, nullptr,                   "SendTo"},
+    {0x00170182, nullptr, "SendTo"},
-    {0x001A0000, nullptr,                   "GetChannel"},
+    {0x001A0000, nullptr, "GetChannel"},
-    {0x001B0302, Initialize,                "Initialize"},
+    {0x001B0302, Initialize, "Initialize"},
-    {0x001D0044, nullptr,                   "BeginHostingNetwork"},
+    {0x001D0044, nullptr, "BeginHostingNetwork"},
-    {0x001E0084, nullptr,                   "ConnectToNetwork"},
+    {0x001E0084, nullptr, "ConnectToNetwork"},
-    {0x001F0006, nullptr,                   "DecryptBeaconData"},
+    {0x001F0006, nullptr, "DecryptBeaconData"},
-    {0x00200040, nullptr,                   "Flush"},
+    {0x00200040, nullptr, "Flush"},
-    {0x00210080, nullptr,                   "SetProbeResponseParam"},
+    {0x00210080, nullptr, "SetProbeResponseParam"},
-    {0x00220402, nullptr,                   "ScanOnConnection"},
+    {0x00220402, nullptr, "ScanOnConnection"},
 };
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/pm_app.cpp b/src/core/hle/service/pm_app.cpp
index 05d01bc48..7d91694f6 100644
--- a/src/core/hle/service/pm_app.cpp
+++ b/src/core/hle/service/pm_app.cpp
@@ -10,18 +10,18 @@
 namespace PM_APP {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010140, nullptr,                 "LaunchTitle"},
+    {0x00010140, nullptr, "LaunchTitle"},
-    {0x00020082, nullptr,                 "LaunchFIRMSetParams"},
+    {0x00020082, nullptr, "LaunchFIRMSetParams"},
-    {0x00030080, nullptr,                 "TerminateProcesse"},
+    {0x00030080, nullptr, "TerminateProcesse"},
-    {0x00040100, nullptr,                 "TerminateProcessTID"},
+    {0x00040100, nullptr, "TerminateProcessTID"},
-    {0x000500C0, nullptr,                 "TerminateProcessTID_unknown"},
+    {0x000500C0, nullptr, "TerminateProcessTID_unknown"},
-    {0x00070042, nullptr,                 "GetFIRMLaunchParams"},
+    {0x00070042, nullptr, "GetFIRMLaunchParams"},
-    {0x00080100, nullptr,                 "GetTitleExheaderFlags"},
+    {0x00080100, nullptr, "GetTitleExheaderFlags"},
-    {0x00090042, nullptr,                 "SetFIRMLaunchParams"},
+    {0x00090042, nullptr, "SetFIRMLaunchParams"},
-    {0x000A0140, nullptr,                 "SetResourceLimit"},
+    {0x000A0140, nullptr, "SetResourceLimit"},
-    {0x000B0140, nullptr,                 "GetResourceLimitMax"},
+    {0x000B0140, nullptr, "GetResourceLimitMax"},
-    {0x000C0080, nullptr,                 "UnregisterProcess"},
+    {0x000C0080, nullptr, "UnregisterProcess"},
-    {0x000D0240, nullptr,                 "LaunchTitleUpdate"},
+    {0x000D0240, nullptr, "LaunchTitleUpdate"},
 };
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/ptm/ptm.cpp b/src/core/hle/service/ptm/ptm.cpp
index e2c17d93b..80fa09f5f 100644
--- a/src/core/hle/service/ptm/ptm.cpp
+++ b/src/core/hle/service/ptm/ptm.cpp
@@ -2,21 +2,21 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
+#include "core/hle/service/ptm/ptm.h"
 #include "common/logging/log.h"
-#include "core/settings.h"
 #include "core/file_sys/file_backend.h"
 #include "core/hle/service/fs/archive.h"
-#include "core/hle/service/ptm/ptm.h"
 #include "core/hle/service/ptm/ptm_play.h"
 #include "core/hle/service/ptm/ptm_sysm.h"
 #include "core/hle/service/ptm/ptm_u.h"
 #include "core/hle/service/service.h"
+#include "core/settings.h"
 namespace Service {
 namespace PTM {
 /// Values for the default gamecoin.dat file
-static const GameCoin default_game_coin = { 0x4F00, 42, 0, 0, 0, 2014, 12, 29 };
+static const GameCoin default_game_coin = {0x4F00, 42, 0, 0, 0, 2014, 12, 29};
 /// Id of the SharedExtData archive used by the PTM process
 static const std::vector<u8> ptm_shared_extdata_id = {0, 0, 0, 0, 0x0B, 0, 0, 0xF0, 0, 0, 0, 0};
@@ -51,7 +51,8 @@ void GetBatteryLevel(Service::Interface* self) {
    // it returns a valid result without implementing full functionality.
    cmd_buff[1] = RESULT_SUCCESS.raw;
-    cmd_buff[2] = static_cast<u32>(ChargeLevels::CompletelyFull); // Set to a completely full battery
+    cmd_buff[2] =
+        static_cast<u32>(ChargeLevels::CompletelyFull); // Set to a completely full battery
    LOG_WARNING(Service_PTM, "(STUBBED) called");
 }
@@ -94,7 +95,8 @@ void CheckNew3DS(Service::Interface* self) {
    const bool is_new_3ds = Settings::values.is_new_3ds;
    if (is_new_3ds) {
-        LOG_CRITICAL(Service_PTM, "The option 'is_new_3ds' is enabled as part of the 'System' settings. Citra does not fully support New 3DS emulation yet!");
+        LOG_CRITICAL(Service_PTM, "The option 'is_new_3ds' is enabled as part of the 'System' "
+                                  "settings. Citra does not fully support New 3DS emulation yet!");
    }
    cmd_buff[1] = RESULT_SUCCESS.raw;
@@ -111,15 +113,19 @@ void Init() {
    shell_open = true;
    battery_is_charging = true;
-    // Open the SharedExtSaveData archive 0xF000000B and create the gamecoin.dat file if it doesn't exist
+    // Open the SharedExtSaveData archive 0xF000000B and create the gamecoin.dat file if it doesn't
+    // exist
    FileSys::Path archive_path(ptm_shared_extdata_id);
-    auto archive_result = Service::FS::OpenArchive(Service::FS::ArchiveIdCode::SharedExtSaveData, archive_path);
+    auto archive_result =
+        Service::FS::OpenArchive(Service::FS::ArchiveIdCode::SharedExtSaveData, archive_path);
    // If the archive didn't exist, create the files inside
    if (archive_result.Code().description == ErrorDescription::FS_NotFormatted) {
        // Format the archive to create the directories
-        Service::FS::FormatArchive(Service::FS::ArchiveIdCode::SharedExtSaveData, FileSys::ArchiveFormatInfo(), archive_path);
+        Service::FS::FormatArchive(Service::FS::ArchiveIdCode::SharedExtSaveData,
+                                   FileSys::ArchiveFormatInfo(), archive_path);
        // Open it again to get a valid archive now that the folder exists
-        archive_result = Service::FS::OpenArchive(Service::FS::ArchiveIdCode::SharedExtSaveData, archive_path);
+        archive_result =
+            Service::FS::OpenArchive(Service::FS::ArchiveIdCode::SharedExtSaveData, archive_path);
        ASSERT_MSG(archive_result.Succeeded(), "Could not open the PTM SharedExtSaveData archive!");
        FileSys::Path gamecoin_path("gamecoin.dat");
@@ -127,17 +133,18 @@ void Init() {
        open_mode.write_flag.Assign(1);
        open_mode.create_flag.Assign(1);
        // Open the file and write the default gamecoin information
-        auto gamecoin_result = Service::FS::OpenFileFromArchive(*archive_result, gamecoin_path, open_mode);
+        auto gamecoin_result =
+            Service::FS::OpenFileFromArchive(*archive_result, gamecoin_path, open_mode);
        if (gamecoin_result.Succeeded()) {
            auto gamecoin = gamecoin_result.MoveFrom();
-            gamecoin->backend->Write(0, sizeof(GameCoin), 1, reinterpret_cast<const u8*>(&default_game_coin));
+            gamecoin->backend->Write(0, sizeof(GameCoin), 1,
+                                     reinterpret_cast<const u8*>(&default_game_coin));
            gamecoin->backend->Close();
        }
    }
 }
 void Shutdown() {
 }
 } // namespace PTM
diff --git a/src/core/hle/service/ptm/ptm.h b/src/core/hle/service/ptm/ptm.h
index 7ef8877c7..6e163a6f9 100644
--- a/src/core/hle/service/ptm/ptm.h
+++ b/src/core/hle/service/ptm/ptm.h
@@ -14,23 +14,24 @@ namespace PTM {
 /// Charge levels used by PTM functions
 enum class ChargeLevels : u32 {
-    CriticalBattery    = 1,
+    CriticalBattery = 1,
-    LowBattery         = 2,
+    LowBattery = 2,
-    HalfFull           = 3,
+    HalfFull = 3,
-    MostlyFull         = 4,
+    MostlyFull = 4,
-    CompletelyFull     = 5,
+    CompletelyFull = 5,
 };
 /**
 * Represents the gamecoin file structure in the SharedExtData archive
- * More information in 3dbrew (http://www.3dbrew.org/wiki/Extdata#Shared_Extdata_0xf000000b_gamecoin.dat)
+ * More information in 3dbrew
+ * (http://www.3dbrew.org/wiki/Extdata#Shared_Extdata_0xf000000b_gamecoin.dat)
 */
 struct GameCoin {
-    u32 magic; ///< Magic number: 0x4F00
+    u32 magic;               ///< Magic number: 0x4F00
-    u16 total_coins; ///< Total Play Coins
+    u16 total_coins;         ///< Total Play Coins
    u16 total_coins_on_date; ///< Total Play Coins obtained on the date stored below.
-    u32 step_count; ///< Total step count at the time a new Play Coin was obtained.
+    u32 step_count;          ///< Total step count at the time a new Play Coin was obtained.
-    u32 last_step_count; ///< Step count for the day the last Play Coin was obtained
+    u32 last_step_count;     ///< Step count for the day the last Play Coin was obtained
    u16 year;
    u8 month;
    u8 day;
diff --git a/src/core/hle/service/ptm/ptm_play.cpp b/src/core/hle/service/ptm/ptm_play.cpp
index ca5dd0403..2e0c6e1a3 100644
--- a/src/core/hle/service/ptm/ptm_play.cpp
+++ b/src/core/hle/service/ptm/ptm_play.cpp
@@ -8,10 +8,10 @@ namespace Service {
 namespace PTM {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x08070082, nullptr,               "GetPlayHistory"},
+    {0x08070082, nullptr, "GetPlayHistory"},
-    {0x08080000, nullptr,               "GetPlayHistoryStart"},
+    {0x08080000, nullptr, "GetPlayHistoryStart"},
-    {0x08090000, nullptr,               "GetPlayHistoryLength"},
+    {0x08090000, nullptr, "GetPlayHistoryLength"},
-    {0x080B0080, nullptr,               "CalcPlayHistoryStart"},
+    {0x080B0080, nullptr, "CalcPlayHistoryStart"},
 };
 PTM_Play_Interface::PTM_Play_Interface() {
diff --git a/src/core/hle/service/ptm/ptm_play.h b/src/core/hle/service/ptm/ptm_play.h
index e5c3e04df..47f229581 100644
--- a/src/core/hle/service/ptm/ptm_play.h
+++ b/src/core/hle/service/ptm/ptm_play.h
@@ -13,9 +13,9 @@ class PTM_Play_Interface : public Service::Interface {
 public:
    PTM_Play_Interface();
-std::string GetPortName() const override {
+    std::string GetPortName() const override {
-    return "ptm:play";
+        return "ptm:play";
-}
+    }
 };
 } // namespace PTM
diff --git a/src/core/hle/service/ptm/ptm_sysm.cpp b/src/core/hle/service/ptm/ptm_sysm.cpp
index cc4ef1101..693158dbf 100644
--- a/src/core/hle/service/ptm/ptm_sysm.cpp
+++ b/src/core/hle/service/ptm/ptm_sysm.cpp
@@ -9,37 +9,37 @@ namespace Service {
 namespace PTM {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x040100C0, nullptr,             "SetRtcAlarmEx"},
+    {0x040100C0, nullptr, "SetRtcAlarmEx"},
-    {0x04020042, nullptr,             "ReplySleepQuery"},
+    {0x04020042, nullptr, "ReplySleepQuery"},
-    {0x04030042, nullptr,             "NotifySleepPreparationComplete"},
+    {0x04030042, nullptr, "NotifySleepPreparationComplete"},
-    {0x04040102, nullptr,             "SetWakeupTrigger"},
+    {0x04040102, nullptr, "SetWakeupTrigger"},
-    {0x04050000, nullptr,             "GetAwakeReason"},
+    {0x04050000, nullptr, "GetAwakeReason"},
-    {0x04060000, nullptr,             "RequestSleep"},
+    {0x04060000, nullptr, "RequestSleep"},
-    {0x040700C0, nullptr,             "ShutdownAsync"},
+    {0x040700C0, nullptr, "ShutdownAsync"},
-    {0x04080000, nullptr,             "Awake"},
+    {0x04080000, nullptr, "Awake"},
-    {0x04090080, nullptr,             "RebootAsync"},
+    {0x04090080, nullptr, "RebootAsync"},
-    {0x040A0000, CheckNew3DS,         "CheckNew3DS"},
+    {0x040A0000, CheckNew3DS, "CheckNew3DS"},
-    {0x08010640, nullptr,             "SetInfoLEDPattern"},
+    {0x08010640, nullptr, "SetInfoLEDPattern"},
-    {0x08020040, nullptr,             "SetInfoLEDPatternHeader"},
+    {0x08020040, nullptr, "SetInfoLEDPatternHeader"},
-    {0x08030000, nullptr,             "GetInfoLEDStatus"},
+    {0x08030000, nullptr, "GetInfoLEDStatus"},
-    {0x08040040, nullptr,             "SetBatteryEmptyLEDPattern"},
+    {0x08040040, nullptr, "SetBatteryEmptyLEDPattern"},
-    {0x08050000, nullptr,             "ClearStepHistory"},
+    {0x08050000, nullptr, "ClearStepHistory"},
-    {0x080600C2, nullptr,             "SetStepHistory"},
+    {0x080600C2, nullptr, "SetStepHistory"},
-    {0x08070082, nullptr,             "GetPlayHistory"},
+    {0x08070082, nullptr, "GetPlayHistory"},
-    {0x08080000, nullptr,             "GetPlayHistoryStart"},
+    {0x08080000, nullptr, "GetPlayHistoryStart"},
-    {0x08090000, nullptr,             "GetPlayHistoryLength"},
+    {0x08090000, nullptr, "GetPlayHistoryLength"},
-    {0x080A0000, nullptr,             "ClearPlayHistory"},
+    {0x080A0000, nullptr, "ClearPlayHistory"},
-    {0x080B0080, nullptr,             "CalcPlayHistoryStart"},
+    {0x080B0080, nullptr, "CalcPlayHistoryStart"},
-    {0x080C0080, nullptr,             "SetUserTime"},
+    {0x080C0080, nullptr, "SetUserTime"},
-    {0x080D0000, nullptr,             "InvalidateSystemTime"},
+    {0x080D0000, nullptr, "InvalidateSystemTime"},
-    {0x080E0140, nullptr,             "NotifyPlayEvent"},
+    {0x080E0140, nullptr, "NotifyPlayEvent"},
-    {0x080F0000, IsLegacyPowerOff,    "IsLegacyPowerOff"},
+    {0x080F0000, IsLegacyPowerOff, "IsLegacyPowerOff"},
-    {0x08100000, nullptr,             "ClearLegacyPowerOff"},
+    {0x08100000, nullptr, "ClearLegacyPowerOff"},
-    {0x08110000, GetShellState,       "GetShellState"},
+    {0x08110000, GetShellState, "GetShellState"},
-    {0x08120000, nullptr,             "IsShutdownByBatteryEmpty"},
+    {0x08120000, nullptr, "IsShutdownByBatteryEmpty"},
-    {0x08130000, nullptr,             "FormatSavedata"},
+    {0x08130000, nullptr, "FormatSavedata"},
-    {0x08140000, nullptr,             "GetLegacyJumpProhibitedFlag"},
+    {0x08140000, nullptr, "GetLegacyJumpProhibitedFlag"},
-    {0x08180040, nullptr,             "ConfigureNew3DSCPU"},
+    {0x08180040, nullptr, "ConfigureNew3DSCPU"},
 };
 PTM_Sysm_Interface::PTM_Sysm_Interface() {
diff --git a/src/core/hle/service/ptm/ptm_u.cpp b/src/core/hle/service/ptm/ptm_u.cpp
index 17e764866..65e868393 100644
--- a/src/core/hle/service/ptm/ptm_u.cpp
+++ b/src/core/hle/service/ptm/ptm_u.cpp
@@ -9,21 +9,21 @@ namespace Service {
 namespace PTM {
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010002, nullptr,               "RegisterAlarmClient"},
+    {0x00010002, nullptr, "RegisterAlarmClient"},
-    {0x00020080, nullptr,               "SetRtcAlarm"},
+    {0x00020080, nullptr, "SetRtcAlarm"},
-    {0x00030000, nullptr,               "GetRtcAlarm"},
+    {0x00030000, nullptr, "GetRtcAlarm"},
-    {0x00040000, nullptr,               "CancelRtcAlarm"},
+    {0x00040000, nullptr, "CancelRtcAlarm"},
-    {0x00050000, GetAdapterState,       "GetAdapterState"},
+    {0x00050000, GetAdapterState, "GetAdapterState"},
-    {0x00060000, GetShellState,         "GetShellState"},
+    {0x00060000, GetShellState, "GetShellState"},
-    {0x00070000, GetBatteryLevel,       "GetBatteryLevel"},
+    {0x00070000, GetBatteryLevel, "GetBatteryLevel"},
    {0x00080000, GetBatteryChargeState, "GetBatteryChargeState"},
-    {0x00090000, nullptr,               "GetPedometerState"},
+    {0x00090000, nullptr, "GetPedometerState"},
-    {0x000A0042, nullptr,               "GetStepHistoryEntry"},
+    {0x000A0042, nullptr, "GetStepHistoryEntry"},
-    {0x000B00C2, nullptr,               "GetStepHistory"},
+    {0x000B00C2, nullptr, "GetStepHistory"},
-    {0x000C0000, GetTotalStepCount,     "GetTotalStepCount"},
+    {0x000C0000, GetTotalStepCount, "GetTotalStepCount"},
-    {0x000D0040, nullptr,               "SetPedometerRecordingMode"},
+    {0x000D0040, nullptr, "SetPedometerRecordingMode"},
-    {0x000E0000, nullptr,               "GetPedometerRecordingMode"},
+    {0x000E0000, nullptr, "GetPedometerRecordingMode"},
-    {0x000F0084, nullptr,               "GetStepHistoryAll"},
+    {0x000F0084, nullptr, "GetStepHistoryAll"},
 };
 PTM_U_Interface::PTM_U_Interface() {
diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index 5b8440b77..a531aad87 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -5,7 +5,6 @@
 #include "common/logging/log.h"
 #include "common/string_util.h"
-#include "core/hle/service/service.h"
 #include "core/hle/service/ac_u.h"
 #include "core/hle/service/act_a.h"
 #include "core/hle/service/act_u.h"
@@ -19,6 +18,7 @@
 #include "core/hle/service/ns_s.h"
 #include "core/hle/service/nwm_uds.h"
 #include "core/hle/service/pm_app.h"
+#include "core/hle/service/service.h"
 #include "core/hle/service/soc_u.h"
 #include "core/hle/service/srv.h"
 #include "core/hle/service/ssl_c.h"
@@ -29,10 +29,10 @@
 #include "core/hle/service/boss/boss.h"
 #include "core/hle/service/cam/cam.h"
 #include "core/hle/service/cecd/cecd.h"
+#include "core/hle/service/cfg/cfg.h"
 #include "core/hle/service/dlp/dlp.h"
 #include "core/hle/service/frd/frd.h"
 #include "core/hle/service/fs/archive.h"
-#include "core/hle/service/cfg/cfg.h"
 #include "core/hle/service/hid/hid.h"
 #include "core/hle/service/ir/ir.h"
 #include "core/hle/service/ldr_ro/ldr_ro.h"
@@ -50,11 +50,13 @@ std::unordered_map<std::string, Kernel::SharedPtr<Interface>> g_srv_services;
 * Creates a function string for logging, complete with the name (or header code, depending
 * on what's passed in) the port name, and all the cmd_buff arguments.
 */
-static std::string MakeFunctionString(const char* name, const char* port_name, const u32* cmd_buff) {
+static std::string MakeFunctionString(const char* name, const char* port_name,
+                                      const u32* cmd_buff) {
    // Number of params == bits 0-5 + bits 6-11
    int num_params = (cmd_buff[0] & 0x3F) + ((cmd_buff[0] >> 6) & 0x3F);
-    std::string function_string = Common::StringFromFormat("function '%s': port=%s", name, port_name);
+    std::string function_string =
+        Common::StringFromFormat("function '%s': port=%s", name, port_name);
    for (int i = 1; i <= num_params; ++i) {
        function_string += Common::StringFromFormat(", cmd_buff[%i]=0x%X", i, cmd_buff[i]);
    }
@@ -66,14 +68,19 @@ ResultVal<bool> Interface::SyncRequest() {
    auto itr = m_functions.find(cmd_buff[0]);
    if (itr == m_functions.end() || itr->second.func == nullptr) {
-        std::string function_name = (itr == m_functions.end()) ? Common::StringFromFormat("0x%08X", cmd_buff[0]) : itr->second.name;
+        std::string function_name = (itr == m_functions.end())
-        LOG_ERROR(Service, "unknown / unimplemented %s", MakeFunctionString(function_name.c_str(), GetPortName().c_str(), cmd_buff).c_str());
+                                        ? Common::StringFromFormat("0x%08X", cmd_buff[0])
+                                        : itr->second.name;
+        LOG_ERROR(
+            Service, "unknown / unimplemented %s",
+            MakeFunctionString(function_name.c_str(), GetPortName().c_str(), cmd_buff).c_str());
        // TODO(bunnei): Hack - ignore error
        cmd_buff[1] = 0;
        return MakeResult<bool>(false);
    }
-    LOG_TRACE(Service, "%s", MakeFunctionString(itr->second.name, GetPortName().c_str(), cmd_buff).c_str());
+    LOG_TRACE(Service, "%s",
+              MakeFunctionString(itr->second.name, GetPortName().c_str(), cmd_buff).c_str());
    itr->second.func(this);
@@ -163,6 +170,4 @@ void Shutdown() {
    g_kernel_named_ports.clear();
    LOG_DEBUG(Service, "shutdown OK");
 }
 }
diff --git a/src/core/hle/service/service.h b/src/core/hle/service/service.h
index f31135212..cd216f27e 100644
--- a/src/core/hle/service/service.h
+++ b/src/core/hle/service/service.h
@@ -28,13 +28,15 @@ class Interface : public Kernel::Session {
    // just something that encapsulates a session and acts as a helper to implement service
    // processes.
 public:
-    std::string GetName() const override { return GetPortName(); }
+    std::string GetName() const override {
+        return GetPortName();
+    }
    typedef void (*Function)(Interface*);
    struct FunctionInfo {
-        u32         id;
+        u32 id;
-        Function    func;
+        Function func;
        const char* name;
    };
@@ -49,7 +51,6 @@ public:
    ResultVal<bool> SyncRequest() override;
 protected:
    /**
     * Registers the functions in the service
     */
@@ -62,7 +63,6 @@ protected:
 private:
    boost::container::flat_map<u32, FunctionInfo> m_functions;
 };
 /// Initialize ServiceManager
diff --git a/src/core/hle/service/soc_u.cpp b/src/core/hle/service/soc_u.cpp
index 9b285567b..695b286c0 100644
--- a/src/core/hle/service/soc_u.cpp
+++ b/src/core/hle/service/soc_u.cpp
@@ -19,40 +19,40 @@
 #include "core/memory.h"
 #ifdef _WIN32
-    #include <winsock2.h>
+#include <winsock2.h>
-    #include <ws2tcpip.h>
+#include <ws2tcpip.h>
-    // MinGW does not define several errno constants
+// MinGW does not define several errno constants
-    #ifndef _MSC_VER
+#ifndef _MSC_VER
-        #define EBADMSG 104
+#define EBADMSG 104
-        #define ENODATA 120
+#define ENODATA 120
-        #define ENOMSG  122
+#define ENOMSG 122
-        #define ENOSR   124
+#define ENOSR 124
-        #define ENOSTR  125
+#define ENOSTR 125
-        #define ETIME   137
+#define ETIME 137
-        #define EIDRM   2001
+#define EIDRM 2001
-        #define ENOLINK 2002
+#define ENOLINK 2002
-    #endif // _MSC_VER
+#endif // _MSC_VER
 #else
-    #include <cerrno>
+#include <cerrno>
-    #include <fcntl.h>
+#include <fcntl.h>
-    #include <netinet/in.h>
+#include <netdb.h>
-    #include <netdb.h>
+#include <netinet/in.h>
-    #include <poll.h>
+#include <poll.h>
-    #include <sys/socket.h>
+#include <sys/socket.h>
-    #include <unistd.h>
+#include <unistd.h>
 #endif
 #ifdef _WIN32
-#    define WSAEAGAIN      WSAEWOULDBLOCK
+#define WSAEAGAIN WSAEWOULDBLOCK
-#    define WSAEMULTIHOP   -1 // Invalid dummy value
+#define WSAEMULTIHOP -1 // Invalid dummy value
-#    define ERRNO(x)       WSA##x
+#define ERRNO(x) WSA##x
-#    define GET_ERRNO      WSAGetLastError()
+#define GET_ERRNO WSAGetLastError()
-#    define poll(x, y, z)  WSAPoll(x, y, z);
+#define poll(x, y, z) WSAPoll(x, y, z);
 #else
-#    define ERRNO(x)       x
+#define ERRNO(x) x
-#    define GET_ERRNO      errno
+#define GET_ERRNO errno
-#    define closesocket(x) close(x)
+#define closesocket(x) close(x)
 #endif
 static const s32 SOCKET_ERROR_VALUE = -1;
@@ -63,84 +63,82 @@ static const s32 SOCKET_ERROR_VALUE = -1;
 namespace SOC_U {
 /// Holds the translation from system network errors to 3DS network errors
-static const std::unordered_map<int, int> error_map = { {
+static const std::unordered_map<int, int> error_map = {{{E2BIG, 1},
-    { E2BIG, 1 },
+                                                        {ERRNO(EACCES), 2},
-    { ERRNO(EACCES), 2 },
+                                                        {ERRNO(EADDRINUSE), 3},
-    { ERRNO(EADDRINUSE), 3 },
+                                                        {ERRNO(EADDRNOTAVAIL), 4},
-    { ERRNO(EADDRNOTAVAIL), 4 },
+                                                        {ERRNO(EAFNOSUPPORT), 5},
-    { ERRNO(EAFNOSUPPORT), 5 },
+                                                        {ERRNO(EAGAIN), 6},
-    { ERRNO(EAGAIN), 6 },
+                                                        {ERRNO(EALREADY), 7},
-    { ERRNO(EALREADY), 7 },
+                                                        {ERRNO(EBADF), 8},
-    { ERRNO(EBADF), 8 },
+                                                        {EBADMSG, 9},
-    { EBADMSG, 9 },
+                                                        {EBUSY, 10},
-    { EBUSY, 10 },
+                                                        {ECANCELED, 11},
-    { ECANCELED, 11 },
+                                                        {ECHILD, 12},
-    { ECHILD, 12 },
+                                                        {ERRNO(ECONNABORTED), 13},
-    { ERRNO(ECONNABORTED), 13 },
+                                                        {ERRNO(ECONNREFUSED), 14},
-    { ERRNO(ECONNREFUSED), 14 },
+                                                        {ERRNO(ECONNRESET), 15},
-    { ERRNO(ECONNRESET), 15 },
+                                                        {EDEADLK, 16},
-    { EDEADLK, 16 },
+                                                        {ERRNO(EDESTADDRREQ), 17},
-    { ERRNO(EDESTADDRREQ), 17 },
+                                                        {EDOM, 18},
-    { EDOM, 18 },
+                                                        {ERRNO(EDQUOT), 19},
-    { ERRNO(EDQUOT), 19 },
+                                                        {EEXIST, 20},
-    { EEXIST, 20 },
+                                                        {ERRNO(EFAULT), 21},
-    { ERRNO(EFAULT), 21 },
+                                                        {EFBIG, 22},
-    { EFBIG, 22 },
+                                                        {ERRNO(EHOSTUNREACH), 23},
-    { ERRNO(EHOSTUNREACH), 23 },
+                                                        {EIDRM, 24},
-    { EIDRM, 24 },
+                                                        {EILSEQ, 25},
-    { EILSEQ, 25 },
+                                                        {ERRNO(EINPROGRESS), 26},
-    { ERRNO(EINPROGRESS), 26 },
+                                                        {ERRNO(EINTR), 27},
-    { ERRNO(EINTR), 27 },
+                                                        {ERRNO(EINVAL), 28},
-    { ERRNO(EINVAL), 28 },
+                                                        {EIO, 29},
-    { EIO, 29 },
+                                                        {ERRNO(EISCONN), 30},
-    { ERRNO(EISCONN), 30 },
+                                                        {EISDIR, 31},
-    { EISDIR, 31 },
+                                                        {ERRNO(ELOOP), 32},
-    { ERRNO(ELOOP), 32 },
+                                                        {ERRNO(EMFILE), 33},
-    { ERRNO(EMFILE), 33 },
+                                                        {EMLINK, 34},
-    { EMLINK, 34 },
+                                                        {ERRNO(EMSGSIZE), 35},
-    { ERRNO(EMSGSIZE), 35 },
+                                                        {ERRNO(EMULTIHOP), 36},
-    { ERRNO(EMULTIHOP), 36 },
+                                                        {ERRNO(ENAMETOOLONG), 37},
-    { ERRNO(ENAMETOOLONG), 37 },
+                                                        {ERRNO(ENETDOWN), 38},
-    { ERRNO(ENETDOWN), 38 },
+                                                        {ERRNO(ENETRESET), 39},
-    { ERRNO(ENETRESET), 39 },
+                                                        {ERRNO(ENETUNREACH), 40},
-    { ERRNO(ENETUNREACH), 40 },
+                                                        {ENFILE, 41},
-    { ENFILE, 41 },
+                                                        {ERRNO(ENOBUFS), 42},
-    { ERRNO(ENOBUFS), 42 },
+                                                        {ENODATA, 43},
-    { ENODATA, 43 },
+                                                        {ENODEV, 44},
-    { ENODEV, 44 },
+                                                        {ENOENT, 45},
-    { ENOENT, 45 },
+                                                        {ENOEXEC, 46},
-    { ENOEXEC, 46 },
+                                                        {ENOLCK, 47},
-    { ENOLCK, 47 },
+                                                        {ENOLINK, 48},
-    { ENOLINK, 48 },
+                                                        {ENOMEM, 49},
-    { ENOMEM, 49 },
+                                                        {ENOMSG, 50},
-    { ENOMSG, 50 },
+                                                        {ERRNO(ENOPROTOOPT), 51},
-    { ERRNO(ENOPROTOOPT), 51 },
+                                                        {ENOSPC, 52},
-    { ENOSPC, 52 },
+                                                        {ENOSR, 53},
-    { ENOSR, 53 },
+                                                        {ENOSTR, 54},
-    { ENOSTR, 54 },
+                                                        {ENOSYS, 55},
-    { ENOSYS, 55 },
+                                                        {ERRNO(ENOTCONN), 56},
-    { ERRNO(ENOTCONN), 56 },
+                                                        {ENOTDIR, 57},
-    { ENOTDIR, 57 },
+                                                        {ERRNO(ENOTEMPTY), 58},
-    { ERRNO(ENOTEMPTY), 58 },
+                                                        {ERRNO(ENOTSOCK), 59},
-    { ERRNO(ENOTSOCK), 59 },
+                                                        {ENOTSUP, 60},
-    { ENOTSUP, 60 },
+                                                        {ENOTTY, 61},
-    { ENOTTY, 61 },
+                                                        {ENXIO, 62},
-    { ENXIO, 62 },
+                                                        {ERRNO(EOPNOTSUPP), 63},
-    { ERRNO(EOPNOTSUPP), 63 },
+                                                        {EOVERFLOW, 64},
-    { EOVERFLOW, 64 },
+                                                        {EPERM, 65},
-    { EPERM, 65 },
+                                                        {EPIPE, 66},
-    { EPIPE, 66 },
+                                                        {EPROTO, 67},
-    { EPROTO, 67 },
+                                                        {ERRNO(EPROTONOSUPPORT), 68},
-    { ERRNO(EPROTONOSUPPORT), 68 },
+                                                        {ERRNO(EPROTOTYPE), 69},
-    { ERRNO(EPROTOTYPE), 69 },
+                                                        {ERANGE, 70},
-    { ERANGE, 70 },
+                                                        {EROFS, 71},
-    { EROFS, 71 },
+                                                        {ESPIPE, 72},
-    { ESPIPE, 72 },
+                                                        {ESRCH, 73},
-    { ESRCH, 73 },
+                                                        {ERRNO(ESTALE), 74},
-    { ERRNO(ESTALE), 74 },
+                                                        {ETIME, 75},
-    { ETIME, 75 },
+                                                        {ERRNO(ETIMEDOUT), 76}}};
-    { ERRNO(ETIMEDOUT), 76 }
-}};
 /// Converts a network error from platform-specific to 3ds-specific
 static int TranslateError(int error) {
@@ -153,21 +151,21 @@ static int TranslateError(int error) {
 /// Holds the translation from system network socket options to 3DS network socket options
 /// Note: -1 = No effect/unavailable
-static const std::unordered_map<int, int> sockopt_map = { {
+static const std::unordered_map<int, int> sockopt_map = {{
-    { 0x0004,   SO_REUSEADDR },
+    {0x0004, SO_REUSEADDR},
-    { 0x0080,   -1 },
+    {0x0080, -1},
-    { 0x0100,   -1 },
+    {0x0100, -1},
-    { 0x1001,   SO_SNDBUF },
+    {0x1001, SO_SNDBUF},
-    { 0x1002,   SO_RCVBUF },
+    {0x1002, SO_RCVBUF},
-    { 0x1003,   -1 },
+    {0x1003, -1},
 #ifdef _WIN32
    /// Unsupported in WinSock2
-    { 0x1004,   -1 },
+    {0x1004, -1},
 #else
-    { 0x1004,   SO_RCVLOWAT },
+    {0x1004, SO_RCVLOWAT},
 #endif
-    { 0x1008,   SO_TYPE },
+    {0x1008, SO_TYPE},
-    { 0x1009,   SO_ERROR },
+    {0x1009, SO_ERROR},
 }};
 /// Converts a socket option from 3ds-specific to platform-specific
@@ -203,7 +201,8 @@ struct CTRPollFD {
            return *this;
        }
-        /// Translates the resulting events of a Poll operation from platform-specific to 3ds specific
+        /// Translates the resulting events of a Poll operation from platform-specific to 3ds
+        /// specific
        static Events TranslateTo3DS(u32 input_event) {
            Events ev = {};
            if (input_event & POLLIN)
@@ -221,7 +220,8 @@ struct CTRPollFD {
            return ev;
        }
-        /// Translates the resulting events of a Poll operation from 3ds specific to platform specific
+        /// Translates the resulting events of a Poll operation from 3ds specific to platform
+        /// specific
        static u32 TranslateToPlatform(Events input_event) {
            u32 ret = 0;
            if (input_event.pollin)
@@ -239,7 +239,7 @@ struct CTRPollFD {
            return ret;
        }
    };
-    Events events; ///< Events to poll for (input)
+    Events events;  ///< Events to poll for (input)
    Events revents; ///< Events received (output)
    /// Converts a platform-specific pollfd to a 3ds specific structure
@@ -265,17 +265,17 @@ struct CTRPollFD {
 union CTRSockAddr {
    /// Structure to represent a raw sockaddr
    struct {
-        u8 len; ///< The length of the entire structure, only the set fields count
+        u8 len;           ///< The length of the entire structure, only the set fields count
-        u8 sa_family; ///< The address family of the sockaddr
+        u8 sa_family;     ///< The address family of the sockaddr
        u8 sa_data[0x1A]; ///< The extra data, this varies, depending on the address family
    } raw;
    /// Structure to represent the 3ds' sockaddr_in structure
    struct CTRSockAddrIn {
-        u8 len; ///< The length of the entire structure
+        u8 len;        ///< The length of the entire structure
        u8 sin_family; ///< The address family of the sockaddr_in
-        u16 sin_port; ///< The port associated with this sockaddr_in
+        u16 sin_port;  ///< The port associated with this sockaddr_in
-        u32 sin_addr; ///< The actual address of the sockaddr_in
+        u32 sin_addr;  ///< The actual address of the sockaddr_in
    } in;
    /// Convert a 3DS CTRSockAddr to a platform-specific sockaddr
@@ -286,8 +286,7 @@ union CTRSockAddr {
        // We can not guarantee ABI compatibility between platforms so we copy the fields manually
        switch (result.sa_family) {
-        case AF_INET:
+        case AF_INET: {
-        {
            sockaddr_in* result_in = reinterpret_cast<sockaddr_in*>(&result);
            result_in->sin_port = ctr_addr.in.sin_port;
            result_in->sin_addr.s_addr = ctr_addr.in.sin_addr;
@@ -307,8 +306,7 @@ union CTRSockAddr {
        result.raw.sa_family = static_cast<u8>(addr.sa_family);
        // We can not guarantee ABI compatibility between platforms so we copy the fields manually
        switch (result.raw.sa_family) {
-        case AF_INET:
+        case AF_INET: {
-        {
            sockaddr_in const* addr_in = reinterpret_cast<sockaddr_in const*>(&addr);
            result.raw.len = sizeof(CTRSockAddrIn);
            result.in.sin_port = addr_in->sin_port;
@@ -341,24 +339,27 @@ static void Socket(Service::Interface* self) {
    // Only 0 is allowed according to 3dbrew, using 0 will let the OS decide which protocol to use
    if (protocol != 0) {
-        cmd_buffer[1] = UnimplementedFunction(ErrorModule::SOC).raw; // TODO(Subv): Correct error code
+        cmd_buffer[1] =
+            UnimplementedFunction(ErrorModule::SOC).raw; // TODO(Subv): Correct error code
        return;
    }
    if (domain != AF_INET) {
-        cmd_buffer[1] = UnimplementedFunction(ErrorModule::SOC).raw; // TODO(Subv): Correct error code
+        cmd_buffer[1] =
+            UnimplementedFunction(ErrorModule::SOC).raw; // TODO(Subv): Correct error code
        return;
    }
    if (type != SOCK_DGRAM && type != SOCK_STREAM) {
-        cmd_buffer[1] = UnimplementedFunction(ErrorModule::SOC).raw; // TODO(Subv): Correct error code
+        cmd_buffer[1] =
+            UnimplementedFunction(ErrorModule::SOC).raw; // TODO(Subv): Correct error code
        return;
    }
    u32 socket_handle = static_cast<u32>(::socket(domain, type, protocol));
    if ((s32)socket_handle != SOCKET_ERROR_VALUE)
-        open_sockets[socket_handle] = { socket_handle, true };
+        open_sockets[socket_handle] = {socket_handle, true};
    int result = 0;
    if ((s32)socket_handle == SOCKET_ERROR_VALUE)
@@ -406,8 +407,8 @@ static void Fcntl(Service::Interface* self) {
    int result = 0;
    u32 posix_ret = 0; // TODO: Check what hardware returns for F_SETFL (unspecified by POSIX)
    SCOPE_EXIT({
-            cmd_buffer[1] = result;
+        cmd_buffer[1] = result;
-            cmd_buffer[2] = posix_ret;
+        cmd_buffer[2] = posix_ret;
    });
    if (ctr_cmd == 3) { // F_GETFL
@@ -493,7 +494,7 @@ static void Accept(Service::Interface* self) {
    u32 ret = static_cast<u32>(::accept(socket_handle, &addr, &addr_len));
    if ((s32)ret != SOCKET_ERROR_VALUE)
-        open_sockets[ret] = { ret, true };
+        open_sockets[ret] = {ret, true};
    int result = 0;
    if ((s32)ret == SOCKET_ERROR_VALUE) {
@@ -573,9 +574,11 @@ static void SendTo(Service::Interface* self) {
    int ret = -1;
    if (addr_len > 0) {
        sockaddr dest_addr = CTRSockAddr::ToPlatform(ctr_dest_addr);
-        ret = ::sendto(socket_handle, reinterpret_cast<const char*>(input_buff.data()), len, flags, &dest_addr, sizeof(dest_addr));
+        ret = ::sendto(socket_handle, reinterpret_cast<const char*>(input_buff.data()), len, flags,
+                       &dest_addr, sizeof(dest_addr));
    } else {
-        ret = ::sendto(socket_handle, reinterpret_cast<const char*>(input_buff.data()), len, flags, nullptr, 0);
+        ret = ::sendto(socket_handle, reinterpret_cast<const char*>(input_buff.data()), len, flags,
+                       nullptr, 0);
    }
    int result = 0;
@@ -596,8 +599,7 @@ static void RecvFrom(Service::Interface* self) {
    u32 flags = cmd_buffer[3];
    socklen_t addr_len = static_cast<socklen_t>(cmd_buffer[4]);
-    struct
+    struct {
-    {
        u32 output_buffer_descriptor;
        u32 output_buffer_addr;
        u32 address_buffer_descriptor;
@@ -619,11 +621,13 @@ static void RecvFrom(Service::Interface* self) {
    std::vector<u8> output_buff(len);
    sockaddr src_addr;
    socklen_t src_addr_len = sizeof(src_addr);
-    int ret = ::recvfrom(socket_handle, reinterpret_cast<char*>(output_buff.data()), len, flags, &src_addr, &src_addr_len);
+    int ret = ::recvfrom(socket_handle, reinterpret_cast<char*>(output_buff.data()), len, flags,
+                         &src_addr, &src_addr_len);
    if (ret >= 0 && buffer_parameters.output_src_address_buffer != 0 && src_addr_len > 0) {
        CTRSockAddr ctr_src_addr = CTRSockAddr::FromPlatform(src_addr);
-        Memory::WriteBlock(buffer_parameters.output_src_address_buffer, &ctr_src_addr, sizeof(ctr_src_addr));
+        Memory::WriteBlock(buffer_parameters.output_src_address_buffer, &ctr_src_addr,
+                           sizeof(ctr_src_addr));
    }
    int result = 0;
@@ -633,7 +637,8 @@ static void RecvFrom(Service::Interface* self) {
        total_received = 0;
    } else {
        // Write only the data we received to avoid overwriting parts of the buffer with zeros
-        Memory::WriteBlock(buffer_parameters.output_buffer_addr, output_buff.data(), total_received);
+        Memory::WriteBlock(buffer_parameters.output_buffer_addr, output_buff.data(),
+                           total_received);
    }
    cmd_buffer[1] = result;
@@ -648,7 +653,8 @@ static void Poll(Service::Interface* self) {
    VAddr input_fds_addr = cmd_buffer[6];
    VAddr output_fds_addr = cmd_buffer[0x104 >> 2];
-    if (!Memory::IsValidVirtualAddress(input_fds_addr) || !Memory::IsValidVirtualAddress(output_fds_addr)) {
+    if (!Memory::IsValidVirtualAddress(input_fds_addr) ||
+        !Memory::IsValidVirtualAddress(output_fds_addr)) {
        cmd_buffer[1] = -1; // TODO(Subv): Find correct error code.
        return;
    }
@@ -656,7 +662,8 @@ static void Poll(Service::Interface* self) {
    std::vector<CTRPollFD> ctr_fds(nfds);
    Memory::ReadBlock(input_fds_addr, ctr_fds.data(), nfds * sizeof(CTRPollFD));
-    // The 3ds_pollfd and the pollfd structures may be different (Windows/Linux have different sizes)
+    // The 3ds_pollfd and the pollfd structures may be different (Windows/Linux have different
+    // sizes)
    // so we have to copy the data
    std::vector<pollfd> platform_pollfd(nfds);
    std::transform(ctr_fds.begin(), ctr_fds.end(), platform_pollfd.begin(), CTRPollFD::ToPlatform);
@@ -664,7 +671,8 @@ static void Poll(Service::Interface* self) {
    const int ret = ::poll(platform_pollfd.data(), nfds, timeout);
    // Now update the output pollfd structure
-    std::transform(platform_pollfd.begin(), platform_pollfd.end(), ctr_fds.begin(), CTRPollFD::FromPlatform);
+    std::transform(platform_pollfd.begin(), platform_pollfd.end(), ctr_fds.begin(),
+                   CTRPollFD::FromPlatform);
    Memory::WriteBlock(output_fds_addr, ctr_fds.data(), nfds * sizeof(CTRPollFD));
@@ -775,7 +783,7 @@ static void Connect(Service::Interface* self) {
 }
 static void InitializeSockets(Service::Interface* self) {
-    // TODO(Subv): Implement
+// TODO(Subv): Implement
 #ifdef _WIN32
    WSADATA data;
    WSAStartup(MAKEWORD(2, 2), &data);
@@ -808,7 +816,7 @@ static void GetSockOpt(Service::Interface* self) {
    int ret = -1;
    int err = 0;
-    if(optname < 0) {
+    if (optname < 0) {
 #ifdef _WIN32
        err = WSAEINVAL;
 #else
@@ -818,7 +826,7 @@ static void GetSockOpt(Service::Interface* self) {
        // 0x100 = static buffer offset (bytes)
        // + 0x4 = 2nd pointer (u32) position
        // >> 2  = convert to u32 offset instead of byte offset (cmd_buffer = u32*)
-        char* optval = reinterpret_cast<char *>(Memory::GetPointer(cmd_buffer[0x104 >> 2]));
+        char* optval = reinterpret_cast<char*>(Memory::GetPointer(cmd_buffer[0x104 >> 2]));
        ret = ::getsockopt(socket_handle, level, optname, optval, &optlen);
        err = 0;
@@ -842,7 +850,7 @@ static void SetSockOpt(Service::Interface* self) {
    int ret = -1;
    int err = 0;
-    if(optname < 0) {
+    if (optname < 0) {
 #ifdef _WIN32
        err = WSAEINVAL;
 #else
@@ -850,7 +858,7 @@ static void SetSockOpt(Service::Interface* self) {
 #endif
    } else {
        socklen_t optlen = static_cast<socklen_t>(cmd_buffer[4]);
-        const char* optval = reinterpret_cast<const char *>(Memory::GetPointer(cmd_buffer[8]));
+        const char* optval = reinterpret_cast<const char*>(Memory::GetPointer(cmd_buffer[8]));
        ret = static_cast<u32>(::setsockopt(socket_handle, level, optname, optval, optlen));
        err = 0;
@@ -865,39 +873,39 @@ static void SetSockOpt(Service::Interface* self) {
 }
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010044, InitializeSockets,             "InitializeSockets"},
+    {0x00010044, InitializeSockets, "InitializeSockets"},
-    {0x000200C2, Socket,                        "Socket"},
+    {0x000200C2, Socket, "Socket"},
-    {0x00030082, Listen,                        "Listen"},
+    {0x00030082, Listen, "Listen"},
-    {0x00040082, Accept,                        "Accept"},
+    {0x00040082, Accept, "Accept"},
-    {0x00050084, Bind,                          "Bind"},
+    {0x00050084, Bind, "Bind"},
-    {0x00060084, Connect,                       "Connect"},
+    {0x00060084, Connect, "Connect"},
-    {0x00070104, nullptr,                       "recvfrom_other"},
+    {0x00070104, nullptr, "recvfrom_other"},
-    {0x00080102, RecvFrom,                      "RecvFrom"},
+    {0x00080102, RecvFrom, "RecvFrom"},
-    {0x00090106, nullptr,                       "sendto_other"},
+    {0x00090106, nullptr, "sendto_other"},
-    {0x000A0106, SendTo,                        "SendTo"},
+    {0x000A0106, SendTo, "SendTo"},
-    {0x000B0042, Close,                         "Close"},
+    {0x000B0042, Close, "Close"},
-    {0x000C0082, Shutdown,                      "Shutdown"},
+    {0x000C0082, Shutdown, "Shutdown"},
-    {0x000D0082, nullptr,                       "GetHostByName"},
+    {0x000D0082, nullptr, "GetHostByName"},
-    {0x000E00C2, nullptr,                       "GetHostByAddr"},
+    {0x000E00C2, nullptr, "GetHostByAddr"},
-    {0x000F0106, nullptr,                       "GetAddrInfo"},
+    {0x000F0106, nullptr, "GetAddrInfo"},
-    {0x00100102, nullptr,                       "GetNameInfo"},
+    {0x00100102, nullptr, "GetNameInfo"},
-    {0x00110102, GetSockOpt,                    "GetSockOpt"},
+    {0x00110102, GetSockOpt, "GetSockOpt"},
-    {0x00120104, SetSockOpt,                    "SetSockOpt"},
+    {0x00120104, SetSockOpt, "SetSockOpt"},
-    {0x001300C2, Fcntl,                         "Fcntl"},
+    {0x001300C2, Fcntl, "Fcntl"},
-    {0x00140084, Poll,                          "Poll"},
+    {0x00140084, Poll, "Poll"},
-    {0x00150042, nullptr,                       "SockAtMark"},
+    {0x00150042, nullptr, "SockAtMark"},
-    {0x00160000, GetHostId,                     "GetHostId"},
+    {0x00160000, GetHostId, "GetHostId"},
-    {0x00170082, GetSockName,                   "GetSockName"},
+    {0x00170082, GetSockName, "GetSockName"},
-    {0x00180082, GetPeerName,                   "GetPeerName"},
+    {0x00180082, GetPeerName, "GetPeerName"},
-    {0x00190000, ShutdownSockets,               "ShutdownSockets"},
+    {0x00190000, ShutdownSockets, "ShutdownSockets"},
-    {0x001A00C0, nullptr,                       "GetNetworkOpt"},
+    {0x001A00C0, nullptr, "GetNetworkOpt"},
-    {0x001B0040, nullptr,                       "ICMPSocket"},
+    {0x001B0040, nullptr, "ICMPSocket"},
-    {0x001C0104, nullptr,                       "ICMPPing"},
+    {0x001C0104, nullptr, "ICMPPing"},
-    {0x001D0040, nullptr,                       "ICMPCancel"},
+    {0x001D0040, nullptr, "ICMPCancel"},
-    {0x001E0040, nullptr,                       "ICMPClose"},
+    {0x001E0040, nullptr, "ICMPClose"},
-    {0x001F0040, nullptr,                       "GetResolverInfo"},
+    {0x001F0040, nullptr, "GetResolverInfo"},
-    {0x00210002, nullptr,                       "CloseSockets"},
+    {0x00210002, nullptr, "CloseSockets"},
-    {0x00230040, nullptr,                       "AddGlobalSocket"},
+    {0x00230040, nullptr, "AddGlobalSocket"},
 };
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/srv.cpp b/src/core/hle/service/srv.cpp
index 3c05f836b..fda9d8acf 100644
--- a/src/core/hle/service/srv.cpp
+++ b/src/core/hle/service/srv.cpp
@@ -5,8 +5,8 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "core/hle/service/srv.h"
 #include "core/hle/kernel/event.h"
+#include "core/hle/service/srv.h"
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Namespace SRV
@@ -28,13 +28,14 @@ static void RegisterClient(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    if (cmd_buff[1] != IPC::CallingPidDesc()) {
-        cmd_buff[0] = IPC::MakeHeader(0x0, 0x1, 0); //0x40
+        cmd_buff[0] = IPC::MakeHeader(0x0, 0x1, 0); // 0x40
        cmd_buff[1] = ResultCode(ErrorDescription::OS_InvalidBufferDescriptor, ErrorModule::OS,
-                                 ErrorSummary::WrongArgument, ErrorLevel::Permanent).raw;
+                                 ErrorSummary::WrongArgument, ErrorLevel::Permanent)
+                          .raw;
        return;
    }
-    cmd_buff[0] = IPC::MakeHeader(0x1, 0x1, 0); //0x10040
+    cmd_buff[0] = IPC::MakeHeader(0x1, 0x1, 0); // 0x10040
-    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
+    cmd_buff[1] = RESULT_SUCCESS.raw;           // No error
    LOG_WARNING(Service_SRV, "(STUBBED) called");
 }
@@ -56,7 +57,7 @@ static void EnableNotification(Service::Interface* self) {
    event_handle->Clear();
    cmd_buff[0] = IPC::MakeHeader(0x2, 0x1, 0x2); // 0x20042
-    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
+    cmd_buff[1] = RESULT_SUCCESS.raw;             // No error
    cmd_buff[2] = IPC::CopyHandleDesc(1);
    cmd_buff[3] = Kernel::g_handle_table.Create(event_handle).MoveFrom();
    LOG_WARNING(Service_SRV, "(STUBBED) called");
@@ -105,7 +106,7 @@ static void Subscribe(Service::Interface* self) {
    u32 notification_id = cmd_buff[1];
    cmd_buff[0] = IPC::MakeHeader(0x9, 0x1, 0); // 0x90040
-    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
+    cmd_buff[1] = RESULT_SUCCESS.raw;           // No error
    LOG_WARNING(Service_SRV, "(STUBBED) called, notification_id=0x%X", notification_id);
 }
@@ -124,7 +125,7 @@ static void Unsubscribe(Service::Interface* self) {
    u32 notification_id = cmd_buff[1];
    cmd_buff[0] = IPC::MakeHeader(0xA, 0x1, 0); // 0xA0040
-    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
+    cmd_buff[1] = RESULT_SUCCESS.raw;           // No error
    LOG_WARNING(Service_SRV, "(STUBBED) called, notification_id=0x%X", notification_id);
 }
@@ -145,25 +146,26 @@ static void PublishToSubscriber(Service::Interface* self) {
    u8 flags = cmd_buff[2] & 0xFF;
    cmd_buff[0] = IPC::MakeHeader(0xC, 0x1, 0); // 0xC0040
-    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
+    cmd_buff[1] = RESULT_SUCCESS.raw;           // No error
-    LOG_WARNING(Service_SRV, "(STUBBED) called, notification_id=0x%X, flags=%u", notification_id, flags);
+    LOG_WARNING(Service_SRV, "(STUBBED) called, notification_id=0x%X, flags=%u", notification_id,
+                flags);
 }
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010002, RegisterClient,          "RegisterClient"},
+    {0x00010002, RegisterClient, "RegisterClient"},
-    {0x00020000, EnableNotification,      "EnableNotification"},
+    {0x00020000, EnableNotification, "EnableNotification"},
-    {0x00030100, nullptr,                 "RegisterService"},
+    {0x00030100, nullptr, "RegisterService"},
-    {0x000400C0, nullptr,                 "UnregisterService"},
+    {0x000400C0, nullptr, "UnregisterService"},
-    {0x00050100, GetServiceHandle,        "GetServiceHandle"},
+    {0x00050100, GetServiceHandle, "GetServiceHandle"},
-    {0x000600C2, nullptr,                 "RegisterPort"},
+    {0x000600C2, nullptr, "RegisterPort"},
-    {0x000700C0, nullptr,                 "UnregisterPort"},
+    {0x000700C0, nullptr, "UnregisterPort"},
-    {0x00080100, nullptr,                 "GetPort"},
+    {0x00080100, nullptr, "GetPort"},
-    {0x00090040, Subscribe,               "Subscribe"},
+    {0x00090040, Subscribe, "Subscribe"},
-    {0x000A0040, Unsubscribe,             "Unsubscribe"},
+    {0x000A0040, Unsubscribe, "Unsubscribe"},
-    {0x000B0000, nullptr,                 "ReceiveNotification"},
+    {0x000B0000, nullptr, "ReceiveNotification"},
-    {0x000C0080, PublishToSubscriber,     "PublishToSubscriber"},
+    {0x000C0080, PublishToSubscriber, "PublishToSubscriber"},
-    {0x000D0040, nullptr,                 "PublishAndGetSubscriber"},
+    {0x000D0040, nullptr, "PublishAndGetSubscriber"},
-    {0x000E00C0, nullptr,                 "IsServiceRegistered"},
+    {0x000E00C0, nullptr, "IsServiceRegistered"},
 };
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/ssl_c.cpp b/src/core/hle/service/ssl_c.cpp
index a8aff1abf..47c4a8cb0 100644
--- a/src/core/hle/service/ssl_c.cpp
+++ b/src/core/hle/service/ssl_c.cpp
@@ -37,7 +37,8 @@ static void GenerateRandomData(Service::Interface* self) {
    u32 i = 0;
    while (i < size) {
        if ((i % 4) == 0) {
-            // The random number generator returns 4 bytes worth of data, so generate new random data when i == 0 and when i is divisible by 4
+            // The random number generator returns 4 bytes worth of data, so generate new random
+            // data when i == 0 and when i is divisible by 4
            data = rand_gen();
        }
@@ -59,27 +60,26 @@ static void GenerateRandomData(Service::Interface* self) {
 }
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010002, Initialize,            "Initialize"},
+    {0x00010002, Initialize, "Initialize"},
-    {0x000200C2, nullptr,               "CreateContext"},
+    {0x000200C2, nullptr, "CreateContext"},
-    {0x00030000, nullptr,               "CreateRootCertChain"},
+    {0x00030000, nullptr, "CreateRootCertChain"},
-    {0x00040040, nullptr,               "DestroyRootCertChain"},
+    {0x00040040, nullptr, "DestroyRootCertChain"},
-    {0x00050082, nullptr,               "AddTrustedRootCA"},
+    {0x00050082, nullptr, "AddTrustedRootCA"},
-    {0x00060080, nullptr,               "RootCertChainAddDefaultCert"},
+    {0x00060080, nullptr, "RootCertChainAddDefaultCert"},
-    {0x00070080, nullptr,               "RootCertChainRemoveCert"},
+    {0x00070080, nullptr, "RootCertChainRemoveCert"},
-    {0x000E0040, nullptr,               "OpenDefaultClientCertContext"},
+    {0x000E0040, nullptr, "OpenDefaultClientCertContext"},
-    {0x000F0040, nullptr,               "CloseClientCertContext"},
+    {0x000F0040, nullptr, "CloseClientCertContext"},
-    {0x00110042, GenerateRandomData,    "GenerateRandomData"},
+    {0x00110042, GenerateRandomData, "GenerateRandomData"},
-    {0x00120042, nullptr,               "InitializeConnectionSession"},
+    {0x00120042, nullptr, "InitializeConnectionSession"},
-    {0x00130040, nullptr,               "StartConnection"},
+    {0x00130040, nullptr, "StartConnection"},
-    {0x00140040, nullptr,               "StartConnectionGetOut"},
+    {0x00140040, nullptr, "StartConnectionGetOut"},
-    {0x00150082, nullptr,               "Read"},
+    {0x00150082, nullptr, "Read"},
-    {0x00170082, nullptr,               "Write"},
+    {0x00170082, nullptr, "Write"},
-    {0x00180080, nullptr,               "ContextSetRootCertChain"},
+    {0x00180080, nullptr, "ContextSetRootCertChain"},
-    {0x00190080, nullptr,               "ContextSetClientCert"},
+    {0x00190080, nullptr, "ContextSetClientCert"},
-    {0x001B0080, nullptr,               "ContextClearOpt"},
+    {0x001B0080, nullptr, "ContextClearOpt"},
-    {0x001E0040, nullptr,               "DestroyContext"},
+    {0x001E0040, nullptr, "DestroyContext"},
-    {0x001F0082, nullptr,               "ContextInitSharedmem"}
+    {0x001F0082, nullptr, "ContextInitSharedmem"}};
-};
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Interface class
diff --git a/src/core/hle/service/y2r_u.cpp b/src/core/hle/service/y2r_u.cpp
index d16578f87..278548e0e 100644
--- a/src/core/hle/service/y2r_u.cpp
+++ b/src/core/hle/service/y2r_u.cpp
@@ -39,16 +39,16 @@ static u32 transfer_end_interrupt_enabled = 0;
 static u32 spacial_dithering_enabled = 0;
 static const CoefficientSet standard_coefficients[4] = {
-    {{ 0x100, 0x166, 0xB6, 0x58, 0x1C5, -0x166F, 0x10EE, -0x1C5B }}, // ITU_Rec601
+    {{0x100, 0x166, 0xB6, 0x58, 0x1C5, -0x166F, 0x10EE, -0x1C5B}}, // ITU_Rec601
-    {{ 0x100, 0x193, 0x77, 0x2F, 0x1DB, -0x1933,  0xA7C, -0x1D51 }}, // ITU_Rec709
+    {{0x100, 0x193, 0x77, 0x2F, 0x1DB, -0x1933, 0xA7C, -0x1D51}},  // ITU_Rec709
-    {{ 0x12A, 0x198, 0xD0, 0x64, 0x204, -0x1BDE, 0x10F2, -0x229B }}, // ITU_Rec601_Scaling
+    {{0x12A, 0x198, 0xD0, 0x64, 0x204, -0x1BDE, 0x10F2, -0x229B}}, // ITU_Rec601_Scaling
-    {{ 0x12A, 0x1CA, 0x88, 0x36, 0x21C, -0x1F04,  0x99C, -0x2421 }}, // ITU_Rec709_Scaling
+    {{0x12A, 0x1CA, 0x88, 0x36, 0x21C, -0x1F04, 0x99C, -0x2421}},  // ITU_Rec709_Scaling
 };
 ResultCode ConversionConfiguration::SetInputLineWidth(u16 width) {
    if (width == 0 || width > 1024 || width % 8 != 0) {
        return ResultCode(ErrorDescription::OutOfRange, ErrorModule::CAM,
-            ErrorSummary::InvalidArgument, ErrorLevel::Usage); // 0xE0E053FD
+                          ErrorSummary::InvalidArgument, ErrorLevel::Usage); // 0xE0E053FD
    }
    // Note: The hardware uses the register value 0 to represent a width of 1024, so for a width of
@@ -61,7 +61,7 @@ ResultCode ConversionConfiguration::SetInputLineWidth(u16 width) {
 ResultCode ConversionConfiguration::SetInputLines(u16 lines) {
    if (lines == 0 || lines > 1024) {
        return ResultCode(ErrorDescription::OutOfRange, ErrorModule::CAM,
-            ErrorSummary::InvalidArgument, ErrorLevel::Usage); // 0xE0E053FD
+                          ErrorSummary::InvalidArgument, ErrorLevel::Usage); // 0xE0E053FD
    }
    // Note: In what appears to be a bug, the `camera` module does not set the hardware register at
@@ -73,11 +73,12 @@ ResultCode ConversionConfiguration::SetInputLines(u16 lines) {
    return RESULT_SUCCESS;
 }
-ResultCode ConversionConfiguration::SetStandardCoefficient(StandardCoefficient standard_coefficient) {
+ResultCode
+ConversionConfiguration::SetStandardCoefficient(StandardCoefficient standard_coefficient) {
    size_t index = static_cast<size_t>(standard_coefficient);
    if (index >= ARRAY_SIZE(standard_coefficients)) {
        return ResultCode(ErrorDescription::InvalidEnumValue, ErrorModule::CAM,
-            ErrorSummary::InvalidArgument, ErrorLevel::Usage); // 0xE0E053ED
+                          ErrorSummary::InvalidArgument, ErrorLevel::Usage); // 0xE0E053ED
    }
    std::memcpy(coefficients.data(), standard_coefficients[index].data(), sizeof(coefficients));
@@ -294,8 +295,10 @@ static void SetSendingY(Service::Interface* self) {
    cmd_buff[0] = IPC::MakeHeader(0x10, 1, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, src_process_handle=0x%08X",
+    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, "
-            conversion.src_Y.image_size, conversion.src_Y.transfer_unit, conversion.src_Y.gap, cmd_buff[6]);
+                           "src_process_handle=0x%08X",
+              conversion.src_Y.image_size, conversion.src_Y.transfer_unit, conversion.src_Y.gap,
+              cmd_buff[6]);
 }
 static void SetSendingU(Service::Interface* self) {
@@ -309,8 +312,10 @@ static void SetSendingU(Service::Interface* self) {
    cmd_buff[0] = IPC::MakeHeader(0x11, 1, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, src_process_handle=0x%08X",
+    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, "
-            conversion.src_U.image_size, conversion.src_U.transfer_unit, conversion.src_U.gap, cmd_buff[6]);
+                           "src_process_handle=0x%08X",
+              conversion.src_U.image_size, conversion.src_U.transfer_unit, conversion.src_U.gap,
+              cmd_buff[6]);
 }
 static void SetSendingV(Service::Interface* self) {
@@ -324,8 +329,10 @@ static void SetSendingV(Service::Interface* self) {
    cmd_buff[0] = IPC::MakeHeader(0x12, 1, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, src_process_handle=0x%08X",
+    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, "
-            conversion.src_V.image_size, conversion.src_V.transfer_unit, conversion.src_V.gap, cmd_buff[6]);
+                           "src_process_handle=0x%08X",
+              conversion.src_V.image_size, conversion.src_V.transfer_unit, conversion.src_V.gap,
+              cmd_buff[6]);
 }
 static void SetSendingYUYV(Service::Interface* self) {
@@ -339,8 +346,10 @@ static void SetSendingYUYV(Service::Interface* self) {
    cmd_buff[0] = IPC::MakeHeader(0x13, 1, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, src_process_handle=0x%08X",
+    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, "
-            conversion.src_YUYV.image_size, conversion.src_YUYV.transfer_unit, conversion.src_YUYV.gap, cmd_buff[6]);
+                           "src_process_handle=0x%08X",
+              conversion.src_YUYV.image_size, conversion.src_YUYV.transfer_unit,
+              conversion.src_YUYV.gap, cmd_buff[6]);
 }
 /**
@@ -418,8 +427,10 @@ static void SetReceiving(Service::Interface* self) {
    cmd_buff[0] = IPC::MakeHeader(0x18, 1, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, dst_process_handle=0x%08X",
+    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, "
-            conversion.dst.image_size, conversion.dst.transfer_unit, conversion.dst.gap, cmd_buff[6]);
+                           "dst_process_handle=0x%08X",
+              conversion.dst.image_size, conversion.dst.transfer_unit, conversion.dst.gap,
+              cmd_buff[6]);
 }
 /**
@@ -486,8 +497,8 @@ static void SetCoefficient(Service::Interface* self) {
    cmd_buff[1] = RESULT_SUCCESS.raw;
    LOG_DEBUG(Service_Y2R, "called coefficients=[%hX, %hX, %hX, %hX, %hX, %hX, %hX, %hX]",
-            coefficients[0], coefficients[1], coefficients[2], coefficients[3],
+              coefficients[0], coefficients[1], coefficients[2], coefficients[3], coefficients[4],
-            coefficients[4], coefficients[5], coefficients[6], coefficients[7]);
+              coefficients[5], coefficients[6], coefficients[7]);
 }
 static void GetCoefficient(Service::Interface* self) {
@@ -575,8 +586,10 @@ static void StartConversion(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
    // dst_image_size would seem to be perfect for this, but it doesn't include the gap :(
-    u32 total_output_size = conversion.input_lines * (conversion.dst.transfer_unit + conversion.dst.gap);
+    u32 total_output_size =
-    Memory::RasterizerFlushAndInvalidateRegion(Memory::VirtualToPhysicalAddress(conversion.dst.address), total_output_size);
+        conversion.input_lines * (conversion.dst.transfer_unit + conversion.dst.gap);
+    Memory::RasterizerFlushAndInvalidateRegion(
+        Memory::VirtualToPhysicalAddress(conversion.dst.address), total_output_size);
    HW::Y2R::PerformConversion(conversion);
@@ -648,10 +661,13 @@ cleanup:
    cmd_buff[0] = IPC::MakeHeader(0x29, 1, 0);
    cmd_buff[1] = result.raw;
-    LOG_DEBUG(Service_Y2R, "called input_format=%hhu output_format=%hhu rotation=%hhu block_alignment=%hhu "
+    LOG_DEBUG(
-            "input_line_width=%hu input_lines=%hu standard_coefficient=%hhu reserved=%hhu alpha=%hX",
+        Service_Y2R,
-            params->input_format, params->output_format, params->rotation, params->block_alignment,
+        "called input_format=%hhu output_format=%hhu rotation=%hhu block_alignment=%hhu "
-            params->input_line_width, params->input_lines, params->standard_coefficient, params->padding, params->alpha);
+        "input_line_width=%hu input_lines=%hu standard_coefficient=%hhu reserved=%hhu alpha=%hX",
+        params->input_format, params->output_format, params->rotation, params->block_alignment,
+        params->input_line_width, params->input_lines, params->standard_coefficient,
+        params->padding, params->alpha);
 }
 static void PingProcess(Service::Interface* self) {
@@ -699,7 +715,6 @@ static void DriverFinalize(Service::Interface* self) {
    LOG_DEBUG(Service_Y2R, "called");
 }
 static void GetPackageParameter(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();
@@ -711,51 +726,51 @@ static void GetPackageParameter(Service::Interface* self) {
 }
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010040, SetInputFormat,          "SetInputFormat"},
+    {0x00010040, SetInputFormat, "SetInputFormat"},
-    {0x00020000, GetInputFormat,          "GetInputFormat"},
+    {0x00020000, GetInputFormat, "GetInputFormat"},
-    {0x00030040, SetOutputFormat,         "SetOutputFormat"},
+    {0x00030040, SetOutputFormat, "SetOutputFormat"},
-    {0x00040000, GetOutputFormat,         "GetOutputFormat"},
+    {0x00040000, GetOutputFormat, "GetOutputFormat"},
-    {0x00050040, SetRotation,             "SetRotation"},
+    {0x00050040, SetRotation, "SetRotation"},
-    {0x00060000, GetRotation,             "GetRotation"},
+    {0x00060000, GetRotation, "GetRotation"},
-    {0x00070040, SetBlockAlignment,       "SetBlockAlignment"},
+    {0x00070040, SetBlockAlignment, "SetBlockAlignment"},
-    {0x00080000, GetBlockAlignment,       "GetBlockAlignment"},
+    {0x00080000, GetBlockAlignment, "GetBlockAlignment"},
-    {0x00090040, SetSpacialDithering,     "SetSpacialDithering"},
+    {0x00090040, SetSpacialDithering, "SetSpacialDithering"},
-    {0x000A0000, GetSpacialDithering,     "GetSpacialDithering"},
+    {0x000A0000, GetSpacialDithering, "GetSpacialDithering"},
-    {0x000B0040, SetTemporalDithering,    "SetTemporalDithering"},
+    {0x000B0040, SetTemporalDithering, "SetTemporalDithering"},
-    {0x000C0000, GetTemporalDithering,    "GetTemporalDithering"},
+    {0x000C0000, GetTemporalDithering, "GetTemporalDithering"},
    {0x000D0040, SetTransferEndInterrupt, "SetTransferEndInterrupt"},
    {0x000E0000, GetTransferEndInterrupt, "GetTransferEndInterrupt"},
-    {0x000F0000, GetTransferEndEvent,     "GetTransferEndEvent"},
+    {0x000F0000, GetTransferEndEvent, "GetTransferEndEvent"},
-    {0x00100102, SetSendingY,             "SetSendingY"},
+    {0x00100102, SetSendingY, "SetSendingY"},
-    {0x00110102, SetSendingU,             "SetSendingU"},
+    {0x00110102, SetSendingU, "SetSendingU"},
-    {0x00120102, SetSendingV,             "SetSendingV"},
+    {0x00120102, SetSendingV, "SetSendingV"},
-    {0x00130102, SetSendingYUYV,          "SetSendingYUYV"},
+    {0x00130102, SetSendingYUYV, "SetSendingYUYV"},
-    {0x00140000, IsFinishedSendingYuv,    "IsFinishedSendingYuv"},
+    {0x00140000, IsFinishedSendingYuv, "IsFinishedSendingYuv"},
-    {0x00150000, IsFinishedSendingY,      "IsFinishedSendingY"},
+    {0x00150000, IsFinishedSendingY, "IsFinishedSendingY"},
-    {0x00160000, IsFinishedSendingU,      "IsFinishedSendingU"},
+    {0x00160000, IsFinishedSendingU, "IsFinishedSendingU"},
-    {0x00170000, IsFinishedSendingV,      "IsFinishedSendingV"},
+    {0x00170000, IsFinishedSendingV, "IsFinishedSendingV"},
-    {0x00180102, SetReceiving,            "SetReceiving"},
+    {0x00180102, SetReceiving, "SetReceiving"},
-    {0x00190000, IsFinishedReceiving,     "IsFinishedReceiving"},
+    {0x00190000, IsFinishedReceiving, "IsFinishedReceiving"},
-    {0x001A0040, SetInputLineWidth,       "SetInputLineWidth"},
+    {0x001A0040, SetInputLineWidth, "SetInputLineWidth"},
-    {0x001B0000, GetInputLineWidth,       "GetInputLineWidth"},
+    {0x001B0000, GetInputLineWidth, "GetInputLineWidth"},
-    {0x001C0040, SetInputLines,           "SetInputLines"},
+    {0x001C0040, SetInputLines, "SetInputLines"},
-    {0x001D0000, GetInputLines,           "GetInputLines"},
+    {0x001D0000, GetInputLines, "GetInputLines"},
-    {0x001E0100, SetCoefficient,          "SetCoefficient"},
+    {0x001E0100, SetCoefficient, "SetCoefficient"},
-    {0x001F0000, GetCoefficient,          "GetCoefficient"},
+    {0x001F0000, GetCoefficient, "GetCoefficient"},
-    {0x00200040, SetStandardCoefficient,  "SetStandardCoefficient"},
+    {0x00200040, SetStandardCoefficient, "SetStandardCoefficient"},
-    {0x00210040, GetStandardCoefficient,  "GetStandardCoefficient"},
+    {0x00210040, GetStandardCoefficient, "GetStandardCoefficient"},
-    {0x00220040, SetAlpha,                "SetAlpha"},
+    {0x00220040, SetAlpha, "SetAlpha"},
-    {0x00230000, GetAlpha,                "GetAlpha"},
+    {0x00230000, GetAlpha, "GetAlpha"},
-    {0x00240200, SetDitheringWeightParams,"SetDitheringWeightParams"},
+    {0x00240200, SetDitheringWeightParams, "SetDitheringWeightParams"},
-    {0x00250000, GetDitheringWeightParams,"GetDitheringWeightParams"},
+    {0x00250000, GetDitheringWeightParams, "GetDitheringWeightParams"},
-    {0x00260000, StartConversion,         "StartConversion"},
+    {0x00260000, StartConversion, "StartConversion"},
-    {0x00270000, StopConversion,          "StopConversion"},
+    {0x00270000, StopConversion, "StopConversion"},
-    {0x00280000, IsBusyConversion,        "IsBusyConversion"},
+    {0x00280000, IsBusyConversion, "IsBusyConversion"},
-    {0x002901C0, SetPackageParameter,     "SetPackageParameter"},
+    {0x002901C0, SetPackageParameter, "SetPackageParameter"},
-    {0x002A0000, PingProcess,             "PingProcess"},
+    {0x002A0000, PingProcess, "PingProcess"},
-    {0x002B0000, DriverInitialize,        "DriverInitialize"},
+    {0x002B0000, DriverInitialize, "DriverInitialize"},
-    {0x002C0000, DriverFinalize,          "DriverFinalize"},
+    {0x002C0000, DriverFinalize, "DriverFinalize"},
-    {0x002D0000, GetPackageParameter,     "GetPackageParameter"},
+    {0x002D0000, GetPackageParameter, "GetPackageParameter"},
 };
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/shared_page.cpp b/src/core/hle/shared_page.cpp
index 4d9272923..453fcf7ec 100644
--- a/src/core/hle/shared_page.cpp
+++ b/src/core/hle/shared_page.cpp
@@ -52,8 +52,8 @@ static u64 GetSystemTime() {
 }
 static void UpdateTimeCallback(u64 userdata, int cycles_late) {
-    DateTime& date_time = shared_page.date_time_counter % 2 ?
+    DateTime& date_time =
-        shared_page.date_time_0 : shared_page.date_time_1;
+        shared_page.date_time_counter % 2 ? shared_page.date_time_0 : shared_page.date_time_1;
    date_time.date_time = GetSystemTime();
    date_time.update_tick = CoreTiming::GetTicks();
@@ -74,7 +74,8 @@ void Init() {
    // Some games wait until this value becomes 0x1, before asking running_hw
    shared_page.unknown_value = 0x1;
-    update_time_event = CoreTiming::RegisterEvent("SharedPage::UpdateTimeCallback", UpdateTimeCallback);
+    update_time_event =
+        CoreTiming::RegisterEvent("SharedPage::UpdateTimeCallback", UpdateTimeCallback);
    CoreTiming::ScheduleEvent(0, update_time_event);
 }
diff --git a/src/core/hle/shared_page.h b/src/core/hle/shared_page.h
index cd9246726..b3b10be31 100644
--- a/src/core/hle/shared_page.h
+++ b/src/core/hle/shared_page.h
@@ -32,27 +32,28 @@ static_assert(sizeof(DateTime) == 0x20, "Datetime size is wrong");
 struct SharedPageDef {
    // Most of these names are taken from the 3dbrew page linked above.
-    u32_le   date_time_counter;          // 0
+    u32_le date_time_counter; // 0
-    u8       running_hw;                 // 4
+    u8 running_hw;            // 4
    /// "Microcontroller hardware info"
-    u8       mcu_hw_info;                // 5
+    u8 mcu_hw_info;                      // 5
    INSERT_PADDING_BYTES(0x20 - 0x6);    // 6
    DateTime date_time_0;                // 20
    DateTime date_time_1;                // 40
-    u8       wifi_macaddr[6];            // 60
+    u8 wifi_macaddr[6];                  // 60
-    u8       wifi_link_level;            // 66
+    u8 wifi_link_level;                  // 66
-    u8       wifi_unknown2;              // 67
+    u8 wifi_unknown2;                    // 67
    INSERT_PADDING_BYTES(0x80 - 0x68);   // 68
    float_le sliderstate_3d;             // 80
-    u8       ledstate_3d;                // 84
+    u8 ledstate_3d;                      // 84
    INSERT_PADDING_BYTES(1);             // 85
-    u8       unknown_value;              // 86
+    u8 unknown_value;                    // 86
    INSERT_PADDING_BYTES(0xA0 - 0x87);   // 87
-    u64_le   menu_title_id;              // A0
+    u64_le menu_title_id;                // A0
-    u64_le   active_menu_title_id;       // A8
+    u64_le active_menu_title_id;         // A8
    INSERT_PADDING_BYTES(0x1000 - 0xB0); // B0
 };
-static_assert(sizeof(SharedPageDef) == Memory::SHARED_PAGE_SIZE, "Shared page structure size is wrong");
+static_assert(sizeof(SharedPageDef) == Memory::SHARED_PAGE_SIZE,
+              "Shared page structure size is wrong");
 extern SharedPageDef shared_page;
diff --git a/src/core/hle/svc.cpp b/src/core/hle/svc.cpp
index 5d71d5619..9d0a9c54c 100644
--- a/src/core/hle/svc.cpp
+++ b/src/core/hle/svc.cpp
@@ -10,8 +10,8 @@
 #include "common/string_util.h"
 #include "common/symbols.h"
-#include "core/core_timing.h"
 #include "core/arm/arm_interface.h"
+#include "core/core_timing.h"
 #include "core/hle/kernel/address_arbiter.h"
 #include "core/hle/kernel/client_port.h"
@@ -40,43 +40,46 @@ using Kernel::ERR_INVALID_HANDLE;
 namespace SVC {
 const ResultCode ERR_NOT_FOUND(ErrorDescription::NotFound, ErrorModule::Kernel,
-        ErrorSummary::NotFound, ErrorLevel::Permanent); // 0xD88007FA
+                               ErrorSummary::NotFound, ErrorLevel::Permanent); // 0xD88007FA
 const ResultCode ERR_PORT_NAME_TOO_LONG(ErrorDescription(30), ErrorModule::OS,
-        ErrorSummary::InvalidArgument, ErrorLevel::Usage); // 0xE0E0181E
+                                        ErrorSummary::InvalidArgument,
+                                        ErrorLevel::Usage); // 0xE0E0181E
-const ResultCode ERR_MISALIGNED_ADDRESS{ // 0xE0E01BF1
-        ErrorDescription::MisalignedAddress, ErrorModule::OS,
+const ResultCode ERR_MISALIGNED_ADDRESS{// 0xE0E01BF1
-        ErrorSummary::InvalidArgument, ErrorLevel::Usage};
+                                        ErrorDescription::MisalignedAddress, ErrorModule::OS,
-const ResultCode ERR_MISALIGNED_SIZE{ // 0xE0E01BF2
+                                        ErrorSummary::InvalidArgument, ErrorLevel::Usage};
-        ErrorDescription::MisalignedSize, ErrorModule::OS,
+const ResultCode ERR_MISALIGNED_SIZE{// 0xE0E01BF2
-        ErrorSummary::InvalidArgument, ErrorLevel::Usage};
+                                     ErrorDescription::MisalignedSize, ErrorModule::OS,
-const ResultCode ERR_INVALID_COMBINATION{ // 0xE0E01BEE
+                                     ErrorSummary::InvalidArgument, ErrorLevel::Usage};
-        ErrorDescription::InvalidCombination, ErrorModule::OS,
+const ResultCode ERR_INVALID_COMBINATION{// 0xE0E01BEE
-        ErrorSummary::InvalidArgument, ErrorLevel::Usage};
+                                         ErrorDescription::InvalidCombination, ErrorModule::OS,
+                                         ErrorSummary::InvalidArgument, ErrorLevel::Usage};
 enum ControlMemoryOperation {
-    MEMOP_FREE    = 1,
+    MEMOP_FREE = 1,
    MEMOP_RESERVE = 2, // This operation seems to be unsupported in the kernel
-    MEMOP_COMMIT  = 3,
+    MEMOP_COMMIT = 3,
-    MEMOP_MAP     = 4,
+    MEMOP_MAP = 4,
-    MEMOP_UNMAP   = 5,
+    MEMOP_UNMAP = 5,
    MEMOP_PROTECT = 6,
    MEMOP_OPERATION_MASK = 0xFF,
-    MEMOP_REGION_APP    = 0x100,
+    MEMOP_REGION_APP = 0x100,
    MEMOP_REGION_SYSTEM = 0x200,
-    MEMOP_REGION_BASE   = 0x300,
+    MEMOP_REGION_BASE = 0x300,
-    MEMOP_REGION_MASK   = 0xF00,
+    MEMOP_REGION_MASK = 0xF00,
    MEMOP_LINEAR = 0x10000,
 };
 /// Map application or GSP heap memory
-static ResultCode ControlMemory(u32* out_addr, u32 operation, u32 addr0, u32 addr1, u32 size, u32 permissions) {
+static ResultCode ControlMemory(u32* out_addr, u32 operation, u32 addr0, u32 addr1, u32 size,
+                                u32 permissions) {
    using namespace Kernel;
-    LOG_DEBUG(Kernel_SVC,"called operation=0x%08X, addr0=0x%08X, addr1=0x%08X, size=0x%X, permissions=0x%08X",
+    LOG_DEBUG(Kernel_SVC,
-        operation, addr0, addr1, size, permissions);
+              "called operation=0x%08X, addr0=0x%08X, addr1=0x%08X, size=0x%X, permissions=0x%08X",
+              operation, addr0, addr1, size, permissions);
    if ((addr0 & Memory::PAGE_MASK) != 0 || (addr1 & Memory::PAGE_MASK) != 0) {
        return ERR_MISALIGNED_ADDRESS;
@@ -89,7 +92,8 @@ static ResultCode ControlMemory(u32* out_addr, u32 operation, u32 addr0, u32 add
    operation &= ~MEMOP_REGION_MASK;
    if (region != 0) {
-        LOG_WARNING(Kernel_SVC, "ControlMemory with specified region not supported, region=%X", region);
+        LOG_WARNING(Kernel_SVC, "ControlMemory with specified region not supported, region=%X",
+                    region);
    }
    if ((permissions & (u32)MemoryPermission::ReadWrite) != permissions) {
@@ -100,15 +104,17 @@ static ResultCode ControlMemory(u32* out_addr, u32 operation, u32 addr0, u32 add
    auto& process = *g_current_process;
    switch (operation & MEMOP_OPERATION_MASK) {
-    case MEMOP_FREE:
+    case MEMOP_FREE: {
-    {
+        // TODO(Subv): What happens if an application tries to FREE a block of memory that has a
-        // TODO(Subv): What happens if an application tries to FREE a block of memory that has a SharedMemory pointing to it?
+        // SharedMemory pointing to it?
        if (addr0 >= Memory::HEAP_VADDR && addr0 < Memory::HEAP_VADDR_END) {
            ResultCode result = process.HeapFree(addr0, size);
-            if (result.IsError()) return result;
+            if (result.IsError())
+                return result;
        } else if (addr0 >= process.GetLinearHeapBase() && addr0 < process.GetLinearHeapLimit()) {
            ResultCode result = process.LinearFree(addr0, size);
-            if (result.IsError()) return result;
+            if (result.IsError())
+                return result;
        } else {
            return ERR_INVALID_ADDRESS;
        }
@@ -116,8 +122,7 @@ static ResultCode ControlMemory(u32* out_addr, u32 operation, u32 addr0, u32 add
        break;
    }
-    case MEMOP_COMMIT:
+    case MEMOP_COMMIT: {
-    {
        if (operation & MEMOP_LINEAR) {
            CASCADE_RESULT(*out_addr, process.LinearAllocate(addr0, size, vma_permissions));
        } else {
@@ -126,23 +131,26 @@ static ResultCode ControlMemory(u32* out_addr, u32 operation, u32 addr0, u32 add
        break;
    }
-    case MEMOP_MAP: // TODO: This is just a hack to avoid regressions until memory aliasing is implemented
+    case MEMOP_MAP: // TODO: This is just a hack to avoid regressions until memory aliasing is
-    {
+                    // implemented
-        CASCADE_RESULT(*out_addr, process.HeapAllocate(addr0, size, vma_permissions));
+        {
-        break;
+            CASCADE_RESULT(*out_addr, process.HeapAllocate(addr0, size, vma_permissions));
-    }
+            break;
+        }
-    case MEMOP_UNMAP: // TODO: This is just a hack to avoid regressions until memory aliasing is implemented
+    case MEMOP_UNMAP: // TODO: This is just a hack to avoid regressions until memory aliasing is
-    {
+                      // implemented
-        ResultCode result = process.HeapFree(addr0, size);
+        {
-        if (result.IsError()) return result;
+            ResultCode result = process.HeapFree(addr0, size);
-        break;
+            if (result.IsError())
-    }
+                return result;
+            break;
+        }
-    case MEMOP_PROTECT:
+    case MEMOP_PROTECT: {
-    {
        ResultCode result = process.vm_manager.ReprotectRange(addr0, size, vma_permissions);
-        if (result.IsError()) return result;
+        if (result.IsError())
+            return result;
        break;
    }
@@ -161,8 +169,9 @@ static ResultCode MapMemoryBlock(Handle handle, u32 addr, u32 permissions, u32 o
    using Kernel::SharedMemory;
    using Kernel::MemoryPermission;
-    LOG_TRACE(Kernel_SVC, "called memblock=0x%08X, addr=0x%08X, mypermissions=0x%08X, otherpermission=%d",
+    LOG_TRACE(Kernel_SVC,
-        handle, addr, permissions, other_permissions);
+              "called memblock=0x%08X, addr=0x%08X, mypermissions=0x%08X, otherpermission=%d",
+              handle, addr, permissions, other_permissions);
    SharedPtr<SharedMemory> shared_memory = Kernel::g_handle_table.Get<SharedMemory>(handle);
    if (shared_memory == nullptr)
@@ -179,12 +188,13 @@ static ResultCode MapMemoryBlock(Handle handle, u32 addr, u32 permissions, u32 o
    case MemoryPermission::ReadWriteExecute:
    case MemoryPermission::DontCare:
        return shared_memory->Map(Kernel::g_current_process.get(), addr, permissions_type,
-                static_cast<MemoryPermission>(other_permissions));
+                                  static_cast<MemoryPermission>(other_permissions));
    default:
        LOG_ERROR(Kernel_SVC, "unknown permissions=0x%08X", permissions);
    }
-    return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::OS, ErrorSummary::InvalidArgument, ErrorLevel::Usage);
+    return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::OS,
+                      ErrorSummary::InvalidArgument, ErrorLevel::Usage);
 }
 static ResultCode UnmapMemoryBlock(Handle handle, u32 addr) {
@@ -249,7 +259,7 @@ static ResultCode WaitSynchronization1(Handle handle, s64 nano_seconds) {
        return ERR_INVALID_HANDLE;
    LOG_TRACE(Kernel_SVC, "called handle=0x%08X(%s:%s), nanoseconds=%lld", handle,
-            object->GetTypeName().c_str(), object->GetName().c_str(), nano_seconds);
+              object->GetTypeName().c_str(), object->GetName().c_str(), nano_seconds);
    HLE::Reschedule(__func__);
@@ -257,7 +267,7 @@ static ResultCode WaitSynchronization1(Handle handle, s64 nano_seconds) {
    if (object->ShouldWait()) {
        object->AddWaitingThread(thread);
-        Kernel::WaitCurrentThread_WaitSynchronization({ object }, false, false);
+        Kernel::WaitCurrentThread_WaitSynchronization({object}, false, false);
        // Create an event to wake the thread up after the specified nanosecond delay has passed
        thread->WakeAfterDelay(nano_seconds);
@@ -272,7 +282,8 @@ static ResultCode WaitSynchronization1(Handle handle, s64 nano_seconds) {
 }
 /// Wait for the given handles to synchronize, timeout after the specified nanoseconds
-static ResultCode WaitSynchronizationN(s32* out, Handle* handles, s32 handle_count, bool wait_all, s64 nano_seconds) {
+static ResultCode WaitSynchronizationN(s32* out, Handle* handles, s32 handle_count, bool wait_all,
+                                       s64 nano_seconds) {
    bool wait_thread = !wait_all;
    int handle_index = 0;
    Kernel::Thread* thread = Kernel::GetCurrentThread();
@@ -281,7 +292,8 @@ static ResultCode WaitSynchronizationN(s32* out, Handle* handles, s32 handle_cou
    // Check if 'handles' is invalid
    if (handles == nullptr)
-        return ResultCode(ErrorDescription::InvalidPointer, ErrorModule::Kernel, ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
+        return ResultCode(ErrorDescription::InvalidPointer, ErrorModule::Kernel,
+                          ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
    // NOTE: on real hardware, there is no nullptr check for 'out' (tested with firmware 4.4). If
    // this happens, the running application will crash.
@@ -289,7 +301,8 @@ static ResultCode WaitSynchronizationN(s32* out, Handle* handles, s32 handle_cou
    // Check if 'handle_count' is invalid
    if (handle_count < 0)
-        return ResultCode(ErrorDescription::OutOfRange, ErrorModule::OS, ErrorSummary::InvalidArgument, ErrorLevel::Usage);
+        return ResultCode(ErrorDescription::OutOfRange, ErrorModule::OS,
+                          ErrorSummary::InvalidArgument, ErrorLevel::Usage);
    // If 'handle_count' is non-zero, iterate through each handle and wait the current thread if
    // necessary
@@ -329,7 +342,9 @@ static ResultCode WaitSynchronizationN(s32* out, Handle* handles, s32 handle_cou
        }
    }
-    SCOPE_EXIT({HLE::Reschedule("WaitSynchronizationN");}); // Reschedule after putting the threads to sleep.
+    SCOPE_EXIT({
+        HLE::Reschedule("WaitSynchronizationN");
+    }); // Reschedule after putting the threads to sleep.
    // If thread should wait, then set its state to waiting
    if (wait_thread) {
@@ -386,18 +401,19 @@ static ResultCode CreateAddressArbiter(Handle* out_handle) {
 }
 /// Arbitrate address
-static ResultCode ArbitrateAddress(Handle handle, u32 address, u32 type, u32 value, s64 nanoseconds) {
+static ResultCode ArbitrateAddress(Handle handle, u32 address, u32 type, u32 value,
+                                   s64 nanoseconds) {
    using Kernel::AddressArbiter;
    LOG_TRACE(Kernel_SVC, "called handle=0x%08X, address=0x%08X, type=0x%08X, value=0x%08X", handle,
-        address, type, value);
+              address, type, value);
    SharedPtr<AddressArbiter> arbiter = Kernel::g_handle_table.Get<AddressArbiter>(handle);
    if (arbiter == nullptr)
        return ERR_INVALID_HANDLE;
-    auto res = arbiter->ArbitrateAddress(static_cast<Kernel::ArbitrationType>(type),
+    auto res = arbiter->ArbitrateAddress(static_cast<Kernel::ArbitrationType>(type), address, value,
-                                         address, value, nanoseconds);
+                                         nanoseconds);
    return res;
 }
@@ -406,10 +422,18 @@ static void Break(u8 break_reason) {
    LOG_CRITICAL(Debug_Emulated, "Emulated program broke execution!");
    std::string reason_str;
    switch (break_reason) {
-    case 0: reason_str = "PANIC"; break;
+    case 0:
-    case 1: reason_str = "ASSERT"; break;
+        reason_str = "PANIC";
-    case 2: reason_str = "USER"; break;
+        break;
-    default: reason_str = "UNKNOWN"; break;
+    case 1:
+        reason_str = "ASSERT";
+        break;
+    case 2:
+        reason_str = "USER";
+        break;
+    default:
+        reason_str = "UNKNOWN";
+        break;
    }
    LOG_CRITICAL(Debug_Emulated, "Break reason: %s", reason_str.c_str());
 }
@@ -423,7 +447,8 @@ static void OutputDebugString(const char* string) {
 static ResultCode GetResourceLimit(Handle* resource_limit, Handle process_handle) {
    LOG_TRACE(Kernel_SVC, "called process=0x%08X", process_handle);
-    SharedPtr<Kernel::Process> process = Kernel::g_handle_table.Get<Kernel::Process>(process_handle);
+    SharedPtr<Kernel::Process> process =
+        Kernel::g_handle_table.Get<Kernel::Process>(process_handle);
    if (process == nullptr)
        return ERR_INVALID_HANDLE;
@@ -433,12 +458,13 @@ static ResultCode GetResourceLimit(Handle* resource_limit, Handle process_handle
 }
 /// Get resource limit current values
-static ResultCode GetResourceLimitCurrentValues(s64* values, Handle resource_limit_handle, u32* names,
+static ResultCode GetResourceLimitCurrentValues(s64* values, Handle resource_limit_handle,
-    u32 name_count) {
+                                                u32* names, u32 name_count) {
    LOG_TRACE(Kernel_SVC, "called resource_limit=%08X, names=%p, name_count=%d",
-        resource_limit_handle, names, name_count);
+              resource_limit_handle, names, name_count);
-    SharedPtr<Kernel::ResourceLimit> resource_limit = Kernel::g_handle_table.Get<Kernel::ResourceLimit>(resource_limit_handle);
+    SharedPtr<Kernel::ResourceLimit> resource_limit =
+        Kernel::g_handle_table.Get<Kernel::ResourceLimit>(resource_limit_handle);
    if (resource_limit == nullptr)
        return ERR_INVALID_HANDLE;
@@ -450,11 +476,12 @@ static ResultCode GetResourceLimitCurrentValues(s64* values, Handle resource_lim
 /// Get resource limit max values
 static ResultCode GetResourceLimitLimitValues(s64* values, Handle resource_limit_handle, u32* names,
-    u32 name_count) {
+                                              u32 name_count) {
    LOG_TRACE(Kernel_SVC, "called resource_limit=%08X, names=%p, name_count=%d",
-        resource_limit_handle, names, name_count);
+              resource_limit_handle, names, name_count);
-    SharedPtr<Kernel::ResourceLimit> resource_limit = Kernel::g_handle_table.Get<Kernel::ResourceLimit>(resource_limit_handle);
+    SharedPtr<Kernel::ResourceLimit> resource_limit =
+        Kernel::g_handle_table.Get<Kernel::ResourceLimit>(resource_limit_handle);
    if (resource_limit == nullptr)
        return ERR_INVALID_HANDLE;
@@ -465,7 +492,8 @@ static ResultCode GetResourceLimitLimitValues(s64* values, Handle resource_limit
 }
 /// Creates a new thread
-static ResultCode CreateThread(Handle* out_handle, s32 priority, u32 entry_point, u32 arg, u32 stack_top, s32 processor_id) {
+static ResultCode CreateThread(Handle* out_handle, s32 priority, u32 entry_point, u32 arg,
+                               u32 stack_top, s32 processor_id) {
    using Kernel::Thread;
    std::string name;
@@ -499,20 +527,23 @@ static ResultCode CreateThread(Handle* out_handle, s32 priority, u32 entry_point
    }
    if (processor_id == THREADPROCESSORID_1 || processor_id == THREADPROCESSORID_ALL ||
-        (processor_id == THREADPROCESSORID_DEFAULT && Kernel::g_current_process->ideal_processor == THREADPROCESSORID_1)) {
+        (processor_id == THREADPROCESSORID_DEFAULT &&
-        LOG_WARNING(Kernel_SVC, "Newly created thread is allowed to be run in the SysCore, unimplemented.");
+         Kernel::g_current_process->ideal_processor == THREADPROCESSORID_1)) {
+        LOG_WARNING(Kernel_SVC,
+                    "Newly created thread is allowed to be run in the SysCore, unimplemented.");
    }
-    CASCADE_RESULT(SharedPtr<Thread> thread, Kernel::Thread::Create(
+    CASCADE_RESULT(SharedPtr<Thread> thread, Kernel::Thread::Create(name, entry_point, priority,
-            name, entry_point, priority, arg, processor_id, stack_top));
+                                                                    arg, processor_id, stack_top));
-    thread->context.fpscr = FPSCR_DEFAULT_NAN | FPSCR_FLUSH_TO_ZERO | FPSCR_ROUND_TOZERO; // 0x03C00000
+    thread->context.fpscr =
+        FPSCR_DEFAULT_NAN | FPSCR_FLUSH_TO_ZERO | FPSCR_ROUND_TOZERO; // 0x03C00000
    CASCADE_RESULT(*out_handle, Kernel::g_handle_table.Create(std::move(thread)));
    LOG_TRACE(Kernel_SVC, "called entrypoint=0x%08X (%s), arg=0x%08X, stacktop=0x%08X, "
-        "threadpriority=0x%08X, processorid=0x%08X : created handle=0x%08X", entry_point,
+                          "threadpriority=0x%08X, processorid=0x%08X : created handle=0x%08X",
-        name.c_str(), arg, stack_top, priority, processor_id, *out_handle);
+              entry_point, name.c_str(), arg, stack_top, priority, processor_id, *out_handle);
    return RESULT_SUCCESS;
 }
@@ -552,7 +583,7 @@ static ResultCode CreateMutex(Handle* out_handle, u32 initial_locked) {
    CASCADE_RESULT(*out_handle, Kernel::g_handle_table.Create(std::move(mutex)));
    LOG_TRACE(Kernel_SVC, "called initial_locked=%s : created handle=0x%08X",
-        initial_locked ? "true" : "false", *out_handle);
+              initial_locked ? "true" : "false", *out_handle);
    return RESULT_SUCCESS;
 }
@@ -576,7 +607,8 @@ static ResultCode ReleaseMutex(Handle handle) {
 static ResultCode GetProcessId(u32* process_id, Handle process_handle) {
    LOG_TRACE(Kernel_SVC, "called process=0x%08X", process_handle);
-    const SharedPtr<Kernel::Process> process = Kernel::g_handle_table.Get<Kernel::Process>(process_handle);
+    const SharedPtr<Kernel::Process> process =
+        Kernel::g_handle_table.Get<Kernel::Process>(process_handle);
    if (process == nullptr)
        return ERR_INVALID_HANDLE;
@@ -588,7 +620,8 @@ static ResultCode GetProcessId(u32* process_id, Handle process_handle) {
 static ResultCode GetProcessIdOfThread(u32* process_id, Handle thread_handle) {
    LOG_TRACE(Kernel_SVC, "called thread=0x%08X", thread_handle);
-    const SharedPtr<Kernel::Thread> thread = Kernel::g_handle_table.Get<Kernel::Thread>(thread_handle);
+    const SharedPtr<Kernel::Thread> thread =
+        Kernel::g_handle_table.Get<Kernel::Thread>(thread_handle);
    if (thread == nullptr)
        return ERR_INVALID_HANDLE;
@@ -620,7 +653,7 @@ static ResultCode CreateSemaphore(Handle* out_handle, s32 initial_count, s32 max
    CASCADE_RESULT(*out_handle, Kernel::g_handle_table.Create(std::move(semaphore)));
    LOG_TRACE(Kernel_SVC, "called initial_count=%d, max_count=%d, created handle=0x%08X",
-        initial_count, max_count, *out_handle);
+              initial_count, max_count, *out_handle);
    return RESULT_SUCCESS;
 }
@@ -640,7 +673,8 @@ static ResultCode ReleaseSemaphore(s32* count, Handle handle, s32 release_count)
 }
 /// Query process memory
-static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* page_info, Handle process_handle, u32 addr) {
+static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* page_info,
+                                     Handle process_handle, u32 addr) {
    using Kernel::Process;
    Kernel::SharedPtr<Process> process = Kernel::g_handle_table.Get<Process>(process_handle);
    if (process == nullptr)
@@ -649,7 +683,8 @@ static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* page_inf
    auto vma = process->vm_manager.FindVMA(addr);
    if (vma == Kernel::g_current_process->vm_manager.vma_map.end())
-        return ResultCode(ErrorDescription::InvalidAddress, ErrorModule::OS, ErrorSummary::InvalidArgument, ErrorLevel::Usage);
+        return ResultCode(ErrorDescription::InvalidAddress, ErrorModule::OS,
+                          ErrorSummary::InvalidArgument, ErrorLevel::Usage);
    memory_info->base_address = vma->second.base;
    memory_info->permission = static_cast<u32>(vma->second.permissions);
@@ -673,8 +708,8 @@ static ResultCode CreateEvent(Handle* out_handle, u32 reset_type) {
    SharedPtr<Event> evt = Event::Create(static_cast<Kernel::ResetType>(reset_type));
    CASCADE_RESULT(*out_handle, Kernel::g_handle_table.Create(std::move(evt)));
-    LOG_TRACE(Kernel_SVC, "called reset_type=0x%08X : created handle=0x%08X",
+    LOG_TRACE(Kernel_SVC, "called reset_type=0x%08X : created handle=0x%08X", reset_type,
-            reset_type, *out_handle);
+              *out_handle);
    return RESULT_SUCCESS;
 }
@@ -719,8 +754,8 @@ static ResultCode CreateTimer(Handle* out_handle, u32 reset_type) {
    SharedPtr<Timer> timer = Timer::Create(static_cast<Kernel::ResetType>(reset_type));
    CASCADE_RESULT(*out_handle, Kernel::g_handle_table.Create(std::move(timer)));
-    LOG_TRACE(Kernel_SVC, "called reset_type=0x%08X : created handle=0x%08X",
+    LOG_TRACE(Kernel_SVC, "called reset_type=0x%08X : created handle=0x%08X", reset_type,
-            reset_type, *out_handle);
+              *out_handle);
    return RESULT_SUCCESS;
 }
@@ -783,17 +818,19 @@ static void SleepThread(s64 nanoseconds) {
 static s64 GetSystemTick() {
    s64 result = CoreTiming::GetTicks();
    // Advance time to defeat dumb games (like Cubic Ninja) that busy-wait for the frame to end.
-    Core::g_app_core->AddTicks(150); // Measured time between two calls on a 9.2 o3DS with Ninjhax 1.1b
+    Core::g_app_core->AddTicks(
+        150); // Measured time between two calls on a 9.2 o3DS with Ninjhax 1.1b
    return result;
 }
 /// Creates a memory block at the specified address with the specified permissions and size
 static ResultCode CreateMemoryBlock(Handle* out_handle, u32 addr, u32 size, u32 my_permission,
-        u32 other_permission) {
+                                    u32 other_permission) {
    using Kernel::SharedMemory;
    if (size % Memory::PAGE_SIZE != 0)
-        return ResultCode(ErrorDescription::MisalignedSize, ErrorModule::OS, ErrorSummary::InvalidArgument, ErrorLevel::Usage);
+        return ResultCode(ErrorDescription::MisalignedSize, ErrorModule::OS,
+                          ErrorSummary::InvalidArgument, ErrorLevel::Usage);
    SharedPtr<SharedMemory> shared_memory = nullptr;
@@ -818,25 +855,29 @@ static ResultCode CreateMemoryBlock(Handle* out_handle, u32 addr, u32 size, u32
                          ErrorSummary::InvalidArgument, ErrorLevel::Usage);
    if (addr < Memory::PROCESS_IMAGE_VADDR || addr + size > Memory::SHARED_MEMORY_VADDR_END) {
-        return ResultCode(ErrorDescription::InvalidAddress, ErrorModule::OS, ErrorSummary::InvalidArgument, ErrorLevel::Usage);
+        return ResultCode(ErrorDescription::InvalidAddress, ErrorModule::OS,
+                          ErrorSummary::InvalidArgument, ErrorLevel::Usage);
    }
    // When trying to create a memory block with address = 0,
    // if the process has the Shared Device Memory flag in the exheader,
-    // then we have to allocate from the same region as the caller process instead of the BASE region.
+    // then we have to allocate from the same region as the caller process instead of the BASE
+    // region.
    Kernel::MemoryRegion region = Kernel::MemoryRegion::BASE;
    if (addr == 0 && Kernel::g_current_process->flags.shared_device_mem)
        region = Kernel::g_current_process->flags.memory_region;
-    shared_memory = SharedMemory::Create(Kernel::g_current_process, size,
+    shared_memory = SharedMemory::Create(
-                                static_cast<MemoryPermission>(my_permission), static_cast<MemoryPermission>(other_permission), addr, region);
+        Kernel::g_current_process, size, static_cast<MemoryPermission>(my_permission),
+        static_cast<MemoryPermission>(other_permission), addr, region);
    CASCADE_RESULT(*out_handle, Kernel::g_handle_table.Create(std::move(shared_memory)));
    LOG_WARNING(Kernel_SVC, "called addr=0x%08X", addr);
    return RESULT_SUCCESS;
 }
-static ResultCode CreatePort(Handle* server_port, Handle* client_port, const char* name, u32 max_sessions) {
+static ResultCode CreatePort(Handle* server_port, Handle* client_port, const char* name,
+                             u32 max_sessions) {
    // TODO(Subv): Implement named ports.
    ASSERT_MSG(name == nullptr, "Named ports are currently unimplemented");
@@ -845,9 +886,12 @@ static ResultCode CreatePort(Handle* server_port, Handle* client_port, const cha
    using Kernel::SharedPtr;
    auto ports = ServerPort::CreatePortPair(max_sessions);
-    CASCADE_RESULT(*client_port, Kernel::g_handle_table.Create(std::move(std::get<SharedPtr<ClientPort>>(ports))));
+    CASCADE_RESULT(*client_port, Kernel::g_handle_table.Create(
-    // Note: The 3DS kernel also leaks the client port handle if the server port handle fails to be created.
+                                     std::move(std::get<SharedPtr<ClientPort>>(ports))));
-    CASCADE_RESULT(*server_port, Kernel::g_handle_table.Create(std::move(std::get<SharedPtr<ServerPort>>(ports))));
+    // Note: The 3DS kernel also leaks the client port handle if the server port handle fails to be
+    // created.
+    CASCADE_RESULT(*server_port, Kernel::g_handle_table.Create(
+                                     std::move(std::get<SharedPtr<ServerPort>>(ports))));
    LOG_TRACE(Kernel_SVC, "called max_sessions=%u", max_sessions);
    return RESULT_SUCCESS;
@@ -862,9 +906,9 @@ static ResultCode GetSystemInfo(s64* out, u32 type, s32 param) {
    case SystemInfoType::REGION_MEMORY_USAGE:
        switch ((SystemInfoMemUsageRegion)param) {
        case SystemInfoMemUsageRegion::ALL:
-            *out = Kernel::GetMemoryRegion(Kernel::MemoryRegion::APPLICATION)->used
+            *out = Kernel::GetMemoryRegion(Kernel::MemoryRegion::APPLICATION)->used +
-                 + Kernel::GetMemoryRegion(Kernel::MemoryRegion::SYSTEM)->used
+                   Kernel::GetMemoryRegion(Kernel::MemoryRegion::SYSTEM)->used +
-                 + Kernel::GetMemoryRegion(Kernel::MemoryRegion::BASE)->used;
+                   Kernel::GetMemoryRegion(Kernel::MemoryRegion::BASE)->used;
            break;
        case SystemInfoMemUsageRegion::APPLICATION:
            *out = Kernel::GetMemoryRegion(Kernel::MemoryRegion::APPLICATION)->used;
@@ -912,7 +956,7 @@ static ResultCode GetProcessInfo(s64* out, Handle process_handle, u32 type) {
        // TODO(yuriks): Type 0 returns a slightly higher number than type 2, but I'm not sure
        // what's the difference between them.
        *out = process->heap_used + process->linear_heap_used + process->misc_memory_used;
-        if(*out % Memory::PAGE_SIZE != 0) {
+        if (*out % Memory::PAGE_SIZE != 0) {
            LOG_ERROR(Kernel_SVC, "called, memory size not page-aligned");
            return ERR_MISALIGNED_SIZE;
        }
@@ -935,12 +979,12 @@ static ResultCode GetProcessInfo(s64* out, Handle process_handle, u32 type) {
        if (type >= 21 && type <= 23) {
            return ResultCode( // 0xE0E01BF4
-                    ErrorDescription::NotImplemented, ErrorModule::OS,
+                ErrorDescription::NotImplemented, ErrorModule::OS, ErrorSummary::InvalidArgument,
-                    ErrorSummary::InvalidArgument, ErrorLevel::Usage);
+                ErrorLevel::Usage);
        } else {
            return ResultCode( // 0xD8E007ED
-                    ErrorDescription::InvalidEnumValue, ErrorModule::Kernel,
+                ErrorDescription::InvalidEnumValue, ErrorModule::Kernel,
-                    ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
+                ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
        }
        break;
    }
@@ -949,142 +993,142 @@ static ResultCode GetProcessInfo(s64* out, Handle process_handle, u32 type) {
 }
 namespace {
-    struct FunctionDef {
+struct FunctionDef {
-        using Func = void();
+    using Func = void();
-        u32         id;
+    u32 id;
-        Func*       func;
+    Func* func;
-        const char* name;
+    const char* name;
-    };
+};
 }
 static const FunctionDef SVC_Table[] = {
-    {0x00, nullptr,                         "Unknown"},
+    {0x00, nullptr, "Unknown"},
-    {0x01, HLE::Wrap<ControlMemory>,        "ControlMemory"},
+    {0x01, HLE::Wrap<ControlMemory>, "ControlMemory"},
-    {0x02, HLE::Wrap<QueryMemory>,          "QueryMemory"},
+    {0x02, HLE::Wrap<QueryMemory>, "QueryMemory"},
-    {0x03, nullptr,                         "ExitProcess"},
+    {0x03, nullptr, "ExitProcess"},
-    {0x04, nullptr,                         "GetProcessAffinityMask"},
+    {0x04, nullptr, "GetProcessAffinityMask"},
-    {0x05, nullptr,                         "SetProcessAffinityMask"},
+    {0x05, nullptr, "SetProcessAffinityMask"},
-    {0x06, nullptr,                         "GetProcessIdealProcessor"},
+    {0x06, nullptr, "GetProcessIdealProcessor"},
-    {0x07, nullptr,                         "SetProcessIdealProcessor"},
+    {0x07, nullptr, "SetProcessIdealProcessor"},
-    {0x08, HLE::Wrap<CreateThread>,         "CreateThread"},
+    {0x08, HLE::Wrap<CreateThread>, "CreateThread"},
-    {0x09, ExitThread,                      "ExitThread"},
+    {0x09, ExitThread, "ExitThread"},
-    {0x0A, HLE::Wrap<SleepThread>,          "SleepThread"},
+    {0x0A, HLE::Wrap<SleepThread>, "SleepThread"},
-    {0x0B, HLE::Wrap<GetThreadPriority>,    "GetThreadPriority"},
+    {0x0B, HLE::Wrap<GetThreadPriority>, "GetThreadPriority"},
-    {0x0C, HLE::Wrap<SetThreadPriority>,    "SetThreadPriority"},
+    {0x0C, HLE::Wrap<SetThreadPriority>, "SetThreadPriority"},
-    {0x0D, nullptr,                         "GetThreadAffinityMask"},
+    {0x0D, nullptr, "GetThreadAffinityMask"},
-    {0x0E, nullptr,                         "SetThreadAffinityMask"},
+    {0x0E, nullptr, "SetThreadAffinityMask"},
-    {0x0F, nullptr,                         "GetThreadIdealProcessor"},
+    {0x0F, nullptr, "GetThreadIdealProcessor"},
-    {0x10, nullptr,                         "SetThreadIdealProcessor"},
+    {0x10, nullptr, "SetThreadIdealProcessor"},
-    {0x11, nullptr,                         "GetCurrentProcessorNumber"},
+    {0x11, nullptr, "GetCurrentProcessorNumber"},
-    {0x12, nullptr,                         "Run"},
+    {0x12, nullptr, "Run"},
-    {0x13, HLE::Wrap<CreateMutex>,          "CreateMutex"},
+    {0x13, HLE::Wrap<CreateMutex>, "CreateMutex"},
-    {0x14, HLE::Wrap<ReleaseMutex>,         "ReleaseMutex"},
+    {0x14, HLE::Wrap<ReleaseMutex>, "ReleaseMutex"},
-    {0x15, HLE::Wrap<CreateSemaphore>,      "CreateSemaphore"},
+    {0x15, HLE::Wrap<CreateSemaphore>, "CreateSemaphore"},
-    {0x16, HLE::Wrap<ReleaseSemaphore>,     "ReleaseSemaphore"},
+    {0x16, HLE::Wrap<ReleaseSemaphore>, "ReleaseSemaphore"},
-    {0x17, HLE::Wrap<CreateEvent>,          "CreateEvent"},
+    {0x17, HLE::Wrap<CreateEvent>, "CreateEvent"},
-    {0x18, HLE::Wrap<SignalEvent>,          "SignalEvent"},
+    {0x18, HLE::Wrap<SignalEvent>, "SignalEvent"},
-    {0x19, HLE::Wrap<ClearEvent>,           "ClearEvent"},
+    {0x19, HLE::Wrap<ClearEvent>, "ClearEvent"},
-    {0x1A, HLE::Wrap<CreateTimer>,          "CreateTimer"},
+    {0x1A, HLE::Wrap<CreateTimer>, "CreateTimer"},
-    {0x1B, HLE::Wrap<SetTimer>,             "SetTimer"},
+    {0x1B, HLE::Wrap<SetTimer>, "SetTimer"},
-    {0x1C, HLE::Wrap<CancelTimer>,          "CancelTimer"},
+    {0x1C, HLE::Wrap<CancelTimer>, "CancelTimer"},
-    {0x1D, HLE::Wrap<ClearTimer>,           "ClearTimer"},
+    {0x1D, HLE::Wrap<ClearTimer>, "ClearTimer"},
-    {0x1E, HLE::Wrap<CreateMemoryBlock>,    "CreateMemoryBlock"},
+    {0x1E, HLE::Wrap<CreateMemoryBlock>, "CreateMemoryBlock"},
-    {0x1F, HLE::Wrap<MapMemoryBlock>,       "MapMemoryBlock"},
+    {0x1F, HLE::Wrap<MapMemoryBlock>, "MapMemoryBlock"},
-    {0x20, HLE::Wrap<UnmapMemoryBlock>,     "UnmapMemoryBlock"},
+    {0x20, HLE::Wrap<UnmapMemoryBlock>, "UnmapMemoryBlock"},
    {0x21, HLE::Wrap<CreateAddressArbiter>, "CreateAddressArbiter"},
-    {0x22, HLE::Wrap<ArbitrateAddress>,     "ArbitrateAddress"},
+    {0x22, HLE::Wrap<ArbitrateAddress>, "ArbitrateAddress"},
-    {0x23, HLE::Wrap<CloseHandle>,          "CloseHandle"},
+    {0x23, HLE::Wrap<CloseHandle>, "CloseHandle"},
    {0x24, HLE::Wrap<WaitSynchronization1>, "WaitSynchronization1"},
    {0x25, HLE::Wrap<WaitSynchronizationN>, "WaitSynchronizationN"},
-    {0x26, nullptr,                         "SignalAndWait"},
+    {0x26, nullptr, "SignalAndWait"},
-    {0x27, HLE::Wrap<DuplicateHandle>,      "DuplicateHandle"},
+    {0x27, HLE::Wrap<DuplicateHandle>, "DuplicateHandle"},
-    {0x28, HLE::Wrap<GetSystemTick>,        "GetSystemTick"},
+    {0x28, HLE::Wrap<GetSystemTick>, "GetSystemTick"},
-    {0x29, nullptr,                         "GetHandleInfo"},
+    {0x29, nullptr, "GetHandleInfo"},
-    {0x2A, HLE::Wrap<GetSystemInfo>,        "GetSystemInfo"},
+    {0x2A, HLE::Wrap<GetSystemInfo>, "GetSystemInfo"},
-    {0x2B, HLE::Wrap<GetProcessInfo>,       "GetProcessInfo"},
+    {0x2B, HLE::Wrap<GetProcessInfo>, "GetProcessInfo"},
-    {0x2C, nullptr,                         "GetThreadInfo"},
+    {0x2C, nullptr, "GetThreadInfo"},
-    {0x2D, HLE::Wrap<ConnectToPort>,        "ConnectToPort"},
+    {0x2D, HLE::Wrap<ConnectToPort>, "ConnectToPort"},
-    {0x2E, nullptr,                         "SendSyncRequest1"},
+    {0x2E, nullptr, "SendSyncRequest1"},
-    {0x2F, nullptr,                         "SendSyncRequest2"},
+    {0x2F, nullptr, "SendSyncRequest2"},
-    {0x30, nullptr,                         "SendSyncRequest3"},
+    {0x30, nullptr, "SendSyncRequest3"},
-    {0x31, nullptr,                         "SendSyncRequest4"},
+    {0x31, nullptr, "SendSyncRequest4"},
-    {0x32, HLE::Wrap<SendSyncRequest>,      "SendSyncRequest"},
+    {0x32, HLE::Wrap<SendSyncRequest>, "SendSyncRequest"},
-    {0x33, nullptr,                         "OpenProcess"},
+    {0x33, nullptr, "OpenProcess"},
-    {0x34, nullptr,                         "OpenThread"},
+    {0x34, nullptr, "OpenThread"},
-    {0x35, HLE::Wrap<GetProcessId>,         "GetProcessId"},
+    {0x35, HLE::Wrap<GetProcessId>, "GetProcessId"},
    {0x36, HLE::Wrap<GetProcessIdOfThread>, "GetProcessIdOfThread"},
-    {0x37, HLE::Wrap<GetThreadId>,          "GetThreadId"},
+    {0x37, HLE::Wrap<GetThreadId>, "GetThreadId"},
-    {0x38, HLE::Wrap<GetResourceLimit>,     "GetResourceLimit"},
+    {0x38, HLE::Wrap<GetResourceLimit>, "GetResourceLimit"},
    {0x39, HLE::Wrap<GetResourceLimitLimitValues>, "GetResourceLimitLimitValues"},
    {0x3A, HLE::Wrap<GetResourceLimitCurrentValues>, "GetResourceLimitCurrentValues"},
-    {0x3B, nullptr,                         "GetThreadContext"},
+    {0x3B, nullptr, "GetThreadContext"},
-    {0x3C, HLE::Wrap<Break>,                "Break"},
+    {0x3C, HLE::Wrap<Break>, "Break"},
-    {0x3D, HLE::Wrap<OutputDebugString>,    "OutputDebugString"},
+    {0x3D, HLE::Wrap<OutputDebugString>, "OutputDebugString"},
-    {0x3E, nullptr,                         "ControlPerformanceCounter"},
+    {0x3E, nullptr, "ControlPerformanceCounter"},
-    {0x3F, nullptr,                         "Unknown"},
+    {0x3F, nullptr, "Unknown"},
-    {0x40, nullptr,                         "Unknown"},
+    {0x40, nullptr, "Unknown"},
-    {0x41, nullptr,                         "Unknown"},
+    {0x41, nullptr, "Unknown"},
-    {0x42, nullptr,                         "Unknown"},
+    {0x42, nullptr, "Unknown"},
-    {0x43, nullptr,                         "Unknown"},
+    {0x43, nullptr, "Unknown"},
-    {0x44, nullptr,                         "Unknown"},
+    {0x44, nullptr, "Unknown"},
-    {0x45, nullptr,                         "Unknown"},
+    {0x45, nullptr, "Unknown"},
-    {0x46, nullptr,                         "Unknown"},
+    {0x46, nullptr, "Unknown"},
-    {0x47, HLE::Wrap<CreatePort>,           "CreatePort"},
+    {0x47, HLE::Wrap<CreatePort>, "CreatePort"},
-    {0x48, nullptr,                         "CreateSessionToPort"},
+    {0x48, nullptr, "CreateSessionToPort"},
-    {0x49, nullptr,                         "CreateSession"},
+    {0x49, nullptr, "CreateSession"},
-    {0x4A, nullptr,                         "AcceptSession"},
+    {0x4A, nullptr, "AcceptSession"},
-    {0x4B, nullptr,                         "ReplyAndReceive1"},
+    {0x4B, nullptr, "ReplyAndReceive1"},
-    {0x4C, nullptr,                         "ReplyAndReceive2"},
+    {0x4C, nullptr, "ReplyAndReceive2"},
-    {0x4D, nullptr,                         "ReplyAndReceive3"},
+    {0x4D, nullptr, "ReplyAndReceive3"},
-    {0x4E, nullptr,                         "ReplyAndReceive4"},
+    {0x4E, nullptr, "ReplyAndReceive4"},
-    {0x4F, nullptr,                         "ReplyAndReceive"},
+    {0x4F, nullptr, "ReplyAndReceive"},
-    {0x50, nullptr,                         "BindInterrupt"},
+    {0x50, nullptr, "BindInterrupt"},
-    {0x51, nullptr,                         "UnbindInterrupt"},
+    {0x51, nullptr, "UnbindInterrupt"},
-    {0x52, nullptr,                         "InvalidateProcessDataCache"},
+    {0x52, nullptr, "InvalidateProcessDataCache"},
-    {0x53, nullptr,                         "StoreProcessDataCache"},
+    {0x53, nullptr, "StoreProcessDataCache"},
-    {0x54, nullptr,                         "FlushProcessDataCache"},
+    {0x54, nullptr, "FlushProcessDataCache"},
-    {0x55, nullptr,                         "StartInterProcessDma"},
+    {0x55, nullptr, "StartInterProcessDma"},
-    {0x56, nullptr,                         "StopDma"},
+    {0x56, nullptr, "StopDma"},
-    {0x57, nullptr,                         "GetDmaState"},
+    {0x57, nullptr, "GetDmaState"},
-    {0x58, nullptr,                         "RestartDma"},
+    {0x58, nullptr, "RestartDma"},
-    {0x59, nullptr,                         "Unknown"},
+    {0x59, nullptr, "Unknown"},
-    {0x5A, nullptr,                         "Unknown"},
+    {0x5A, nullptr, "Unknown"},
-    {0x5B, nullptr,                         "Unknown"},
+    {0x5B, nullptr, "Unknown"},
-    {0x5C, nullptr,                         "Unknown"},
+    {0x5C, nullptr, "Unknown"},
-    {0x5D, nullptr,                         "Unknown"},
+    {0x5D, nullptr, "Unknown"},
-    {0x5E, nullptr,                         "Unknown"},
+    {0x5E, nullptr, "Unknown"},
-    {0x5F, nullptr,                         "Unknown"},
+    {0x5F, nullptr, "Unknown"},
-    {0x60, nullptr,                         "DebugActiveProcess"},
+    {0x60, nullptr, "DebugActiveProcess"},
-    {0x61, nullptr,                         "BreakDebugProcess"},
+    {0x61, nullptr, "BreakDebugProcess"},
-    {0x62, nullptr,                         "TerminateDebugProcess"},
+    {0x62, nullptr, "TerminateDebugProcess"},
-    {0x63, nullptr,                         "GetProcessDebugEvent"},
+    {0x63, nullptr, "GetProcessDebugEvent"},
-    {0x64, nullptr,                         "ContinueDebugEvent"},
+    {0x64, nullptr, "ContinueDebugEvent"},
-    {0x65, nullptr,                         "GetProcessList"},
+    {0x65, nullptr, "GetProcessList"},
-    {0x66, nullptr,                         "GetThreadList"},
+    {0x66, nullptr, "GetThreadList"},
-    {0x67, nullptr,                         "GetDebugThreadContext"},
+    {0x67, nullptr, "GetDebugThreadContext"},
-    {0x68, nullptr,                         "SetDebugThreadContext"},
+    {0x68, nullptr, "SetDebugThreadContext"},
-    {0x69, nullptr,                         "QueryDebugProcessMemory"},
+    {0x69, nullptr, "QueryDebugProcessMemory"},
-    {0x6A, nullptr,                         "ReadProcessMemory"},
+    {0x6A, nullptr, "ReadProcessMemory"},
-    {0x6B, nullptr,                         "WriteProcessMemory"},
+    {0x6B, nullptr, "WriteProcessMemory"},
-    {0x6C, nullptr,                         "SetHardwareBreakPoint"},
+    {0x6C, nullptr, "SetHardwareBreakPoint"},
-    {0x6D, nullptr,                         "GetDebugThreadParam"},
+    {0x6D, nullptr, "GetDebugThreadParam"},
-    {0x6E, nullptr,                         "Unknown"},
+    {0x6E, nullptr, "Unknown"},
-    {0x6F, nullptr,                         "Unknown"},
+    {0x6F, nullptr, "Unknown"},
-    {0x70, nullptr,                         "ControlProcessMemory"},
+    {0x70, nullptr, "ControlProcessMemory"},
-    {0x71, nullptr,                         "MapProcessMemory"},
+    {0x71, nullptr, "MapProcessMemory"},
-    {0x72, nullptr,                         "UnmapProcessMemory"},
+    {0x72, nullptr, "UnmapProcessMemory"},
-    {0x73, nullptr,                         "CreateCodeSet"},
+    {0x73, nullptr, "CreateCodeSet"},
-    {0x74, nullptr,                         "RandomStub"},
+    {0x74, nullptr, "RandomStub"},
-    {0x75, nullptr,                         "CreateProcess"},
+    {0x75, nullptr, "CreateProcess"},
-    {0x76, nullptr,                         "TerminateProcess"},
+    {0x76, nullptr, "TerminateProcess"},
-    {0x77, nullptr,                         "SetProcessResourceLimits"},
+    {0x77, nullptr, "SetProcessResourceLimits"},
-    {0x78, nullptr,                         "CreateResourceLimit"},
+    {0x78, nullptr, "CreateResourceLimit"},
-    {0x79, nullptr,                         "SetResourceLimitValues"},
+    {0x79, nullptr, "SetResourceLimitValues"},
-    {0x7A, nullptr,                         "AddCodeSegment"},
+    {0x7A, nullptr, "AddCodeSegment"},
-    {0x7B, nullptr,                         "Backdoor"},
+    {0x7B, nullptr, "Backdoor"},
-    {0x7C, nullptr,                         "KernelSetState"},
+    {0x7C, nullptr, "KernelSetState"},
-    {0x7D, HLE::Wrap<QueryProcessMemory>,   "QueryProcessMemory"},
+    {0x7D, HLE::Wrap<QueryProcessMemory>, "QueryProcessMemory"},
 };
 static const FunctionDef* GetSVCInfo(u32 func_num) {
diff --git a/src/core/hw/gpu.cpp b/src/core/hw/gpu.cpp
index a4dfb7e43..bf2c066f4 100644
--- a/src/core/hw/gpu.cpp
+++ b/src/core/hw/gpu.cpp
@@ -12,15 +12,15 @@
 #include "common/microprofile.h"
 #include "common/vector_math.h"
-#include "core/settings.h"
-#include "core/memory.h"
 #include "core/core_timing.h"
+#include "core/memory.h"
+#include "core/settings.h"
 #include "core/hle/service/gsp_gpu.h"
 #include "core/hle/service/hid/hid.h"
-#include "core/hw/hw.h"
 #include "core/hw/gpu.h"
+#include "core/hw/hw.h"
 #include "core/tracer/recorder.h"
@@ -32,7 +32,6 @@
 #include "video_core/debug_utils/debug_utils.h"
 namespace GPU {
 Regs g_regs;
@@ -49,7 +48,7 @@ static u64 frame_count;
 static bool last_skip_frame;
 template <typename T>
-inline void Read(T &var, const u32 raw_addr) {
+inline void Read(T& var, const u32 raw_addr) {
    u32 addr = raw_addr - HW::VADDR_GPU;
    u32 index = addr / 4;
@@ -105,8 +104,7 @@ inline void Write(u32 addr, const T data) {
    // Memory fills are triggered once the fill value is written.
    case GPU_REG_INDEX_WORKAROUND(memory_fill_config[0].trigger, 0x00004 + 0x3):
-    case GPU_REG_INDEX_WORKAROUND(memory_fill_config[1].trigger, 0x00008 + 0x3):
+    case GPU_REG_INDEX_WORKAROUND(memory_fill_config[1].trigger, 0x00008 + 0x3): {
-    {
        const bool is_second_filler = (index != GPU_REG_INDEX(memory_fill_config[0].trigger));
        auto& config = g_regs.memory_fill_config[is_second_filler];
@@ -125,7 +123,9 @@ inline void Write(u32 addr, const T data) {
                //       regions that were between surfaces or within the touching
                //       ones for cpu to manually fill here.
                if (!VideoCore::g_renderer->Rasterizer()->AccelerateFill(config)) {
-                    Memory::RasterizerFlushAndInvalidateRegion(config.GetStartAddress(), config.GetEndAddress() - config.GetStartAddress());
+                    Memory::RasterizerFlushAndInvalidateRegion(config.GetStartAddress(),
+                                                               config.GetEndAddress() -
+                                                                   config.GetStartAddress());
                    if (config.fill_24bit) {
                        // fill with 24-bit values
@@ -150,7 +150,8 @@ inline void Write(u32 addr, const T data) {
                    }
                }
-                LOG_TRACE(HW_GPU, "MemoryFill from 0x%08x to 0x%08x", config.GetStartAddress(), config.GetEndAddress());
+                LOG_TRACE(HW_GPU, "MemoryFill from 0x%08x to 0x%08x", config.GetStartAddress(),
+                          config.GetEndAddress());
                if (!is_second_filler) {
                    GSP_GPU::SignalInterrupt(GSP_GPU::InterruptId::PSC0);
@@ -167,15 +168,15 @@ inline void Write(u32 addr, const T data) {
        break;
    }
-    case GPU_REG_INDEX(display_transfer_config.trigger):
+    case GPU_REG_INDEX(display_transfer_config.trigger): {
-    {
        MICROPROFILE_SCOPE(GPU_DisplayTransfer);
        const auto& config = g_regs.display_transfer_config;
        if (config.trigger & 1) {
            if (Pica::g_debug_context)
-                Pica::g_debug_context->OnEvent(Pica::DebugContext::Event::IncomingDisplayTransfer, nullptr);
+                Pica::g_debug_context->OnEvent(Pica::DebugContext::Event::IncomingDisplayTransfer,
+                                               nullptr);
            if (!VideoCore::g_renderer->Rasterizer()->AccelerateDisplayTransfer(config)) {
                u8* src_pointer = Memory::GetPhysicalPointer(config.GetPhysicalInputAddress());
@@ -187,17 +188,23 @@ inline void Write(u32 addr, const T data) {
                    u32 output_width = config.texture_copy.output_width * 16;
                    u32 output_gap = config.texture_copy.output_gap * 16;
-                    size_t contiguous_input_size = config.texture_copy.size / input_width * (input_width + input_gap);
+                    size_t contiguous_input_size =
-                    Memory::RasterizerFlushRegion(config.GetPhysicalInputAddress(), static_cast<u32>(contiguous_input_size));
+                        config.texture_copy.size / input_width * (input_width + input_gap);
+                    Memory::RasterizerFlushRegion(config.GetPhysicalInputAddress(),
+                                                  static_cast<u32>(contiguous_input_size));
-                    size_t contiguous_output_size = config.texture_copy.size / output_width * (output_width + output_gap);
+                    size_t contiguous_output_size =
-                    Memory::RasterizerFlushAndInvalidateRegion(config.GetPhysicalOutputAddress(), static_cast<u32>(contiguous_output_size));
+                        config.texture_copy.size / output_width * (output_width + output_gap);
+                    Memory::RasterizerFlushAndInvalidateRegion(
+                        config.GetPhysicalOutputAddress(),
+                        static_cast<u32>(contiguous_output_size));
                    u32 remaining_size = config.texture_copy.size;
                    u32 remaining_input = input_width;
                    u32 remaining_output = output_width;
                    while (remaining_size > 0) {
-                        u32 copy_size = std::min({ remaining_input, remaining_output, remaining_size });
+                        u32 copy_size =
+                            std::min({remaining_input, remaining_output, remaining_size});
                        std::memcpy(dst_pointer, src_pointer, copy_size);
                        src_pointer += copy_size;
@@ -217,10 +224,11 @@ inline void Write(u32 addr, const T data) {
                        }
                    }
-                    LOG_TRACE(HW_GPU, "TextureCopy: 0x%X bytes from 0x%08X(%u+%u)-> 0x%08X(%u+%u), flags 0x%08X",
+                    LOG_TRACE(
-                        config.texture_copy.size,
+                        HW_GPU,
-                        config.GetPhysicalInputAddress(), input_width, input_gap,
+                        "TextureCopy: 0x%X bytes from 0x%08X(%u+%u)-> 0x%08X(%u+%u), flags 0x%08X",
-                        config.GetPhysicalOutputAddress(), output_width, output_gap,
+                        config.texture_copy.size, config.GetPhysicalInputAddress(), input_width,
+                        input_gap, config.GetPhysicalOutputAddress(), output_width, output_gap,
                        config.flags);
                    GSP_GPU::SignalInterrupt(GSP_GPU::InterruptId::PPF);
@@ -228,7 +236,8 @@ inline void Write(u32 addr, const T data) {
                }
                if (config.scaling > config.ScaleXY) {
-                    LOG_CRITICAL(HW_GPU, "Unimplemented display transfer scaling mode %u", config.scaling.Value());
+                    LOG_CRITICAL(HW_GPU, "Unimplemented display transfer scaling mode %u",
+                                 config.scaling.Value());
                    UNIMPLEMENTED();
                    break;
                }
@@ -245,11 +254,14 @@ inline void Write(u32 addr, const T data) {
                u32 output_width = config.output_width >> horizontal_scale;
                u32 output_height = config.output_height >> vertical_scale;
-                u32 input_size = config.input_width * config.input_height * GPU::Regs::BytesPerPixel(config.input_format);
+                u32 input_size = config.input_width * config.input_height *
-                u32 output_size = output_width * output_height * GPU::Regs::BytesPerPixel(config.output_format);
+                                 GPU::Regs::BytesPerPixel(config.input_format);
+                u32 output_size =
+                    output_width * output_height * GPU::Regs::BytesPerPixel(config.output_format);
                Memory::RasterizerFlushRegion(config.GetPhysicalInputAddress(), input_size);
-                Memory::RasterizerFlushAndInvalidateRegion(config.GetPhysicalOutputAddress(), output_size);
+                Memory::RasterizerFlushAndInvalidateRegion(config.GetPhysicalOutputAddress(),
+                                                           output_size);
                for (u32 y = 0; y < output_height; ++y) {
                    for (u32 x = 0; x < output_width; ++x) {
@@ -278,11 +290,14 @@ inline void Write(u32 addr, const T data) {
                                u32 coarse_y = y & ~7;
                                u32 stride = output_width * dst_bytes_per_pixel;
-                                src_offset = (input_x + input_y * config.input_width) * src_bytes_per_pixel;
+                                src_offset =
-                                dst_offset = VideoCore::GetMortonOffset(x, y, dst_bytes_per_pixel) + coarse_y * stride;
+                                    (input_x + input_y * config.input_width) * src_bytes_per_pixel;
+                                dst_offset = VideoCore::GetMortonOffset(x, y, dst_bytes_per_pixel) +
+                                             coarse_y * stride;
                            } else {
                                // Both input and output are linear
-                                src_offset = (input_x + input_y * config.input_width) * src_bytes_per_pixel;
+                                src_offset =
+                                    (input_x + input_y * config.input_width) * src_bytes_per_pixel;
                                dst_offset = (x + y * output_width) * dst_bytes_per_pixel;
                            }
                        } else {
@@ -291,7 +306,9 @@ inline void Write(u32 addr, const T data) {
                                u32 coarse_y = input_y & ~7;
                                u32 stride = config.input_width * src_bytes_per_pixel;
-                                src_offset = VideoCore::GetMortonOffset(input_x, input_y, src_bytes_per_pixel) + coarse_y * stride;
+                                src_offset = VideoCore::GetMortonOffset(input_x, input_y,
+                                                                        src_bytes_per_pixel) +
+                                             coarse_y * stride;
                                dst_offset = (x + y * output_width) * dst_bytes_per_pixel;
                            } else {
                                // Both input and output are tiled
@@ -301,20 +318,27 @@ inline void Write(u32 addr, const T data) {
                                u32 in_coarse_y = input_y & ~7;
                                u32 in_stride = config.input_width * src_bytes_per_pixel;
-                                src_offset = VideoCore::GetMortonOffset(input_x, input_y, src_bytes_per_pixel) + in_coarse_y * in_stride;
+                                src_offset = VideoCore::GetMortonOffset(input_x, input_y,
-                                dst_offset = VideoCore::GetMortonOffset(x, y, dst_bytes_per_pixel) + out_coarse_y * out_stride;
+                                                                        src_bytes_per_pixel) +
+                                             in_coarse_y * in_stride;
+                                dst_offset = VideoCore::GetMortonOffset(x, y, dst_bytes_per_pixel) +
+                                             out_coarse_y * out_stride;
                            }
                        }
                        const u8* src_pixel = src_pointer + src_offset;
                        src_color = DecodePixel(config.input_format, src_pixel);
                        if (config.scaling == config.ScaleX) {
-                            Math::Vec4<u8> pixel = DecodePixel(config.input_format, src_pixel + src_bytes_per_pixel);
+                            Math::Vec4<u8> pixel =
+                                DecodePixel(config.input_format, src_pixel + src_bytes_per_pixel);
                            src_color = ((src_color + pixel) / 2).Cast<u8>();
                        } else if (config.scaling == config.ScaleXY) {
-                            Math::Vec4<u8> pixel1 = DecodePixel(config.input_format, src_pixel + 1 * src_bytes_per_pixel);
+                            Math::Vec4<u8> pixel1 = DecodePixel(
-                            Math::Vec4<u8> pixel2 = DecodePixel(config.input_format, src_pixel + 2 * src_bytes_per_pixel);
+                                config.input_format, src_pixel + 1 * src_bytes_per_pixel);
-                            Math::Vec4<u8> pixel3 = DecodePixel(config.input_format, src_pixel + 3 * src_bytes_per_pixel);
+                            Math::Vec4<u8> pixel2 = DecodePixel(
+                                config.input_format, src_pixel + 2 * src_bytes_per_pixel);
+                            Math::Vec4<u8> pixel3 = DecodePixel(
+                                config.input_format, src_pixel + 3 * src_bytes_per_pixel);
                            src_color = (((src_color + pixel1) + (pixel2 + pixel3)) / 4).Cast<u8>();
                        }
@@ -341,17 +365,20 @@ inline void Write(u32 addr, const T data) {
                            break;
                        default:
-                            LOG_ERROR(HW_GPU, "Unknown destination framebuffer format %x", config.output_format.Value());
+                            LOG_ERROR(HW_GPU, "Unknown destination framebuffer format %x",
+                                      config.output_format.Value());
                            break;
                        }
                    }
                }
-                LOG_TRACE(HW_GPU, "DisplayTriggerTransfer: 0x%08x bytes from 0x%08x(%ux%u)-> 0x%08x(%ux%u), dst format %x, flags 0x%08X",
+                LOG_TRACE(HW_GPU, "DisplayTriggerTransfer: 0x%08x bytes from 0x%08x(%ux%u)-> "
-                      config.output_height * output_width * GPU::Regs::BytesPerPixel(config.output_format),
+                                  "0x%08x(%ux%u), dst format %x, flags 0x%08X",
-                      config.GetPhysicalInputAddress(), config.input_width.Value(), config.input_height.Value(),
+                          config.output_height * output_width *
-                      config.GetPhysicalOutputAddress(), output_width, output_height,
+                              GPU::Regs::BytesPerPixel(config.output_format),
-                      config.output_format.Value(), config.flags);
+                          config.GetPhysicalInputAddress(), config.input_width.Value(),
+                          config.input_height.Value(), config.GetPhysicalOutputAddress(),
+                          output_width, output_height, config.output_format.Value(), config.flags);
            }
            g_regs.display_transfer_config.trigger = 0;
@@ -361,17 +388,16 @@ inline void Write(u32 addr, const T data) {
    }
    // Seems like writing to this register triggers processing
-    case GPU_REG_INDEX(command_processor_config.trigger):
+    case GPU_REG_INDEX(command_processor_config.trigger): {
-    {
        const auto& config = g_regs.command_processor_config;
-        if (config.trigger & 1)
+        if (config.trigger & 1) {
-        {
            MICROPROFILE_SCOPE(GPU_CmdlistProcessing);
            u32* buffer = (u32*)Memory::GetPhysicalPointer(config.GetPhysicalAddress());
            if (Pica::g_debug_context && Pica::g_debug_context->recorder) {
-                Pica::g_debug_context->recorder->MemoryAccessed((u8*)buffer, config.size * sizeof(u32), config.GetPhysicalAddress());
+                Pica::g_debug_context->recorder->MemoryAccessed(
+                    (u8*)buffer, config.size * sizeof(u32), config.GetPhysicalAddress());
            }
            Pica::CommandProcessor::ProcessCommandList(buffer, config.size);
@@ -389,16 +415,17 @@ inline void Write(u32 addr, const T data) {
    // This is happening *after* handling the write to make sure we properly catch all memory reads.
    if (Pica::g_debug_context && Pica::g_debug_context->recorder) {
        // addr + GPU VBase - IO VBase + IO PBase
-        Pica::g_debug_context->recorder->RegisterWritten<T>(addr + 0x1EF00000 - 0x1EC00000 + 0x10100000, data);
+        Pica::g_debug_context->recorder->RegisterWritten<T>(
+            addr + 0x1EF00000 - 0x1EC00000 + 0x10100000, data);
    }
 }
 // Explicitly instantiate template functions because we aren't defining this in the header:
-template void Read<u64>(u64 &var, const u32 addr);
+template void Read<u64>(u64& var, const u32 addr);
-template void Read<u32>(u32 &var, const u32 addr);
+template void Read<u32>(u32& var, const u32 addr);
-template void Read<u16>(u16 &var, const u32 addr);
+template void Read<u16>(u16& var, const u32 addr);
-template void Read<u8>(u8 &var, const u32 addr);
+template void Read<u8>(u8& var, const u32 addr);
 template void Write<u64>(u32 addr, const u64 data);
 template void Write<u32>(u32 addr, const u32 data);
@@ -417,8 +444,9 @@ static void VBlankCallback(u64 userdata, int cycles_late) {
    //  - If frameskip == 0 (disabled), always swap buffers
    //  - If frameskip == 1, swap buffers every other frame (starting from the first frame)
    //  - If frameskip > 1, swap buffers every frameskip^n frames (starting from the second frame)
-    if ((((Settings::values.frame_skip != 1) ^ last_skip_frame) && last_skip_frame != g_skip_frame) ||
+    if ((((Settings::values.frame_skip != 1) ^ last_skip_frame) &&
-            Settings::values.frame_skip == 0) {
+         last_skip_frame != g_skip_frame) ||
+        Settings::values.frame_skip == 0) {
        VideoCore::g_renderer->SwapBuffers();
    }
@@ -448,12 +476,12 @@ void Init() {
    // .. or at least these are the ones used by system applets.
    // There's probably a smarter way to come up with addresses
    // like this which does not require hardcoding.
-    framebuffer_top.address_left1  = 0x181E6000;
+    framebuffer_top.address_left1 = 0x181E6000;
-    framebuffer_top.address_left2  = 0x1822C800;
+    framebuffer_top.address_left2 = 0x1822C800;
    framebuffer_top.address_right1 = 0x18273000;
    framebuffer_top.address_right2 = 0x182B9800;
-    framebuffer_sub.address_left1  = 0x1848F000;
+    framebuffer_sub.address_left1 = 0x1848F000;
-    framebuffer_sub.address_left2  = 0x184C7800;
+    framebuffer_sub.address_left2 = 0x184C7800;
    framebuffer_top.width.Assign(240);
    framebuffer_top.height.Assign(400);
diff --git a/src/core/hw/gpu.h b/src/core/hw/gpu.h
index da4c345b4..077b6255f 100644
--- a/src/core/hw/gpu.h
+++ b/src/core/hw/gpu.h
@@ -17,7 +17,8 @@ namespace GPU {
 // Returns index corresponding to the Regs member labeled by field_name
 // TODO: Due to Visual studio bug 209229, offsetof does not return constant expressions
 //       when used with array elements (e.g. GPU_REG_INDEX(memory_fill_config[0])).
-//       For details cf. https://connect.microsoft.com/VisualStudio/feedback/details/209229/offsetof-does-not-produce-a-constant-expression-for-array-members
+//       For details cf.
+//       https://connect.microsoft.com/VisualStudio/feedback/details/209229/offsetof-does-not-produce-a-constant-expression-for-array-members
 //       Hopefully, this will be fixed sometime in the future.
 //       For lack of better alternatives, we currently hardcode the offsets when constant
 //       expressions are needed via GPU_REG_INDEX_WORKAROUND (on sane compilers, static_asserts
@@ -30,8 +31,9 @@ namespace GPU {
 //       really is this annoying. This macro just forwards its first argument to GPU_REG_INDEX
 //       and then performs a (no-op) cast to size_t iff the second argument matches the expected
 //       field offset. Otherwise, the compiler will fail to compile this code.
-#define GPU_REG_INDEX_WORKAROUND(field_name, backup_workaround_index) \
+#define GPU_REG_INDEX_WORKAROUND(field_name, backup_workaround_index)                              \
-    ((typename std::enable_if<backup_workaround_index == GPU_REG_INDEX(field_name), size_t>::type)GPU_REG_INDEX(field_name))
+    ((typename std::enable_if<backup_workaround_index == GPU_REG_INDEX(field_name), size_t>::type) \
+         GPU_REG_INDEX(field_name))
 #endif
 // MMIO region 0x1EFxxxxx
@@ -44,18 +46,18 @@ struct Regs {
 //       support for that.
 #define ASSERT_MEMBER_SIZE(name, size_in_bytes)
 #else
-#define ASSERT_MEMBER_SIZE(name, size_in_bytes)  \
+#define ASSERT_MEMBER_SIZE(name, size_in_bytes)                                                    \
-    static_assert(sizeof(name) == size_in_bytes, \
+    static_assert(sizeof(name) == size_in_bytes,                                                   \
                  "Structure size and register block length don't match")
 #endif
    // Components are laid out in reverse byte order, most significant bits first.
    enum class PixelFormat : u32 {
-        RGBA8  = 0,
+        RGBA8 = 0,
-        RGB8   = 1,
+        RGB8 = 1,
        RGB565 = 2,
        RGB5A1 = 3,
-        RGBA4  = 4,
+        RGBA4 = 4,
    };
    /**
@@ -88,8 +90,8 @@ struct Regs {
            BitField<0, 16, u32> value_16bit;
            // TODO: Verify component order
-            BitField< 0, 8, u32> value_24bit_r;
+            BitField<0, 8, u32> value_24bit_r;
-            BitField< 8, 8, u32> value_24bit_g;
+            BitField<8, 8, u32> value_24bit_g;
            BitField<16, 8, u32> value_24bit_b;
        };
@@ -126,7 +128,7 @@ struct Regs {
        union {
            u32 size;
-            BitField< 0, 16, u32> width;
+            BitField<0, 16, u32> width;
            BitField<16, 16, u32> height;
        };
@@ -138,7 +140,7 @@ struct Regs {
        union {
            u32 format;
-            BitField< 0, 3, PixelFormat> color_format;
+            BitField<0, 3, PixelFormat> color_format;
        };
        INSERT_PADDING_WORDS(0x1);
@@ -180,35 +182,37 @@ struct Regs {
        union {
            u32 output_size;
-            BitField< 0, 16, u32> output_width;
+            BitField<0, 16, u32> output_width;
            BitField<16, 16, u32> output_height;
        };
        union {
            u32 input_size;
-            BitField< 0, 16, u32> input_width;
+            BitField<0, 16, u32> input_width;
            BitField<16, 16, u32> input_height;
        };
        enum ScalingMode : u32 {
-            NoScale  = 0,  // Doesn't scale the image
+            NoScale = 0, // Doesn't scale the image
-            ScaleX   = 1,  // Downscales the image in half in the X axis and applies a box filter
+            ScaleX = 1,  // Downscales the image in half in the X axis and applies a box filter
-            ScaleXY  = 2,  // Downscales the image in half in both the X and Y axes and applies a box filter
+            ScaleXY =
+                2, // Downscales the image in half in both the X and Y axes and applies a box filter
        };
        union {
            u32 flags;
-            BitField< 0, 1, u32> flip_vertically;  // flips input data vertically
+            BitField<0, 1, u32> flip_vertically; // flips input data vertically
-            BitField< 1, 1, u32> input_linear;     // Converts from linear to tiled format
+            BitField<1, 1, u32> input_linear;    // Converts from linear to tiled format
-            BitField< 2, 1, u32> crop_input_lines;
+            BitField<2, 1, u32> crop_input_lines;
-            BitField< 3, 1, u32> is_texture_copy;  // Copies the data without performing any processing and respecting texture copy fields
+            BitField<3, 1, u32> is_texture_copy; // Copies the data without performing any
-            BitField< 5, 1, u32> dont_swizzle;
+                                                 // processing and respecting texture copy fields
-            BitField< 8, 3, PixelFormat> input_format;
+            BitField<5, 1, u32> dont_swizzle;
+            BitField<8, 3, PixelFormat> input_format;
            BitField<12, 3, PixelFormat> output_format;
            /// Uses some kind of 32x32 block swizzling mode, instead of the usual 8x8 one.
-            BitField<16, 1, u32> block_32; // TODO(yuriks): unimplemented
+            BitField<16, 1, u32> block_32;        // TODO(yuriks): unimplemented
            BitField<24, 2, ScalingMode> scaling; // Determines the scaling mode of the transfer
        };
@@ -225,14 +229,14 @@ struct Regs {
            union {
                u32 input_size;
-                BitField< 0, 16, u32> input_width;
+                BitField<0, 16, u32> input_width;
                BitField<16, 16, u32> input_gap;
            };
            union {
                u32 output_size;
-                BitField< 0, 16, u32> output_width;
+                BitField<0, 16, u32> output_width;
                BitField<16, 16, u32> output_gap;
            };
        } texture_copy;
@@ -267,12 +271,12 @@ struct Regs {
        return sizeof(Regs) / sizeof(u32);
    }
-    const u32& operator [] (int index) const {
+    const u32& operator[](int index) const {
        const u32* content = reinterpret_cast<const u32*>(this);
        return content[index];
    }
-    u32& operator [] (int index) {
+    u32& operator[](int index) {
        u32* content = reinterpret_cast<u32*>(this);
        return content[index];
    }
@@ -294,28 +298,29 @@ static_assert(std::is_standard_layout<Regs>::value, "Structure does not use stan
 //       is technically allowed since C++11. This macro should be enabled once MSVC adds
 //       support for that.
 #ifndef _MSC_VER
-#define ASSERT_REG_POSITION(field_name, position)             \
+#define ASSERT_REG_POSITION(field_name, position)                                                  \
-    static_assert(offsetof(Regs, field_name) == position * 4, \
+    static_assert(offsetof(Regs, field_name) == position * 4,                                      \
-                  "Field "#field_name" has invalid position")
+                  "Field " #field_name " has invalid position")
-ASSERT_REG_POSITION(memory_fill_config[0],    0x00004);
+ASSERT_REG_POSITION(memory_fill_config[0], 0x00004);
-ASSERT_REG_POSITION(memory_fill_config[1],    0x00008);
+ASSERT_REG_POSITION(memory_fill_config[1], 0x00008);
-ASSERT_REG_POSITION(framebuffer_config[0],    0x00117);
+ASSERT_REG_POSITION(framebuffer_config[0], 0x00117);
-ASSERT_REG_POSITION(framebuffer_config[1],    0x00157);
+ASSERT_REG_POSITION(framebuffer_config[1], 0x00157);
-ASSERT_REG_POSITION(display_transfer_config,  0x00300);
+ASSERT_REG_POSITION(display_transfer_config, 0x00300);
 ASSERT_REG_POSITION(command_processor_config, 0x00638);
 #undef ASSERT_REG_POSITION
 #endif // !defined(_MSC_VER)
-// The total number of registers is chosen arbitrarily, but let's make sure it's not some odd value anyway.
+// The total number of registers is chosen arbitrarily, but let's make sure it's not some odd value
+// anyway.
 static_assert(sizeof(Regs) == 0x1000 * sizeof(u32), "Invalid total size of register set");
 extern Regs g_regs;
 extern bool g_skip_frame;
 template <typename T>
-void Read(T &var, const u32 addr);
+void Read(T& var, const u32 addr);
 template <typename T>
 void Write(u32 addr, const T data);
@@ -326,5 +331,4 @@ void Init();
 /// Shutdown hardware
 void Shutdown();
 } // namespace
diff --git a/src/core/hw/hw.cpp b/src/core/hw/hw.cpp
index b5fdbf9c1..db224c9aa 100644
--- a/src/core/hw/hw.cpp
+++ b/src/core/hw/hw.cpp
@@ -5,14 +5,14 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "core/hw/hw.h"
 #include "core/hw/gpu.h"
+#include "core/hw/hw.h"
 #include "core/hw/lcd.h"
 namespace HW {
 template <typename T>
-inline void Read(T &var, const u32 addr) {
+inline void Read(T& var, const u32 addr) {
    switch (addr & 0xFFFFF000) {
    case VADDR_GPU:
    case VADDR_GPU + 0x1000:
@@ -71,10 +71,10 @@ inline void Write(u32 addr, const T data) {
 // Explicitly instantiate template functions because we aren't defining this in the header:
-template void Read<u64>(u64 &var, const u32 addr);
+template void Read<u64>(u64& var, const u32 addr);
-template void Read<u32>(u32 &var, const u32 addr);
+template void Read<u32>(u32& var, const u32 addr);
-template void Read<u16>(u16 &var, const u32 addr);
+template void Read<u16>(u16& var, const u32 addr);
-template void Read<u8>(u8 &var, const u32 addr);
+template void Read<u8>(u8& var, const u32 addr);
 template void Write<u64>(u32 addr, const u64 data);
 template void Write<u32>(u32 addr, const u32 data);
@@ -98,5 +98,4 @@ void Shutdown() {
    LCD::Shutdown();
    LOG_DEBUG(HW, "shutdown OK");
 }
 }
diff --git a/src/core/hw/hw.h b/src/core/hw/hw.h
index d65608910..a3c5d2ea3 100644
--- a/src/core/hw/hw.h
+++ b/src/core/hw/hw.h
@@ -10,30 +10,30 @@ namespace HW {
 /// Beginnings of IO register regions, in the user VA space.
 enum : u32 {
-    VADDR_HASH      = 0x1EC01000,
+    VADDR_HASH = 0x1EC01000,
-    VADDR_CSND      = 0x1EC03000,
+    VADDR_CSND = 0x1EC03000,
-    VADDR_DSP       = 0x1EC40000,
+    VADDR_DSP = 0x1EC40000,
-    VADDR_PDN       = 0x1EC41000,
+    VADDR_PDN = 0x1EC41000,
-    VADDR_CODEC     = 0x1EC41000,
+    VADDR_CODEC = 0x1EC41000,
-    VADDR_SPI       = 0x1EC42000,
+    VADDR_SPI = 0x1EC42000,
-    VADDR_SPI_2     = 0x1EC43000,   // Only used under TWL_FIRM?
+    VADDR_SPI_2 = 0x1EC43000, // Only used under TWL_FIRM?
-    VADDR_I2C       = 0x1EC44000,
+    VADDR_I2C = 0x1EC44000,
-    VADDR_CODEC_2   = 0x1EC45000,
+    VADDR_CODEC_2 = 0x1EC45000,
-    VADDR_HID       = 0x1EC46000,
+    VADDR_HID = 0x1EC46000,
-    VADDR_GPIO      = 0x1EC47000,
+    VADDR_GPIO = 0x1EC47000,
-    VADDR_I2C_2     = 0x1EC48000,
+    VADDR_I2C_2 = 0x1EC48000,
-    VADDR_SPI_3     = 0x1EC60000,
+    VADDR_SPI_3 = 0x1EC60000,
-    VADDR_I2C_3     = 0x1EC61000,
+    VADDR_I2C_3 = 0x1EC61000,
-    VADDR_MIC       = 0x1EC62000,
+    VADDR_MIC = 0x1EC62000,
-    VADDR_PXI       = 0x1EC63000,
+    VADDR_PXI = 0x1EC63000,
-    VADDR_LCD       = 0x1ED02000,
+    VADDR_LCD = 0x1ED02000,
-    VADDR_DSP_2     = 0x1ED03000,
+    VADDR_DSP_2 = 0x1ED03000,
-    VADDR_HASH_2    = 0x1EE01000,
+    VADDR_HASH_2 = 0x1EE01000,
-    VADDR_GPU       = 0x1EF00000,
+    VADDR_GPU = 0x1EF00000,
 };
 template <typename T>
-void Read(T &var, const u32 addr);
+void Read(T& var, const u32 addr);
 template <typename T>
 void Write(u32 addr, const T data);
diff --git a/src/core/hw/lcd.cpp b/src/core/hw/lcd.cpp
index 6f93709e3..0e3aa7cfd 100644
--- a/src/core/hw/lcd.cpp
+++ b/src/core/hw/lcd.cpp
@@ -18,7 +18,7 @@ namespace LCD {
 Regs g_regs;
 template <typename T>
-inline void Read(T &var, const u32 raw_addr) {
+inline void Read(T& var, const u32 raw_addr) {
    u32 addr = raw_addr - HW::VADDR_LCD;
    u32 index = addr / 4;
@@ -48,16 +48,17 @@ inline void Write(u32 addr, const T data) {
    // This is happening *after* handling the write to make sure we properly catch all memory reads.
    if (Pica::g_debug_context && Pica::g_debug_context->recorder) {
        // addr + GPU VBase - IO VBase + IO PBase
-        Pica::g_debug_context->recorder->RegisterWritten<T>(addr + HW::VADDR_LCD - 0x1EC00000 + 0x10100000, data);
+        Pica::g_debug_context->recorder->RegisterWritten<T>(
+            addr + HW::VADDR_LCD - 0x1EC00000 + 0x10100000, data);
    }
 }
 // Explicitly instantiate template functions because we aren't defining this in the header:
-template void Read<u64>(u64 &var, const u32 addr);
+template void Read<u64>(u64& var, const u32 addr);
-template void Read<u32>(u32 &var, const u32 addr);
+template void Read<u32>(u32& var, const u32 addr);
-template void Read<u16>(u16 &var, const u32 addr);
+template void Read<u16>(u16& var, const u32 addr);
-template void Read<u8>(u8 &var, const u32 addr);
+template void Read<u8>(u8& var, const u32 addr);
 template void Write<u64>(u32 addr, const u64 data);
 template void Write<u32>(u32 addr, const u32 data);
diff --git a/src/core/hw/lcd.h b/src/core/hw/lcd.h
index 57029c5e8..404833165 100644
--- a/src/core/hw/lcd.h
+++ b/src/core/hw/lcd.h
@@ -42,16 +42,15 @@ struct Regs {
        return sizeof(Regs) / sizeof(u32);
    }
-    const u32& operator [] (int index) const {
+    const u32& operator[](int index) const {
        const u32* content = reinterpret_cast<const u32*>(this);
        return content[index];
    }
-    u32& operator [] (int index) {
+    u32& operator[](int index) {
        u32* content = reinterpret_cast<u32*>(this);
        return content[index];
    }
 };
 static_assert(std::is_standard_layout<Regs>::value, "Structure does not use standard layout");
@@ -59,14 +58,14 @@ static_assert(std::is_standard_layout<Regs>::value, "Structure does not use stan
 //       is technically allowed since C++11. This macro should be enabled once MSVC adds
 //       support for that.
 #ifndef _MSC_VER
-#define ASSERT_REG_POSITION(field_name, position) \
+#define ASSERT_REG_POSITION(field_name, position)                                                  \
-    static_assert(offsetof(Regs, field_name) == position * 4, \
+    static_assert(offsetof(Regs, field_name) == position * 4,                                      \
-              "Field "#field_name" has invalid position")
+                  "Field " #field_name " has invalid position")
-ASSERT_REG_POSITION(color_fill_top,    0x81);
+ASSERT_REG_POSITION(color_fill_top, 0x81);
-ASSERT_REG_POSITION(backlight_top,     0x90);
+ASSERT_REG_POSITION(backlight_top, 0x90);
 ASSERT_REG_POSITION(color_fill_bottom, 0x281);
-ASSERT_REG_POSITION(backlight_bottom,  0x290);
+ASSERT_REG_POSITION(backlight_bottom, 0x290);
 #undef ASSERT_REG_POSITION
 #endif // !defined(_MSC_VER)
@@ -74,7 +73,7 @@ ASSERT_REG_POSITION(backlight_bottom,  0x290);
 extern Regs g_regs;
 template <typename T>
-void Read(T &var, const u32 addr);
+void Read(T& var, const u32 addr);
 template <typename T>
 void Write(u32 addr, const T data);
diff --git a/src/core/hw/y2r.cpp b/src/core/hw/y2r.cpp
index 083391e83..5a68d7e65 100644
--- a/src/core/hw/y2r.cpp
+++ b/src/core/hw/y2r.cpp
@@ -27,9 +27,9 @@ static const size_t TILE_SIZE = 8 * 8;
 using ImageTile = std::array<u32, TILE_SIZE>;
 /// Converts a image strip from the source YUV format into individual 8x8 RGB32 tiles.
-static void ConvertYUVToRGB(InputFormat input_format,
+static void ConvertYUVToRGB(InputFormat input_format, const u8* input_Y, const u8* input_U,
-        const u8* input_Y, const u8* input_U, const u8* input_V, ImageTile output[],
+                            const u8* input_V, ImageTile output[], unsigned int width,
-        unsigned int width, unsigned int height, const CoefficientSet& coefficients) {
+                            unsigned int height, const CoefficientSet& coefficients) {
    for (unsigned int y = 0; y < height; ++y) {
        for (unsigned int x = 0; x < width; ++x) {
@@ -58,11 +58,11 @@ static void ConvertYUVToRGB(InputFormat input_format,
            // This conversion process is bit-exact with hardware, as far as could be tested.
            auto& c = coefficients;
-            s32 cY = c[0]*Y;
+            s32 cY = c[0] * Y;
-            s32 r = cY          + c[1]*V;
+            s32 r = cY + c[1] * V;
-            s32 g = cY - c[3]*U - c[2]*V;
+            s32 g = cY - c[3] * U - c[2] * V;
-            s32 b = cY + c[4]*U;
+            s32 b = cY + c[4] * U;
            const s32 rounding_offset = 0x18;
            r = (r >> 3) + c[5] + rounding_offset;
@@ -74,14 +74,14 @@ static void ConvertYUVToRGB(InputFormat input_format,
            u32* out = &output[tile][y * 8 + tile_x];
            using MathUtil::Clamp;
-            *out = ((u32)Clamp(r >> 5, 0, 0xFF) << 24) |
+            *out = ((u32)Clamp(r >> 5, 0, 0xFF) << 24) | ((u32)Clamp(g >> 5, 0, 0xFF) << 16) |
-                   ((u32)Clamp(g >> 5, 0, 0xFF) << 16) |
                   ((u32)Clamp(b >> 5, 0, 0xFF) << 8);
        }
    }
 }
-/// Simulates an incoming CDMA transfer. The N parameter is used to automatically convert 16-bit formats to 8-bit.
+/// Simulates an incoming CDMA transfer. The N parameter is used to automatically convert 16-bit
+/// formats to 8-bit.
 template <size_t N>
 static void ReceiveData(u8* output, ConversionBuffer& buf, size_t amount_of_data) {
    const u8* input = Memory::GetPointer(buf.address);
@@ -103,9 +103,10 @@ static void ReceiveData(u8* output, ConversionBuffer& buf, size_t amount_of_data
    }
 }
-/// Convert intermediate RGB32 format to the final output format while simulating an outgoing CDMA transfer.
+/// Convert intermediate RGB32 format to the final output format while simulating an outgoing CDMA
+/// transfer.
 static void SendData(const u32* input, ConversionBuffer& buf, int amount_of_data,
-        OutputFormat output_format, u8 alpha) {
+                     OutputFormat output_format, u8 alpha) {
    u8* output = Memory::GetPointer(buf.address);
@@ -113,9 +114,7 @@ static void SendData(const u32* input, ConversionBuffer& buf, int amount_of_data
        u8* unit_end = output + buf.transfer_unit;
        while (output < unit_end) {
            u32 color = *input++;
-            Math::Vec4<u8> col_vec{
+            Math::Vec4<u8> col_vec{(u8)(color >> 24), (u8)(color >> 16), (u8)(color >> 8), alpha};
-                (u8)(color >> 24), (u8)(color >> 16), (u8)(color >> 8), alpha
-            };
            switch (output_format) {
            case OutputFormat::RGBA8:
@@ -146,34 +145,26 @@ static void SendData(const u32* input, ConversionBuffer& buf, int amount_of_data
 }
 static const u8 linear_lut[64] = {
-     0,  1,  2,  3,  4,  5,  6,  7,
+    0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
-     8,  9, 10, 11, 12, 13, 14, 15,
+    22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
-    16, 17, 18, 19, 20, 21, 22, 23,
+    44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
-    24, 25, 26, 27, 28, 29, 30, 31,
-    32, 33, 34, 35, 36, 37, 38, 39,
-    40, 41, 42, 43, 44, 45, 46, 47,
-    48, 49, 50, 51, 52, 53, 54, 55,
-    56, 57, 58, 59, 60, 61, 62, 63,
 };
 static const u8 morton_lut[64] = {
-     0,  1,  4,  5, 16, 17, 20, 21,
+    0,  1,  4,  5,  16, 17, 20, 21, 2,  3,  6,  7,  18, 19, 22, 23, 8,  9,  12, 13, 24, 25,
-     2,  3,  6,  7, 18, 19, 22, 23,
+    28, 29, 10, 11, 14, 15, 26, 27, 30, 31, 32, 33, 36, 37, 48, 49, 52, 53, 34, 35, 38, 39,
-     8,  9, 12, 13, 24, 25, 28, 29,
+    50, 51, 54, 55, 40, 41, 44, 45, 56, 57, 60, 61, 42, 43, 46, 47, 58, 59, 62, 63,
-    10, 11, 14, 15, 26, 27, 30, 31,
-    32, 33, 36, 37, 48, 49, 52, 53,
-    34, 35, 38, 39, 50, 51, 54, 55,
-    40, 41, 44, 45, 56, 57, 60, 61,
-    42, 43, 46, 47, 58, 59, 62, 63,
 };
-static void RotateTile0(const ImageTile& input, ImageTile& output, int height, const u8 out_map[64]) {
+static void RotateTile0(const ImageTile& input, ImageTile& output, int height,
+                        const u8 out_map[64]) {
    for (int i = 0; i < height * 8; ++i) {
        output[out_map[i]] = input[i];
    }
 }
-static void RotateTile90(const ImageTile& input, ImageTile& output, int height, const u8 out_map[64]) {
+static void RotateTile90(const ImageTile& input, ImageTile& output, int height,
+                         const u8 out_map[64]) {
    int out_i = 0;
    for (int x = 0; x < 8; ++x) {
        for (int y = height - 1; y >= 0; --y) {
@@ -182,16 +173,18 @@ static void RotateTile90(const ImageTile& input, ImageTile& output, int height,
    }
 }
-static void RotateTile180(const ImageTile& input, ImageTile& output, int height, const u8 out_map[64]) {
+static void RotateTile180(const ImageTile& input, ImageTile& output, int height,
+                          const u8 out_map[64]) {
    int out_i = 0;
    for (int i = height * 8 - 1; i >= 0; --i) {
        output[out_map[out_i++]] = input[i];
    }
 }
-static void RotateTile270(const ImageTile& input, ImageTile& output, int height, const u8 out_map[64]) {
+static void RotateTile270(const ImageTile& input, ImageTile& output, int height,
+                          const u8 out_map[64]) {
    int out_i = 0;
-    for (int x = 8-1; x >= 0; --x) {
+    for (int x = 8 - 1; x >= 0; --x) {
        for (int y = 0; y < height; ++y) {
            output[out_map[out_i++]] = input[y * 8 + x];
        }
@@ -274,9 +267,11 @@ void PerformConversion(ConversionConfiguration& cvt) {
    const u8* tile_remap = nullptr;
    switch (cvt.block_alignment) {
    case BlockAlignment::Linear:
-        tile_remap = linear_lut; break;
+        tile_remap = linear_lut;
+        break;
    case BlockAlignment::Block8x8:
-        tile_remap = morton_lut; break;
+        tile_remap = morton_lut;
+        break;
    }
    for (unsigned int y = 0; y < cvt.input_lines; y += 8) {
@@ -320,7 +315,7 @@ void PerformConversion(ConversionConfiguration& cvt) {
        // Note(yuriks): If additional optimization is required, input_format can be moved to a
        // template parameter, so that its dispatch can be moved to outside the inner loop.
        ConvertYUVToRGB(cvt.input_format, input_Y, input_U, input_V, tiles.get(),
-                cvt.input_line_width, row_height, cvt.coefficients);
+                        cvt.input_line_width, row_height, cvt.coefficients);
        u32* output_buffer = reinterpret_cast<u32*>(data_buffer.get());
@@ -367,9 +362,9 @@ void PerformConversion(ConversionConfiguration& cvt) {
        // Note(yuriks): If additional optimization is required, output_format can be moved to a
        // template parameter, so that its dispatch can be moved to outside the inner loop.
-        SendData(reinterpret_cast<u32*>(data_buffer.get()), cvt.dst, (int)row_data_size, cvt.output_format, (u8)cvt.alpha);
+        SendData(reinterpret_cast<u32*>(data_buffer.get()), cvt.dst, (int)row_data_size,
+                 cvt.output_format, (u8)cvt.alpha);
    }
 }
 }
 }
diff --git a/src/core/hw/y2r.h b/src/core/hw/y2r.h
index 729e1eee3..6b6e71bec 100644
--- a/src/core/hw/y2r.h
+++ b/src/core/hw/y2r.h
@@ -3,13 +3,12 @@
 // Refer to the license.txt file included.
 namespace Y2R_U {
-    struct ConversionConfiguration;
+struct ConversionConfiguration;
 }
 namespace HW {
 namespace Y2R {
 void PerformConversion(Y2R_U::ConversionConfiguration& cvt);
 }
 }
diff --git a/src/core/loader/3dsx.cpp b/src/core/loader/3dsx.cpp
index a16411e14..c2e87f592 100644
--- a/src/core/loader/3dsx.cpp
+++ b/src/core/loader/3dsx.cpp
@@ -37,20 +37,14 @@ namespace Loader {
 * The BSS section must be cleared manually by the application.
 */
-enum THREEDSX_Error {
+enum THREEDSX_Error { ERROR_NONE = 0, ERROR_READ = 1, ERROR_FILE = 2, ERROR_ALLOC = 3 };
-    ERROR_NONE = 0,
-    ERROR_READ = 1,
-    ERROR_FILE = 2,
-    ERROR_ALLOC = 3
-};
 static const u32 RELOCBUFSIZE = 512;
 static const unsigned int NUM_SEGMENTS = 3;
 // File header
 #pragma pack(1)
-struct THREEDSX_Header
+struct THREEDSX_Header {
-{
    u32 magic;
    u16 header_size, reloc_hdr_size;
    u32 format_ver;
@@ -66,11 +60,11 @@ struct THREEDSX_Header
 };
 // Relocation header: all fields (even extra unknown fields) are guaranteed to be relocation counts.
-struct THREEDSX_RelocHdr
+struct THREEDSX_RelocHdr {
-{
    // # of absolute relocations (that is, fix address to post-relocation memory layout)
    u32 cross_segment_absolute;
-    // # of cross-segment relative relocations (that is, 32bit signed offsets that need to be patched)
+    // # of cross-segment relative relocations (that is, 32bit signed offsets that need to be
+    // patched)
    u32 cross_segment_relative;
    // more?
@@ -80,21 +74,18 @@ struct THREEDSX_RelocHdr
 };
 // Relocation entry: from the current pointer, skip X words and patch Y words
-struct THREEDSX_Reloc
+struct THREEDSX_Reloc {
-{
    u16 skip, patch;
 };
 #pragma pack()
-struct THREEloadinfo
+struct THREEloadinfo {
-{
    u8* seg_ptrs[3]; // code, rodata & data
    u32 seg_addrs[3];
    u32 seg_sizes[3];
 };
-static u32 TranslateAddr(u32 addr, const THREEloadinfo *loadinfo, u32* offsets)
+static u32 TranslateAddr(u32 addr, const THREEloadinfo* loadinfo, u32* offsets) {
-{
    if (addr < offsets[0])
        return loadinfo->seg_addrs[0] + addr;
    if (addr < offsets[1])
@@ -105,8 +96,8 @@ static u32 TranslateAddr(u32 addr, const THREEloadinfo *loadinfo, u32* offsets)
 using Kernel::SharedPtr;
 using Kernel::CodeSet;
-static THREEDSX_Error Load3DSXFile(FileUtil::IOFile& file, u32 base_addr, SharedPtr<CodeSet>* out_codeset)
+static THREEDSX_Error Load3DSXFile(FileUtil::IOFile& file, u32 base_addr,
-{
+                                   SharedPtr<CodeSet>* out_codeset) {
    if (!file.IsOpen())
        return ERROR_FILE;
@@ -118,13 +109,14 @@ static THREEDSX_Error Load3DSXFile(FileUtil::IOFile& file, u32 base_addr, Shared
        return ERROR_READ;
    THREEloadinfo loadinfo;
-    //loadinfo segments must be a multiple of 0x1000
+    // loadinfo segments must be a multiple of 0x1000
-    loadinfo.seg_sizes[0] = (hdr.code_seg_size + 0xFFF) &~0xFFF;
+    loadinfo.seg_sizes[0] = (hdr.code_seg_size + 0xFFF) & ~0xFFF;
-    loadinfo.seg_sizes[1] = (hdr.rodata_seg_size + 0xFFF) &~0xFFF;
+    loadinfo.seg_sizes[1] = (hdr.rodata_seg_size + 0xFFF) & ~0xFFF;
-    loadinfo.seg_sizes[2] = (hdr.data_seg_size + 0xFFF) &~0xFFF;
+    loadinfo.seg_sizes[2] = (hdr.data_seg_size + 0xFFF) & ~0xFFF;
-    u32 offsets[2] = { loadinfo.seg_sizes[0], loadinfo.seg_sizes[0] + loadinfo.seg_sizes[1] };
+    u32 offsets[2] = {loadinfo.seg_sizes[0], loadinfo.seg_sizes[0] + loadinfo.seg_sizes[1]};
    u32 n_reloc_tables = hdr.reloc_hdr_size / sizeof(u32);
-    std::vector<u8> program_image(loadinfo.seg_sizes[0] + loadinfo.seg_sizes[1] + loadinfo.seg_sizes[2]);
+    std::vector<u8> program_image(loadinfo.seg_sizes[0] + loadinfo.seg_sizes[1] +
+                                  loadinfo.seg_sizes[2]);
    loadinfo.seg_addrs[0] = base_addr;
    loadinfo.seg_addrs[1] = loadinfo.seg_addrs[0] + loadinfo.seg_sizes[0];
@@ -149,7 +141,8 @@ static THREEDSX_Error Load3DSXFile(FileUtil::IOFile& file, u32 base_addr, Shared
        return ERROR_READ;
    if (file.ReadBytes(loadinfo.seg_ptrs[1], hdr.rodata_seg_size) != hdr.rodata_seg_size)
        return ERROR_READ;
-    if (file.ReadBytes(loadinfo.seg_ptrs[2], hdr.data_seg_size - hdr.bss_size) != hdr.data_seg_size - hdr.bss_size)
+    if (file.ReadBytes(loadinfo.seg_ptrs[2], hdr.data_seg_size - hdr.bss_size) !=
+        hdr.data_seg_size - hdr.bss_size)
        return ERROR_READ;
    // BSS clear
@@ -157,11 +150,12 @@ static THREEDSX_Error Load3DSXFile(FileUtil::IOFile& file, u32 base_addr, Shared
    // Relocate the segments
    for (unsigned int current_segment = 0; current_segment < NUM_SEGMENTS; ++current_segment) {
-        for (unsigned current_segment_reloc_table = 0; current_segment_reloc_table < n_reloc_tables; current_segment_reloc_table++) {
+        for (unsigned current_segment_reloc_table = 0; current_segment_reloc_table < n_reloc_tables;
+             current_segment_reloc_table++) {
            u32 n_relocs = relocs[current_segment * n_reloc_tables + current_segment_reloc_table];
            if (current_segment_reloc_table >= 2) {
                // We are not using this table - ignore it because we don't know what it dose
-                file.Seek(n_relocs*sizeof(THREEDSX_Reloc), SEEK_CUR);
+                file.Seek(n_relocs * sizeof(THREEDSX_Reloc), SEEK_CUR);
                continue;
            }
            THREEDSX_Reloc reloc_table[RELOCBUFSIZE];
@@ -173,17 +167,20 @@ static THREEDSX_Error Load3DSXFile(FileUtil::IOFile& file, u32 base_addr, Shared
                u32 remaining = std::min(RELOCBUFSIZE, n_relocs);
                n_relocs -= remaining;
-                if (file.ReadBytes(reloc_table, remaining * sizeof(THREEDSX_Reloc)) != remaining * sizeof(THREEDSX_Reloc))
+                if (file.ReadBytes(reloc_table, remaining * sizeof(THREEDSX_Reloc)) !=
+                    remaining * sizeof(THREEDSX_Reloc))
                    return ERROR_READ;
-                for (unsigned current_inprogress = 0; current_inprogress < remaining && pos < end_pos; current_inprogress++) {
+                for (unsigned current_inprogress = 0;
+                     current_inprogress < remaining && pos < end_pos; current_inprogress++) {
                    const auto& table = reloc_table[current_inprogress];
                    LOG_TRACE(Loader, "(t=%d,skip=%u,patch=%u)", current_segment_reloc_table,
                              static_cast<u32>(table.skip), static_cast<u32>(table.patch));
                    pos += table.skip;
                    s32 num_patches = table.patch;
                    while (0 < num_patches && pos < end_pos) {
-                        u32 in_addr = static_cast<u32>(reinterpret_cast<u8*>(pos) - program_image.data());
+                        u32 in_addr =
+                            static_cast<u32>(reinterpret_cast<u8*>(pos) - program_image.data());
                        u32 addr = TranslateAddr(*pos, &loadinfo, offsets);
                        LOG_TRACE(Loader, "Patching %08X <-- rel(%08X,%d) (%08X)",
                                  base_addr + in_addr, addr, current_segment_reloc_table, *pos);
@@ -195,7 +192,7 @@ static THREEDSX_Error Load3DSXFile(FileUtil::IOFile& file, u32 base_addr, Shared
                            *pos = static_cast<u32>(addr - in_addr);
                            break;
                        default:
-                            break; //this should never happen
+                            break; // this should never happen
                        }
                        pos++;
                        num_patches--;
@@ -209,23 +206,24 @@ static THREEDSX_Error Load3DSXFile(FileUtil::IOFile& file, u32 base_addr, Shared
    SharedPtr<CodeSet> code_set = CodeSet::Create("", 0);
    code_set->code.offset = loadinfo.seg_ptrs[0] - program_image.data();
-    code_set->code.addr   = loadinfo.seg_addrs[0];
+    code_set->code.addr = loadinfo.seg_addrs[0];
-    code_set->code.size   = loadinfo.seg_sizes[0];
+    code_set->code.size = loadinfo.seg_sizes[0];
    code_set->rodata.offset = loadinfo.seg_ptrs[1] - program_image.data();
-    code_set->rodata.addr   = loadinfo.seg_addrs[1];
+    code_set->rodata.addr = loadinfo.seg_addrs[1];
-    code_set->rodata.size   = loadinfo.seg_sizes[1];
+    code_set->rodata.size = loadinfo.seg_sizes[1];
    code_set->data.offset = loadinfo.seg_ptrs[2] - program_image.data();
-    code_set->data.addr   = loadinfo.seg_addrs[2];
+    code_set->data.addr = loadinfo.seg_addrs[2];
-    code_set->data.size   = loadinfo.seg_sizes[2];
+    code_set->data.size = loadinfo.seg_sizes[2];
    code_set->entrypoint = code_set->code.addr;
    code_set->memory = std::make_shared<std::vector<u8>>(std::move(program_image));
    LOG_DEBUG(Loader, "code size:   0x%X", loadinfo.seg_sizes[0]);
    LOG_DEBUG(Loader, "rodata size: 0x%X", loadinfo.seg_sizes[1]);
-    LOG_DEBUG(Loader, "data size:   0x%X (including 0x%X of bss)", loadinfo.seg_sizes[2], hdr.bss_size);
+    LOG_DEBUG(Loader, "data size:   0x%X (including 0x%X of bss)", loadinfo.seg_sizes[2],
+              hdr.bss_size);
    *out_codeset = code_set;
    return ERROR_NONE;
@@ -260,17 +258,20 @@ ResultStatus AppLoader_THREEDSX::Load() {
    Kernel::g_current_process->address_mappings = default_address_mappings;
    // Attach the default resource limit (APPLICATION) to the process
-    Kernel::g_current_process->resource_limit = Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
+    Kernel::g_current_process->resource_limit =
+        Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
    Kernel::g_current_process->Run(48, Kernel::DEFAULT_STACK_SIZE);
-    Service::FS::RegisterArchiveType(std::make_unique<FileSys::ArchiveFactory_RomFS>(*this), Service::FS::ArchiveIdCode::RomFS);
+    Service::FS::RegisterArchiveType(std::make_unique<FileSys::ArchiveFactory_RomFS>(*this),
+                                     Service::FS::ArchiveIdCode::RomFS);
    is_loaded = true;
    return ResultStatus::Success;
 }
-ResultStatus AppLoader_THREEDSX::ReadRomFS(std::shared_ptr<FileUtil::IOFile>& romfs_file, u64& offset, u64& size) {
+ResultStatus AppLoader_THREEDSX::ReadRomFS(std::shared_ptr<FileUtil::IOFile>& romfs_file,
+                                           u64& offset, u64& size) {
    if (!file.IsOpen())
        return ResultStatus::Error;
diff --git a/src/core/loader/3dsx.h b/src/core/loader/3dsx.h
index 90b20c61c..09a788a1c 100644
--- a/src/core/loader/3dsx.h
+++ b/src/core/loader/3dsx.h
@@ -17,8 +17,10 @@ namespace Loader {
 /// Loads an 3DSX file
 class AppLoader_THREEDSX final : public AppLoader {
 public:
-    AppLoader_THREEDSX(FileUtil::IOFile&& file, const std::string& filename, const std::string& filepath)
+    AppLoader_THREEDSX(FileUtil::IOFile&& file, const std::string& filename,
-        : AppLoader(std::move(file)), filename(std::move(filename)), filepath(filepath) {}
+                       const std::string& filepath)
+        : AppLoader(std::move(file)), filename(std::move(filename)), filepath(filepath) {
+    }
    /**
     * Returns the type of the file
@@ -55,7 +57,8 @@ public:
     * @param size       Size of the RomFS in bytes
     * @return ResultStatus result of function
     */
-    ResultStatus ReadRomFS(std::shared_ptr<FileUtil::IOFile>& romfs_file, u64& offset, u64& size) override;
+    ResultStatus ReadRomFS(std::shared_ptr<FileUtil::IOFile>& romfs_file, u64& offset,
+                           u64& size) override;
 private:
    std::string filename;
diff --git a/src/core/loader/elf.cpp b/src/core/loader/elf.cpp
index 69df94324..53c10a456 100644
--- a/src/core/loader/elf.cpp
+++ b/src/core/loader/elf.cpp
@@ -3,8 +3,8 @@
 // Refer to the license.txt file included.
 #include <cstring>
-#include <string>
 #include <memory>
+#include <string>
 #include "common/common_types.h"
 #include "common/file_util.h"
@@ -24,112 +24,111 @@ using Kernel::CodeSet;
 // File type
 enum ElfType {
-    ET_NONE   = 0,
+    ET_NONE = 0,
-    ET_REL    = 1,
+    ET_REL = 1,
-    ET_EXEC   = 2,
+    ET_EXEC = 2,
-    ET_DYN    = 3,
+    ET_DYN = 3,
-    ET_CORE   = 4,
+    ET_CORE = 4,
    ET_LOPROC = 0xFF00,
    ET_HIPROC = 0xFFFF,
 };
 // Machine/Architecture
 enum ElfMachine {
-    EM_NONE  = 0,
+    EM_NONE = 0,
-    EM_M32   = 1,
+    EM_M32 = 1,
    EM_SPARC = 2,
-    EM_386   = 3,
+    EM_386 = 3,
-    EM_68K   = 4,
+    EM_68K = 4,
-    EM_88K   = 5,
+    EM_88K = 5,
-    EM_860   = 7,
+    EM_860 = 7,
-    EM_MIPS  = 8
+    EM_MIPS = 8
 };
 // File version
-#define EV_NONE    0
+#define EV_NONE 0
 #define EV_CURRENT 1
 // Identification index
-#define EI_MAG0    0
+#define EI_MAG0 0
-#define EI_MAG1    1
+#define EI_MAG1 1
-#define EI_MAG2    2
+#define EI_MAG2 2
-#define EI_MAG3    3
+#define EI_MAG3 3
-#define EI_CLASS   4
+#define EI_CLASS 4
-#define EI_DATA    5
+#define EI_DATA 5
 #define EI_VERSION 6
-#define EI_PAD     7
+#define EI_PAD 7
 #define EI_NIDENT 16
 // Sections constants
 // Section types
-#define SHT_NULL            0
+#define SHT_NULL 0
-#define SHT_PROGBITS        1
+#define SHT_PROGBITS 1
-#define SHT_SYMTAB          2
+#define SHT_SYMTAB 2
-#define SHT_STRTAB          3
+#define SHT_STRTAB 3
-#define SHT_RELA            4
+#define SHT_RELA 4
-#define SHT_HASH            5
+#define SHT_HASH 5
-#define SHT_DYNAMIC         6
+#define SHT_DYNAMIC 6
-#define SHT_NOTE            7
+#define SHT_NOTE 7
-#define SHT_NOBITS          8
+#define SHT_NOBITS 8
-#define SHT_REL             9
+#define SHT_REL 9
-#define SHT_SHLIB          10
+#define SHT_SHLIB 10
-#define SHT_DYNSYM         11
+#define SHT_DYNSYM 11
 #define SHT_LOPROC 0x70000000
 #define SHT_HIPROC 0x7FFFFFFF
 #define SHT_LOUSER 0x80000000
 #define SHT_HIUSER 0xFFFFFFFF
 // Section flags
-enum ElfSectionFlags
+enum ElfSectionFlags {
-{
+    SHF_WRITE = 0x1,
-    SHF_WRITE     = 0x1,
+    SHF_ALLOC = 0x2,
-    SHF_ALLOC     = 0x2,
    SHF_EXECINSTR = 0x4,
-    SHF_MASKPROC  = 0xF0000000,
+    SHF_MASKPROC = 0xF0000000,
 };
 // Segment types
-#define PT_NULL             0
+#define PT_NULL 0
-#define PT_LOAD             1
+#define PT_LOAD 1
-#define PT_DYNAMIC          2
+#define PT_DYNAMIC 2
-#define PT_INTERP           3
+#define PT_INTERP 3
-#define PT_NOTE             4
+#define PT_NOTE 4
-#define PT_SHLIB            5
+#define PT_SHLIB 5
-#define PT_PHDR             6
+#define PT_PHDR 6
-#define PT_LOPROC  0x70000000
+#define PT_LOPROC 0x70000000
-#define PT_HIPROC  0x7FFFFFFF
+#define PT_HIPROC 0x7FFFFFFF
 // Segment flags
-#define PF_X               0x1
+#define PF_X 0x1
-#define PF_W               0x2
+#define PF_W 0x2
-#define PF_R               0x4
+#define PF_R 0x4
 #define PF_MASKPROC 0xF0000000
-typedef unsigned int   Elf32_Addr;
+typedef unsigned int Elf32_Addr;
 typedef unsigned short Elf32_Half;
-typedef unsigned int   Elf32_Off;
+typedef unsigned int Elf32_Off;
-typedef signed   int   Elf32_Sword;
+typedef signed int Elf32_Sword;
-typedef unsigned int   Elf32_Word;
+typedef unsigned int Elf32_Word;
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // ELF file header
 struct Elf32_Ehdr {
    unsigned char e_ident[EI_NIDENT];
-    Elf32_Half    e_type;
+    Elf32_Half e_type;
-    Elf32_Half    e_machine;
+    Elf32_Half e_machine;
-    Elf32_Word    e_version;
+    Elf32_Word e_version;
-    Elf32_Addr    e_entry;
+    Elf32_Addr e_entry;
-    Elf32_Off     e_phoff;
+    Elf32_Off e_phoff;
-    Elf32_Off     e_shoff;
+    Elf32_Off e_shoff;
-    Elf32_Word    e_flags;
+    Elf32_Word e_flags;
-    Elf32_Half    e_ehsize;
+    Elf32_Half e_ehsize;
-    Elf32_Half    e_phentsize;
+    Elf32_Half e_phentsize;
-    Elf32_Half    e_phnum;
+    Elf32_Half e_phnum;
-    Elf32_Half    e_shentsize;
+    Elf32_Half e_shentsize;
-    Elf32_Half    e_shnum;
+    Elf32_Half e_shnum;
-    Elf32_Half    e_shstrndx;
+    Elf32_Half e_shstrndx;
 };
 // Section header
@@ -138,7 +137,7 @@ struct Elf32_Shdr {
    Elf32_Word sh_type;
    Elf32_Word sh_flags;
    Elf32_Addr sh_addr;
-    Elf32_Off  sh_offset;
+    Elf32_Off sh_offset;
    Elf32_Word sh_size;
    Elf32_Word sh_link;
    Elf32_Word sh_info;
@@ -149,7 +148,7 @@ struct Elf32_Shdr {
 // Segment header
 struct Elf32_Phdr {
    Elf32_Word p_type;
-    Elf32_Off  p_offset;
+    Elf32_Off p_offset;
    Elf32_Addr p_vaddr;
    Elf32_Addr p_paddr;
    Elf32_Word p_filesz;
@@ -160,12 +159,12 @@ struct Elf32_Phdr {
 // Symbol table entry
 struct Elf32_Sym {
-    Elf32_Word    st_name;
+    Elf32_Word st_name;
-    Elf32_Addr    st_value;
+    Elf32_Addr st_value;
-    Elf32_Word    st_size;
+    Elf32_Word st_size;
    unsigned char st_info;
    unsigned char st_other;
-    Elf32_Half    st_shndx;
+    Elf32_Half st_shndx;
 };
 // Relocation entries
@@ -181,35 +180,51 @@ typedef int SectionID;
 class ElfReader {
 private:
-    char *base;
+    char* base;
-    u32 *base32;
+    u32* base32;
-    Elf32_Ehdr *header;
+    Elf32_Ehdr* header;
-    Elf32_Phdr *segments;
+    Elf32_Phdr* segments;
-    Elf32_Shdr *sections;
+    Elf32_Shdr* sections;
-    u32 *sectionAddrs;
+    u32* sectionAddrs;
    bool relocate;
    u32 entryPoint;
 public:
-    ElfReader(void *ptr);
+    ElfReader(void* ptr);
-    u32 Read32(int off) const { return base32[off >> 2]; }
+    u32 Read32(int off) const {
+        return base32[off >> 2];
+    }
    // Quick accessors
-    ElfType GetType() const { return (ElfType)(header->e_type); }
+    ElfType GetType() const {
-    ElfMachine GetMachine() const { return (ElfMachine)(header->e_machine); }
+        return (ElfType)(header->e_type);
-    u32 GetEntryPoint() const { return entryPoint; }
+    }
-    u32 GetFlags() const { return (u32)(header->e_flags); }
+    ElfMachine GetMachine() const {
+        return (ElfMachine)(header->e_machine);
+    }
+    u32 GetEntryPoint() const {
+        return entryPoint;
+    }
+    u32 GetFlags() const {
+        return (u32)(header->e_flags);
+    }
    SharedPtr<CodeSet> LoadInto(u32 vaddr);
    bool LoadSymbols();
-    int GetNumSegments() const { return (int)(header->e_phnum); }
+    int GetNumSegments() const {
-    int GetNumSections() const { return (int)(header->e_shnum); }
+        return (int)(header->e_phnum);
-    const u8 *GetPtr(int offset) const { return (u8*)base + offset; }
+    }
-    const char *GetSectionName(int section) const;
+    int GetNumSections() const {
-    const u8 *GetSectionDataPtr(int section) const {
+        return (int)(header->e_shnum);
+    }
+    const u8* GetPtr(int offset) const {
+        return (u8*)base + offset;
+    }
+    const char* GetSectionName(int section) const;
+    const u8* GetSectionDataPtr(int section) const {
        if (section < 0 || section >= header->e_shnum)
            return nullptr;
        if (sections[section].sh_type != SHT_NOBITS)
@@ -220,19 +235,23 @@ public:
    bool IsCodeSection(int section) const {
        return sections[section].sh_type == SHT_PROGBITS;
    }
-    const u8 *GetSegmentPtr(int segment) {
+    const u8* GetSegmentPtr(int segment) {
        return GetPtr(segments[segment].p_offset);
    }
-    u32 GetSectionAddr(SectionID section) const { return sectionAddrs[section]; }
+    u32 GetSectionAddr(SectionID section) const {
-    unsigned int GetSectionSize(SectionID section) const { return sections[section].sh_size; }
+        return sectionAddrs[section];
-    SectionID GetSectionByName(const char *name, int firstSection = 0) const; //-1 for not found
+    }
+    unsigned int GetSectionSize(SectionID section) const {
+        return sections[section].sh_size;
+    }
+    SectionID GetSectionByName(const char* name, int firstSection = 0) const; //-1 for not found
    bool DidRelocate() const {
        return relocate;
    }
 };
-ElfReader::ElfReader(void *ptr) {
+ElfReader::ElfReader(void* ptr) {
    base = (char*)ptr;
    base32 = (u32*)ptr;
    header = (Elf32_Ehdr*)ptr;
@@ -245,7 +264,7 @@ ElfReader::ElfReader(void *ptr) {
    LoadSymbols();
 }
-const char *ElfReader::GetSectionName(int section) const {
+const char* ElfReader::GetSectionName(int section) const {
    if (sections[section].sh_type == SHT_NULL)
        return nullptr;
@@ -303,12 +322,15 @@ SharedPtr<CodeSet> ElfReader::LoadInto(u32 vaddr) {
            } else if (permission_flags == (PF_R | PF_W)) {
                codeset_segment = &codeset->data;
            } else {
-                LOG_ERROR(Loader, "Unexpected ELF PT_LOAD segment id %u with flags %X", i, p->p_flags);
+                LOG_ERROR(Loader, "Unexpected ELF PT_LOAD segment id %u with flags %X", i,
+                          p->p_flags);
                continue;
            }
            if (codeset_segment->size != 0) {
-                LOG_ERROR(Loader, "ELF has more than one segment of the same type. Skipping extra segment (id %i)", i);
+                LOG_ERROR(Loader, "ELF has more than one segment of the same type. Skipping extra "
+                                  "segment (id %i)",
+                          i);
                continue;
            }
@@ -332,9 +354,9 @@ SharedPtr<CodeSet> ElfReader::LoadInto(u32 vaddr) {
    return codeset;
 }
-SectionID ElfReader::GetSectionByName(const char *name, int firstSection) const {
+SectionID ElfReader::GetSectionByName(const char* name, int firstSection) const {
    for (int i = firstSection; i < header->e_shnum; i++) {
-        const char *secname = GetSectionName(i);
+        const char* secname = GetSectionName(i);
        if (secname != nullptr && strcmp(name, secname) == 0)
            return i;
@@ -347,9 +369,9 @@ bool ElfReader::LoadSymbols() {
    SectionID sec = GetSectionByName(".symtab");
    if (sec != -1) {
        int stringSection = sections[sec].sh_link;
-        const char *stringBase = reinterpret_cast<const char*>(GetSectionDataPtr(stringSection));
+        const char* stringBase = reinterpret_cast<const char*>(GetSectionDataPtr(stringSection));
-        //We have a symbol table!
+        // We have a symbol table!
        const Elf32_Sym* symtab = reinterpret_cast<const Elf32_Sym*>(GetSectionDataPtr(sec));
        unsigned int numSymbols = sections[sec].sh_size / sizeof(Elf32_Sym);
        for (unsigned sym = 0; sym < numSymbols; sym++) {
@@ -359,7 +381,7 @@ bool ElfReader::LoadSymbols() {
            int type = symtab[sym].st_info & 0xF;
-            const char *name = stringBase + symtab[sym].st_name;
+            const char* name = stringBase + symtab[sym].st_name;
            Symbols::Add(symtab[sym].st_value, name, size, type);
@@ -411,7 +433,8 @@ ResultStatus AppLoader_ELF::Load() {
    Kernel::g_current_process->address_mappings = default_address_mappings;
    // Attach the default resource limit (APPLICATION) to the process
-    Kernel::g_current_process->resource_limit = Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
+    Kernel::g_current_process->resource_limit =
+        Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
    Kernel::g_current_process->Run(48, Kernel::DEFAULT_STACK_SIZE);
diff --git a/src/core/loader/elf.h b/src/core/loader/elf.h
index cb3724f9d..0b1456c64 100644
--- a/src/core/loader/elf.h
+++ b/src/core/loader/elf.h
@@ -18,7 +18,8 @@ namespace Loader {
 class AppLoader_ELF final : public AppLoader {
 public:
    AppLoader_ELF(FileUtil::IOFile&& file, std::string filename)
-        : AppLoader(std::move(file)), filename(std::move(filename)) { }
+        : AppLoader(std::move(file)), filename(std::move(filename)) {
+    }
    /**
     * Returns the type of the file
diff --git a/src/core/loader/loader.cpp b/src/core/loader/loader.cpp
index 9719d30d5..b392bf544 100644
--- a/src/core/loader/loader.cpp
+++ b/src/core/loader/loader.cpp
@@ -18,17 +18,17 @@
 namespace Loader {
 const std::initializer_list<Kernel::AddressMapping> default_address_mappings = {
-    { 0x1FF50000,   0x8000, true  }, // part of DSP RAM
+    {0x1FF50000, 0x8000, true},    // part of DSP RAM
-    { 0x1FF70000,   0x8000, true  }, // part of DSP RAM
+    {0x1FF70000, 0x8000, true},    // part of DSP RAM
-    { 0x1F000000, 0x600000, false }, // entire VRAM
+    {0x1F000000, 0x600000, false}, // entire VRAM
 };
 FileType IdentifyFile(FileUtil::IOFile& file) {
    FileType type;
-#define CHECK_TYPE(loader) \
+#define CHECK_TYPE(loader)                                                                         \
-    type = AppLoader_##loader::IdentifyType(file); \
+    type = AppLoader_##loader::IdentifyType(file);                                                 \
-    if (FileType::Error != type) \
+    if (FileType::Error != type)                                                                   \
        return type;
    CHECK_TYPE(THREEDSX)
@@ -100,7 +100,8 @@ const char* GetFileTypeString(FileType type) {
 * @return std::unique_ptr<AppLoader> a pointer to a loader object;  nullptr for unsupported type
 */
 static std::unique_ptr<AppLoader> GetFileLoader(FileUtil::IOFile&& file, FileType type,
-    const std::string& filename, const std::string& filepath) {
+                                                const std::string& filename,
+                                                const std::string& filepath) {
    switch (type) {
    // 3DSX file format.
diff --git a/src/core/loader/loader.h b/src/core/loader/loader.h
index 77d87afe1..5f48d2ffe 100644
--- a/src/core/loader/loader.h
+++ b/src/core/loader/loader.h
@@ -30,7 +30,7 @@ enum class FileType {
    CXI,
    CIA,
    ELF,
-    THREEDSX, //3DSX
+    THREEDSX, // 3DSX
 };
 /**
@@ -81,8 +81,10 @@ constexpr u32 MakeMagic(char a, char b, char c, char d) {
 /// Interface for loading an application
 class AppLoader : NonCopyable {
 public:
-    AppLoader(FileUtil::IOFile&& file) : file(std::move(file)) { }
+    AppLoader(FileUtil::IOFile&& file) : file(std::move(file)) {
-    virtual ~AppLoader() { }
+    }
+    virtual ~AppLoader() {
+    }
    /**
     * Returns the type of this file
@@ -140,7 +142,8 @@ public:
     * @param size The size of the romfs
     * @return ResultStatus result of function
     */
-    virtual ResultStatus ReadRomFS(std::shared_ptr<FileUtil::IOFile>& romfs_file, u64& offset, u64& size) {
+    virtual ResultStatus ReadRomFS(std::shared_ptr<FileUtil::IOFile>& romfs_file, u64& offset,
+                                   u64& size) {
        return ResultStatus::ErrorNotImplemented;
    }
diff --git a/src/core/loader/ncch.cpp b/src/core/loader/ncch.cpp
index fca091ff9..5b996d671 100644
--- a/src/core/loader/ncch.cpp
+++ b/src/core/loader/ncch.cpp
@@ -22,8 +22,8 @@
 namespace Loader {
-static const int kMaxSections = 8;        ///< Maximum number of sections (files) in an ExeFs
+static const int kMaxSections = 8;   ///< Maximum number of sections (files) in an ExeFs
-static const int kBlockSize   = 0x200;    ///< Size of ExeFS blocks (in bytes)
+static const int kBlockSize = 0x200; ///< Size of ExeFS blocks (in bytes)
 /**
 * Get the decompressed size of an LZSS compressed ExeFS file
@@ -44,7 +44,8 @@ static u32 LZSS_GetDecompressedSize(const u8* buffer, u32 size) {
 * @param decompressed_size Size of decompressed buffer
 * @return True on success, otherwise false
 */
-static bool LZSS_Decompress(const u8* compressed, u32 compressed_size, u8* decompressed, u32 decompressed_size) {
+static bool LZSS_Decompress(const u8* compressed, u32 compressed_size, u8* decompressed,
+                            u32 decompressed_size) {
    const u8* footer = compressed + compressed_size - 8;
    u32 buffer_top_and_bottom = *reinterpret_cast<const u32*>(footer);
    u32 out = decompressed_size;
@@ -55,7 +56,7 @@ static bool LZSS_Decompress(const u8* compressed, u32 compressed_size, u8* decom
    memcpy(decompressed, compressed, compressed_size);
    while (index > stop_index) {
-       u8 control = compressed[--index];
+        u8 control = compressed[--index];
        for (unsigned i = 0; i < 8; i++) {
            if (index <= stop_index)
@@ -128,7 +129,7 @@ ResultStatus AppLoader_NCCH::LoadExec() {
    std::vector<u8> code;
    if (ResultStatus::Success == ReadCode(code)) {
        std::string process_name = Common::StringFromFixedZeroTerminatedBuffer(
-                (const char*)exheader_header.codeset_info.name, 8);
+            (const char*)exheader_header.codeset_info.name, 8);
        SharedPtr<CodeSet> codeset = CodeSet::Create(process_name, ncch_header.program_id);
@@ -147,7 +148,8 @@ ResultStatus AppLoader_NCCH::LoadExec() {
        codeset->data.offset = codeset->rodata.offset + codeset->rodata.size;
        codeset->data.addr = exheader_header.codeset_info.data.address;
-        codeset->data.size = exheader_header.codeset_info.data.num_max_pages * Memory::PAGE_SIZE + bss_page_size;
+        codeset->data.size =
+            exheader_header.codeset_info.data.num_max_pages * Memory::PAGE_SIZE + bss_page_size;
        codeset->entrypoint = codeset->code.addr;
        codeset->memory = std::make_shared<std::vector<u8>>(std::move(code));
@@ -155,15 +157,18 @@ ResultStatus AppLoader_NCCH::LoadExec() {
        Kernel::g_current_process = Kernel::Process::Create(std::move(codeset));
        // Attach a resource limit to the process based on the resource limit category
-        Kernel::g_current_process->resource_limit = Kernel::ResourceLimit::GetForCategory(
+        Kernel::g_current_process->resource_limit =
-            static_cast<Kernel::ResourceLimitCategory>(exheader_header.arm11_system_local_caps.resource_limit_category));
+            Kernel::ResourceLimit::GetForCategory(static_cast<Kernel::ResourceLimitCategory>(
+                exheader_header.arm11_system_local_caps.resource_limit_category));
        // Set the default CPU core for this process
-        Kernel::g_current_process->ideal_processor = exheader_header.arm11_system_local_caps.ideal_processor;
+        Kernel::g_current_process->ideal_processor =
+            exheader_header.arm11_system_local_caps.ideal_processor;
        // Copy data while converting endianess
        std::array<u32, ARRAY_SIZE(exheader_header.arm11_kernel_caps.descriptors)> kernel_caps;
-        std::copy_n(exheader_header.arm11_kernel_caps.descriptors, kernel_caps.size(), begin(kernel_caps));
+        std::copy_n(exheader_header.arm11_kernel_caps.descriptors, kernel_caps.size(),
+                    begin(kernel_caps));
        Kernel::g_current_process->ParseKernelCaps(kernel_caps.data(), kernel_caps.size());
        s32 priority = exheader_header.arm11_system_local_caps.priority;
@@ -192,7 +197,8 @@ ResultStatus AppLoader_NCCH::LoadSectionExeFS(const char* name, std::vector<u8>&
            LOG_DEBUG(Loader, "%d - offset: 0x%08X, size: 0x%08X, name: %s", section_number,
                      section.offset, section.size, section.name);
-            s64 section_offset = (section.offset + exefs_offset + sizeof(ExeFs_Header) + ncch_offset);
+            s64 section_offset =
+                (section.offset + exefs_offset + sizeof(ExeFs_Header) + ncch_offset);
            file.Seek(section_offset, SEEK_SET);
            if (strcmp(section.name, ".code") == 0 && is_compressed) {
@@ -254,25 +260,25 @@ ResultStatus AppLoader_NCCH::LoadExeFS() {
    if (file.ReadBytes(&exheader_header, sizeof(ExHeader_Header)) != sizeof(ExHeader_Header))
        return ResultStatus::Error;
-    is_compressed           = (exheader_header.codeset_info.flags.flag & 1) == 1;
+    is_compressed = (exheader_header.codeset_info.flags.flag & 1) == 1;
-    entry_point             = exheader_header.codeset_info.text.address;
+    entry_point = exheader_header.codeset_info.text.address;
-    code_size               = exheader_header.codeset_info.text.code_size;
+    code_size = exheader_header.codeset_info.text.code_size;
-    stack_size              = exheader_header.codeset_info.stack_size;
+    stack_size = exheader_header.codeset_info.stack_size;
-    bss_size                = exheader_header.codeset_info.bss_size;
+    bss_size = exheader_header.codeset_info.bss_size;
-    core_version            = exheader_header.arm11_system_local_caps.core_version;
+    core_version = exheader_header.arm11_system_local_caps.core_version;
-    priority                = exheader_header.arm11_system_local_caps.priority;
+    priority = exheader_header.arm11_system_local_caps.priority;
    resource_limit_category = exheader_header.arm11_system_local_caps.resource_limit_category;
-    LOG_INFO(Loader,  "Name:                        %s"    , exheader_header.codeset_info.name);
+    LOG_INFO(Loader, "Name:                        %s", exheader_header.codeset_info.name);
-    LOG_INFO(Loader,  "Program ID:                  %016llX" , ncch_header.program_id);
+    LOG_INFO(Loader, "Program ID:                  %016llX", ncch_header.program_id);
-    LOG_DEBUG(Loader, "Code compressed:             %s"    , is_compressed ? "yes" : "no");
+    LOG_DEBUG(Loader, "Code compressed:             %s", is_compressed ? "yes" : "no");
    LOG_DEBUG(Loader, "Entry point:                 0x%08X", entry_point);
    LOG_DEBUG(Loader, "Code size:                   0x%08X", code_size);
    LOG_DEBUG(Loader, "Stack size:                  0x%08X", stack_size);
    LOG_DEBUG(Loader, "Bss size:                    0x%08X", bss_size);
-    LOG_DEBUG(Loader, "Core version:                %d"    , core_version);
+    LOG_DEBUG(Loader, "Core version:                %d", core_version);
-    LOG_DEBUG(Loader, "Thread priority:             0x%X"  , priority);
+    LOG_DEBUG(Loader, "Thread priority:             0x%X", priority);
-    LOG_DEBUG(Loader, "Resource limit category:     %d"    , resource_limit_category);
+    LOG_DEBUG(Loader, "Resource limit category:     %d", resource_limit_category);
    if (exheader_header.arm11_system_local_caps.program_id != ncch_header.program_id) {
        LOG_ERROR(Loader, "ExHeader Program ID mismatch: the ROM is probably encrypted.");
@@ -309,7 +315,8 @@ ResultStatus AppLoader_NCCH::Load() {
    if (ResultStatus::Success != result)
        return result;
-    Service::FS::RegisterArchiveType(std::make_unique<FileSys::ArchiveFactory_RomFS>(*this), Service::FS::ArchiveIdCode::RomFS);
+    Service::FS::RegisterArchiveType(std::make_unique<FileSys::ArchiveFactory_RomFS>(*this),
+                                     Service::FS::ArchiveIdCode::RomFS);
    return ResultStatus::Success;
 }
@@ -329,7 +336,8 @@ ResultStatus AppLoader_NCCH::ReadLogo(std::vector<u8>& buffer) {
    return LoadSectionExeFS("logo", buffer);
 }
-ResultStatus AppLoader_NCCH::ReadRomFS(std::shared_ptr<FileUtil::IOFile>& romfs_file, u64& offset, u64& size) {
+ResultStatus AppLoader_NCCH::ReadRomFS(std::shared_ptr<FileUtil::IOFile>& romfs_file, u64& offset,
+                                       u64& size) {
    if (!file.IsOpen())
        return ResultStatus::Error;
@@ -341,7 +349,7 @@ ResultStatus AppLoader_NCCH::ReadRomFS(std::shared_ptr<FileUtil::IOFile>& romfs_
        LOG_DEBUG(Loader, "RomFS offset:           0x%08X", romfs_offset);
        LOG_DEBUG(Loader, "RomFS size:             0x%08X", romfs_size);
-        if (file.GetSize () < romfs_offset + romfs_size)
+        if (file.GetSize() < romfs_offset + romfs_size)
            return ResultStatus::Error;
        // We reopen the file, to allow its position to be independent from file's
diff --git a/src/core/loader/ncch.h b/src/core/loader/ncch.h
index 75609ee57..0cd70f70c 100644
--- a/src/core/loader/ncch.h
+++ b/src/core/loader/ncch.h
@@ -164,7 +164,8 @@ namespace Loader {
 class AppLoader_NCCH final : public AppLoader {
 public:
    AppLoader_NCCH(FileUtil::IOFile&& file, const std::string& filepath)
-        : AppLoader(std::move(file)), filepath(filepath) { }
+        : AppLoader(std::move(file)), filepath(filepath) {
+    }
    /**
     * Returns the type of the file
@@ -222,10 +223,10 @@ public:
     * @param size       Size of the RomFS in bytes
     * @return ResultStatus result of function
     */
-    ResultStatus ReadRomFS(std::shared_ptr<FileUtil::IOFile>& romfs_file, u64& offset, u64& size) override;
+    ResultStatus ReadRomFS(std::shared_ptr<FileUtil::IOFile>& romfs_file, u64& offset,
+                           u64& size) override;
 private:
    /**
     * Reads an application ExeFS section of an NCCH file into AppLoader (e.g. .code, .logo, etc.)
     * @param name Name of section to read out of NCCH file
@@ -246,24 +247,24 @@ private:
     */
    ResultStatus LoadExeFS();
-    bool            is_exefs_loaded = false;
+    bool is_exefs_loaded = false;
-    bool            is_compressed = false;
+    bool is_compressed = false;
-    u32             entry_point = 0;
+    u32 entry_point = 0;
-    u32             code_size = 0;
+    u32 code_size = 0;
-    u32             stack_size = 0;
+    u32 stack_size = 0;
-    u32             bss_size = 0;
+    u32 bss_size = 0;
-    u32             core_version = 0;
+    u32 core_version = 0;
-    u8              priority = 0;
+    u8 priority = 0;
-    u8              resource_limit_category = 0;
+    u8 resource_limit_category = 0;
-    u32             ncch_offset = 0; // Offset to NCCH header, can be 0 or after NCSD header
+    u32 ncch_offset = 0; // Offset to NCCH header, can be 0 or after NCSD header
-    u32             exefs_offset = 0;
+    u32 exefs_offset = 0;
-    NCCH_Header     ncch_header;
+    NCCH_Header ncch_header;
-    ExeFs_Header    exefs_header;
+    ExeFs_Header exefs_header;
    ExHeader_Header exheader_header;
-    std::string     filepath;
+    std::string filepath;
 };
 } // namespace Loader
diff --git a/src/core/loader/smdh.h b/src/core/loader/smdh.h
index 2011abda2..ab665ea82 100644
--- a/src/core/loader/smdh.h
+++ b/src/core/loader/smdh.h
@@ -56,7 +56,7 @@ struct SMDH {
        Italian = 4,
        Spanish = 5,
        SimplifiedChinese = 6,
-        Korean= 7,
+        Korean = 7,
        Dutch = 8,
        Portuguese = 9,
        Russian = 10,
diff --git a/src/core/memory.cpp b/src/core/memory.cpp
index 9aa8c4e5a..4de510fe5 100644
--- a/src/core/memory.cpp
+++ b/src/core/memory.cpp
@@ -25,11 +25,13 @@ enum class PageType {
    Unmapped,
    /// Page is mapped to regular memory. This is the only type you can get pointers to.
    Memory,
-    /// Page is mapped to regular memory, but also needs to check for rasterizer cache flushing and invalidation
+    /// Page is mapped to regular memory, but also needs to check for rasterizer cache flushing and
+    /// invalidation
    RasterizerCachedMemory,
    /// Page is mapped to a I/O region. Writing and reading to this page is handled by functions.
    Special,
-    /// Page is mapped to a I/O region, but also needs to check for rasterizer cache flushing and invalidation
+    /// Page is mapped to a I/O region, but also needs to check for rasterizer cache flushing and
+    /// invalidation
    RasterizerCachedSpecial,
 };
@@ -55,7 +57,8 @@ struct PageTable {
    std::array<u8*, NUM_ENTRIES> pointers;
    /**
-     * Contains MMIO handlers that back memory regions whose entries in the `attribute` array is of type `Special`.
+     * Contains MMIO handlers that back memory regions whose entries in the `attribute` array is of
+     * type `Special`.
     */
    std::vector<SpecialRegion> special_regions;
@@ -78,17 +81,20 @@ static PageTable main_page_table;
 static PageTable* current_page_table = &main_page_table;
 static void MapPages(u32 base, u32 size, u8* memory, PageType type) {
-    LOG_DEBUG(HW_Memory, "Mapping %p onto %08X-%08X", memory, base * PAGE_SIZE, (base + size) * PAGE_SIZE);
+    LOG_DEBUG(HW_Memory, "Mapping %p onto %08X-%08X", memory, base * PAGE_SIZE,
+              (base + size) * PAGE_SIZE);
    u32 end = base + size;
    while (base != end) {
        ASSERT_MSG(base < PageTable::NUM_ENTRIES, "out of range mapping at %08X", base);
-        // Since pages are unmapped on shutdown after video core is shutdown, the renderer may be null here
+        // Since pages are unmapped on shutdown after video core is shutdown, the renderer may be
+        // null here
        if (current_page_table->attributes[base] == PageType::RasterizerCachedMemory ||
            current_page_table->attributes[base] == PageType::RasterizerCachedSpecial) {
-            RasterizerFlushAndInvalidateRegion(VirtualToPhysicalAddress(base << PAGE_BITS), PAGE_SIZE);
+            RasterizerFlushAndInvalidateRegion(VirtualToPhysicalAddress(base << PAGE_BITS),
+                                               PAGE_SIZE);
        }
        current_page_table->attributes[base] = type;
@@ -162,7 +168,7 @@ static MMIORegionPointer GetMMIOHandler(VAddr vaddr) {
    return nullptr; // Should never happen
 }
-template<typename T>
+template <typename T>
 T ReadMMIO(MMIORegionPointer mmio_handler, VAddr addr);
 template <typename T>
@@ -183,8 +189,7 @@ T Read(const VAddr vaddr) {
    case PageType::Memory:
        ASSERT_MSG(false, "Mapped memory page without a pointer @ %08X", vaddr);
        break;
-    case PageType::RasterizerCachedMemory:
+    case PageType::RasterizerCachedMemory: {
-    {
        RasterizerFlushRegion(VirtualToPhysicalAddress(vaddr), sizeof(T));
        T value;
@@ -193,8 +198,7 @@ T Read(const VAddr vaddr) {
    }
    case PageType::Special:
        return ReadMMIO<T>(GetMMIOHandler(vaddr), vaddr);
-    case PageType::RasterizerCachedSpecial:
+    case PageType::RasterizerCachedSpecial: {
-    {
        RasterizerFlushRegion(VirtualToPhysicalAddress(vaddr), sizeof(T));
        return ReadMMIO<T>(GetMMIOHandler(vaddr), vaddr);
@@ -204,7 +208,7 @@ T Read(const VAddr vaddr) {
    }
 }
-template<typename T>
+template <typename T>
 void WriteMMIO(MMIORegionPointer mmio_handler, VAddr addr, const T data);
 template <typename T>
@@ -219,13 +223,13 @@ void Write(const VAddr vaddr, const T data) {
    PageType type = current_page_table->attributes[vaddr >> PAGE_BITS];
    switch (type) {
    case PageType::Unmapped:
-        LOG_ERROR(HW_Memory, "unmapped Write%lu 0x%08X @ 0x%08X", sizeof(data) * 8, (u32) data, vaddr);
+        LOG_ERROR(HW_Memory, "unmapped Write%lu 0x%08X @ 0x%08X", sizeof(data) * 8, (u32)data,
+                  vaddr);
        return;
    case PageType::Memory:
        ASSERT_MSG(false, "Mapped memory page without a pointer @ %08X", vaddr);
        break;
-    case PageType::RasterizerCachedMemory:
+    case PageType::RasterizerCachedMemory: {
-    {
        RasterizerFlushAndInvalidateRegion(VirtualToPhysicalAddress(vaddr), sizeof(T));
        std::memcpy(GetPointerFromVMA(vaddr), &data, sizeof(T));
@@ -234,8 +238,7 @@ void Write(const VAddr vaddr, const T data) {
    case PageType::Special:
        WriteMMIO<T>(GetMMIOHandler(vaddr), vaddr, data);
        break;
-    case PageType::RasterizerCachedSpecial:
+    case PageType::RasterizerCachedSpecial: {
-    {
        RasterizerFlushAndInvalidateRegion(VirtualToPhysicalAddress(vaddr), sizeof(T));
        WriteMMIO<T>(GetMMIOHandler(vaddr), vaddr, data);
@@ -310,7 +313,8 @@ void RasterizerMarkRegionCached(PAddr start, u32 size, int count_delta) {
    for (unsigned i = 0; i < num_pages; ++i) {
        VAddr vaddr = PhysicalToVirtualAddress(paddr);
        u8& res_count = current_page_table->cached_res_count[vaddr >> PAGE_BITS];
-        ASSERT_MSG(count_delta <= UINT8_MAX - res_count, "Rasterizer resource cache counter overflow!");
+        ASSERT_MSG(count_delta <= UINT8_MAX - res_count,
+                   "Rasterizer resource cache counter overflow!");
        ASSERT_MSG(count_delta >= -res_count, "Rasterizer resource cache counter underflow!");
        // Switch page type to cached if now cached
@@ -337,7 +341,8 @@ void RasterizerMarkRegionCached(PAddr start, u32 size, int count_delta) {
            switch (page_type) {
            case PageType::RasterizerCachedMemory:
                page_type = PageType::Memory;
-                current_page_table->pointers[vaddr >> PAGE_BITS] = GetPointerFromVMA(vaddr & ~PAGE_MASK);
+                current_page_table->pointers[vaddr >> PAGE_BITS] =
+                    GetPointerFromVMA(vaddr & ~PAGE_MASK);
                break;
            case PageType::RasterizerCachedSpecial:
                page_type = PageType::Special;
@@ -389,7 +394,8 @@ void ReadBlock(const VAddr src_addr, void* dest_buffer, const size_t size) {
        switch (current_page_table->attributes[page_index]) {
        case PageType::Unmapped: {
-            LOG_ERROR(HW_Memory, "unmapped ReadBlock @ 0x%08X (start address = 0x%08X, size = %zu)", current_vaddr, src_addr, size);
+            LOG_ERROR(HW_Memory, "unmapped ReadBlock @ 0x%08X (start address = 0x%08X, size = %zu)",
+                      current_vaddr, src_addr, size);
            std::memset(dest_buffer, 0, copy_amount);
            break;
        }
@@ -458,7 +464,9 @@ void WriteBlock(const VAddr dest_addr, const void* src_buffer, const size_t size
        switch (current_page_table->attributes[page_index]) {
        case PageType::Unmapped: {
-            LOG_ERROR(HW_Memory, "unmapped WriteBlock @ 0x%08X (start address = 0x%08X, size = %zu)", current_vaddr, dest_addr, size);
+            LOG_ERROR(HW_Memory,
+                      "unmapped WriteBlock @ 0x%08X (start address = 0x%08X, size = %zu)",
+                      current_vaddr, dest_addr, size);
            break;
        }
        case PageType::Memory: {
@@ -475,7 +483,8 @@ void WriteBlock(const VAddr dest_addr, const void* src_buffer, const size_t size
            break;
        }
        case PageType::RasterizerCachedMemory: {
-            RasterizerFlushAndInvalidateRegion(VirtualToPhysicalAddress(current_vaddr), copy_amount);
+            RasterizerFlushAndInvalidateRegion(VirtualToPhysicalAddress(current_vaddr),
+                                               copy_amount);
            std::memcpy(GetPointerFromVMA(current_vaddr), src_buffer, copy_amount);
            break;
@@ -483,7 +492,8 @@ void WriteBlock(const VAddr dest_addr, const void* src_buffer, const size_t size
        case PageType::RasterizerCachedSpecial: {
            DEBUG_ASSERT(GetMMIOHandler(current_vaddr));
-            RasterizerFlushAndInvalidateRegion(VirtualToPhysicalAddress(current_vaddr), copy_amount);
+            RasterizerFlushAndInvalidateRegion(VirtualToPhysicalAddress(current_vaddr),
+                                               copy_amount);
            GetMMIOHandler(current_vaddr)->WriteBlock(current_vaddr, src_buffer, copy_amount);
            break;
@@ -512,7 +522,8 @@ void ZeroBlock(const VAddr dest_addr, const size_t size) {
        switch (current_page_table->attributes[page_index]) {
        case PageType::Unmapped: {
-            LOG_ERROR(HW_Memory, "unmapped ZeroBlock @ 0x%08X (start address = 0x%08X, size = %zu)", current_vaddr, dest_addr, size);
+            LOG_ERROR(HW_Memory, "unmapped ZeroBlock @ 0x%08X (start address = 0x%08X, size = %zu)",
+                      current_vaddr, dest_addr, size);
            break;
        }
        case PageType::Memory: {
@@ -529,7 +540,8 @@ void ZeroBlock(const VAddr dest_addr, const size_t size) {
            break;
        }
        case PageType::RasterizerCachedMemory: {
-            RasterizerFlushAndInvalidateRegion(VirtualToPhysicalAddress(current_vaddr), copy_amount);
+            RasterizerFlushAndInvalidateRegion(VirtualToPhysicalAddress(current_vaddr),
+                                               copy_amount);
            std::memset(GetPointerFromVMA(current_vaddr), 0, copy_amount);
            break;
@@ -537,7 +549,8 @@ void ZeroBlock(const VAddr dest_addr, const size_t size) {
        case PageType::RasterizerCachedSpecial: {
            DEBUG_ASSERT(GetMMIOHandler(current_vaddr));
-            RasterizerFlushAndInvalidateRegion(VirtualToPhysicalAddress(current_vaddr), copy_amount);
+            RasterizerFlushAndInvalidateRegion(VirtualToPhysicalAddress(current_vaddr),
+                                               copy_amount);
            GetMMIOHandler(current_vaddr)->WriteBlock(current_vaddr, zeros.data(), copy_amount);
            break;
@@ -563,7 +576,8 @@ void CopyBlock(VAddr dest_addr, VAddr src_addr, const size_t size) {
        switch (current_page_table->attributes[page_index]) {
        case PageType::Unmapped: {
-            LOG_ERROR(HW_Memory, "unmapped CopyBlock @ 0x%08X (start address = 0x%08X, size = %zu)", current_vaddr, src_addr, size);
+            LOG_ERROR(HW_Memory, "unmapped CopyBlock @ 0x%08X (start address = 0x%08X, size = %zu)",
+                      current_vaddr, src_addr, size);
            ZeroBlock(dest_addr, copy_amount);
            break;
        }
@@ -609,42 +623,42 @@ void CopyBlock(VAddr dest_addr, VAddr src_addr, const size_t size) {
    }
 }
-template<>
+template <>
 u8 ReadMMIO<u8>(MMIORegionPointer mmio_handler, VAddr addr) {
    return mmio_handler->Read8(addr);
 }
-template<>
+template <>
 u16 ReadMMIO<u16>(MMIORegionPointer mmio_handler, VAddr addr) {
    return mmio_handler->Read16(addr);
 }
-template<>
+template <>
 u32 ReadMMIO<u32>(MMIORegionPointer mmio_handler, VAddr addr) {
    return mmio_handler->Read32(addr);
 }
-template<>
+template <>
 u64 ReadMMIO<u64>(MMIORegionPointer mmio_handler, VAddr addr) {
    return mmio_handler->Read64(addr);
 }
-template<>
+template <>
 void WriteMMIO<u8>(MMIORegionPointer mmio_handler, VAddr addr, const u8 data) {
    mmio_handler->Write8(addr, data);
 }
-template<>
+template <>
 void WriteMMIO<u16>(MMIORegionPointer mmio_handler, VAddr addr, const u16 data) {
    mmio_handler->Write16(addr, data);
 }
-template<>
+template <>
 void WriteMMIO<u32>(MMIORegionPointer mmio_handler, VAddr addr, const u32 data) {
    mmio_handler->Write32(addr, data);
 }
-template<>
+template <>
 void WriteMMIO<u64>(MMIORegionPointer mmio_handler, VAddr addr, const u64 data) {
    mmio_handler->Write64(addr, data);
 }
diff --git a/src/core/memory.h b/src/core/memory.h
index cad845385..7d60ccdf1 100644
--- a/src/core/memory.h
+++ b/src/core/memory.h
@@ -22,92 +22,93 @@ const int PAGE_BITS = 12;
 /// Physical memory regions as seen from the ARM11
 enum : PAddr {
    /// IO register area
-    IO_AREA_PADDR     = 0x10100000,
+    IO_AREA_PADDR = 0x10100000,
-    IO_AREA_SIZE      = 0x01000000, ///< IO area size (16MB)
+    IO_AREA_SIZE = 0x01000000, ///< IO area size (16MB)
    IO_AREA_PADDR_END = IO_AREA_PADDR + IO_AREA_SIZE,
    /// MPCore internal memory region
-    MPCORE_RAM_PADDR     = 0x17E00000,
+    MPCORE_RAM_PADDR = 0x17E00000,
-    MPCORE_RAM_SIZE      = 0x00002000, ///< MPCore internal memory size (8KB)
+    MPCORE_RAM_SIZE = 0x00002000, ///< MPCore internal memory size (8KB)
    MPCORE_RAM_PADDR_END = MPCORE_RAM_PADDR + MPCORE_RAM_SIZE,
    /// Video memory
-    VRAM_PADDR     = 0x18000000,
+    VRAM_PADDR = 0x18000000,
-    VRAM_SIZE      = 0x00600000, ///< VRAM size (6MB)
+    VRAM_SIZE = 0x00600000, ///< VRAM size (6MB)
    VRAM_PADDR_END = VRAM_PADDR + VRAM_SIZE,
    /// DSP memory
-    DSP_RAM_PADDR     = 0x1FF00000,
+    DSP_RAM_PADDR = 0x1FF00000,
-    DSP_RAM_SIZE      = 0x00080000, ///< DSP memory size (512KB)
+    DSP_RAM_SIZE = 0x00080000, ///< DSP memory size (512KB)
    DSP_RAM_PADDR_END = DSP_RAM_PADDR + DSP_RAM_SIZE,
    /// AXI WRAM
-    AXI_WRAM_PADDR     = 0x1FF80000,
+    AXI_WRAM_PADDR = 0x1FF80000,
-    AXI_WRAM_SIZE      = 0x00080000, ///< AXI WRAM size (512KB)
+    AXI_WRAM_SIZE = 0x00080000, ///< AXI WRAM size (512KB)
    AXI_WRAM_PADDR_END = AXI_WRAM_PADDR + AXI_WRAM_SIZE,
    /// Main FCRAM
-    FCRAM_PADDR     = 0x20000000,
+    FCRAM_PADDR = 0x20000000,
-    FCRAM_SIZE      = 0x08000000, ///< FCRAM size (128MB)
+    FCRAM_SIZE = 0x08000000, ///< FCRAM size (128MB)
    FCRAM_PADDR_END = FCRAM_PADDR + FCRAM_SIZE,
 };
 /// Virtual user-space memory regions
 enum : VAddr {
    /// Where the application text, data and bss reside.
-    PROCESS_IMAGE_VADDR     = 0x00100000,
+    PROCESS_IMAGE_VADDR = 0x00100000,
-    PROCESS_IMAGE_MAX_SIZE  = 0x03F00000,
+    PROCESS_IMAGE_MAX_SIZE = 0x03F00000,
    PROCESS_IMAGE_VADDR_END = PROCESS_IMAGE_VADDR + PROCESS_IMAGE_MAX_SIZE,
    /// Area where IPC buffers are mapped onto.
-    IPC_MAPPING_VADDR     = 0x04000000,
+    IPC_MAPPING_VADDR = 0x04000000,
-    IPC_MAPPING_SIZE      = 0x04000000,
+    IPC_MAPPING_SIZE = 0x04000000,
    IPC_MAPPING_VADDR_END = IPC_MAPPING_VADDR + IPC_MAPPING_SIZE,
    /// Application heap (includes stack).
-    HEAP_VADDR     = 0x08000000,
+    HEAP_VADDR = 0x08000000,
-    HEAP_SIZE      = 0x08000000,
+    HEAP_SIZE = 0x08000000,
    HEAP_VADDR_END = HEAP_VADDR + HEAP_SIZE,
    /// Area where shared memory buffers are mapped onto.
-    SHARED_MEMORY_VADDR     = 0x10000000,
+    SHARED_MEMORY_VADDR = 0x10000000,
-    SHARED_MEMORY_SIZE      = 0x04000000,
+    SHARED_MEMORY_SIZE = 0x04000000,
    SHARED_MEMORY_VADDR_END = SHARED_MEMORY_VADDR + SHARED_MEMORY_SIZE,
-    /// Maps 1:1 to an offset in FCRAM. Used for HW allocations that need to be linear in physical memory.
+    /// Maps 1:1 to an offset in FCRAM. Used for HW allocations that need to be linear in physical
-    LINEAR_HEAP_VADDR     = 0x14000000,
+    /// memory.
-    LINEAR_HEAP_SIZE      = 0x08000000,
+    LINEAR_HEAP_VADDR = 0x14000000,
+    LINEAR_HEAP_SIZE = 0x08000000,
    LINEAR_HEAP_VADDR_END = LINEAR_HEAP_VADDR + LINEAR_HEAP_SIZE,
    /// Maps 1:1 to the IO register area.
-    IO_AREA_VADDR     = 0x1EC00000,
+    IO_AREA_VADDR = 0x1EC00000,
    IO_AREA_VADDR_END = IO_AREA_VADDR + IO_AREA_SIZE,
    /// Maps 1:1 to VRAM.
-    VRAM_VADDR     = 0x1F000000,
+    VRAM_VADDR = 0x1F000000,
    VRAM_VADDR_END = VRAM_VADDR + VRAM_SIZE,
    /// Maps 1:1 to DSP memory.
-    DSP_RAM_VADDR     = 0x1FF00000,
+    DSP_RAM_VADDR = 0x1FF00000,
    DSP_RAM_VADDR_END = DSP_RAM_VADDR + DSP_RAM_SIZE,
    /// Read-only page containing kernel and system configuration values.
-    CONFIG_MEMORY_VADDR     = 0x1FF80000,
+    CONFIG_MEMORY_VADDR = 0x1FF80000,
-    CONFIG_MEMORY_SIZE      = 0x00001000,
+    CONFIG_MEMORY_SIZE = 0x00001000,
    CONFIG_MEMORY_VADDR_END = CONFIG_MEMORY_VADDR + CONFIG_MEMORY_SIZE,
    /// Usually read-only page containing mostly values read from hardware.
-    SHARED_PAGE_VADDR     = 0x1FF81000,
+    SHARED_PAGE_VADDR = 0x1FF81000,
-    SHARED_PAGE_SIZE      = 0x00001000,
+    SHARED_PAGE_SIZE = 0x00001000,
    SHARED_PAGE_VADDR_END = SHARED_PAGE_VADDR + SHARED_PAGE_SIZE,
    /// Area where TLS (Thread-Local Storage) buffers are allocated.
-    TLS_AREA_VADDR     = 0x1FF82000,
+    TLS_AREA_VADDR = 0x1FF82000,
-    TLS_ENTRY_SIZE     = 0x200,
+    TLS_ENTRY_SIZE = 0x200,
    /// Equivalent to LINEAR_HEAP_VADDR, but expanded to cover the extra memory in the New 3DS.
-    NEW_LINEAR_HEAP_VADDR     = 0x30000000,
+    NEW_LINEAR_HEAP_VADDR = 0x30000000,
-    NEW_LINEAR_HEAP_SIZE      = 0x10000000,
+    NEW_LINEAR_HEAP_SIZE = 0x10000000,
    NEW_LINEAR_HEAP_VADDR_END = NEW_LINEAR_HEAP_VADDR + NEW_LINEAR_HEAP_SIZE,
 };
@@ -166,5 +167,4 @@ void RasterizerFlushRegion(PAddr start, u32 size);
 * Flushes and invalidates any externally cached rasterizer resources touching the given region.
 */
 void RasterizerFlushAndInvalidateRegion(PAddr start, u32 size);
 }
diff --git a/src/core/memory_setup.h b/src/core/memory_setup.h
index ee8ea7857..23c36d019 100644
--- a/src/core/memory_setup.h
+++ b/src/core/memory_setup.h
@@ -30,5 +30,4 @@ void MapMemoryRegion(VAddr base, u32 size, u8* target);
 void MapIoRegion(VAddr base, u32 size, MMIORegionPointer mmio_handler);
 void UnmapRegion(VAddr base, u32 size);
 }
diff --git a/src/core/mmio.h b/src/core/mmio.h
index d76f005d8..9aa59212b 100644
--- a/src/core/mmio.h
+++ b/src/core/mmio.h
@@ -36,5 +36,4 @@ public:
 };
 using MMIORegionPointer = std::shared_ptr<MMIORegion>;
 };
diff --git a/src/core/settings.cpp b/src/core/settings.cpp
index 1b6733a79..09194fe1f 100644
--- a/src/core/settings.cpp
+++ b/src/core/settings.cpp
@@ -25,7 +25,6 @@ void Apply() {
    AudioCore::SelectSink(values.sink_id);
    AudioCore::EnableStretching(values.enable_audio_stretching);
 }
 } // namespace
diff --git a/src/core/settings.h b/src/core/settings.h
index fcd14c6f3..adb2fd538 100644
--- a/src/core/settings.h
+++ b/src/core/settings.h
@@ -4,8 +4,8 @@
 #pragma once
-#include <string>
 #include <array>
+#include <string>
 #include "common/common_types.h"
@@ -14,14 +14,31 @@ namespace Settings {
 namespace NativeInput {
 enum Values {
    // directly mapped keys
-    A, B, X, Y,
+    A,
-    L, R, ZL, ZR,
+    B,
-    START, SELECT, HOME,
+    X,
-    DUP, DDOWN, DLEFT, DRIGHT,
+    Y,
-    CUP, CDOWN, CLEFT, CRIGHT,
+    L,
+    R,
+    ZL,
+    ZR,
+    START,
+    SELECT,
+    HOME,
+    DUP,
+    DDOWN,
+    DLEFT,
+    DRIGHT,
+    CUP,
+    CDOWN,
+    CLEFT,
+    CRIGHT,
    // indirectly mapped keys
-    CIRCLE_UP, CIRCLE_DOWN, CIRCLE_LEFT, CIRCLE_RIGHT,
+    CIRCLE_UP,
+    CIRCLE_DOWN,
+    CIRCLE_LEFT,
+    CIRCLE_RIGHT,
    CIRCLE_MODIFIER,
    NUM_INPUTS
@@ -29,28 +46,21 @@ enum Values {
 static const std::array<const char*, NUM_INPUTS> Mapping = {{
    // directly mapped keys
-    "pad_a", "pad_b", "pad_x", "pad_y",
+    "pad_a", "pad_b", "pad_x", "pad_y", "pad_l", "pad_r", "pad_zl", "pad_zr", "pad_start",
-    "pad_l", "pad_r", "pad_zl", "pad_zr",
+    "pad_select", "pad_home", "pad_dup", "pad_ddown", "pad_dleft", "pad_dright", "pad_cup",
-    "pad_start", "pad_select", "pad_home",
+    "pad_cdown", "pad_cleft", "pad_cright",
-    "pad_dup", "pad_ddown", "pad_dleft", "pad_dright",
-    "pad_cup", "pad_cdown", "pad_cleft", "pad_cright",
    // indirectly mapped keys
    "pad_circle_up", "pad_circle_down", "pad_circle_left", "pad_circle_right",
    "pad_circle_modifier",
 }};
 static const std::array<Values, NUM_INPUTS> All = {{
-    A, B, X, Y,
+    A,     B,      X,      Y,         L,           R,           ZL,           ZR,
-    L, R, ZL, ZR,
+    START, SELECT, HOME,   DUP,       DDOWN,       DLEFT,       DRIGHT,       CUP,
-    START, SELECT, HOME,
+    CDOWN, CLEFT,  CRIGHT, CIRCLE_UP, CIRCLE_DOWN, CIRCLE_LEFT, CIRCLE_RIGHT, CIRCLE_MODIFIER,
-    DUP, DDOWN, DLEFT, DRIGHT,
-    CUP, CDOWN, CLEFT, CRIGHT,
-    CIRCLE_UP, CIRCLE_DOWN, CIRCLE_LEFT, CIRCLE_RIGHT,
-    CIRCLE_MODIFIER,
 }};
 }
 struct Values {
    // CheckNew3DS
    bool is_new_3ds;
@@ -91,5 +101,4 @@ struct Values {
 } extern values;
 void Apply();
 }
diff --git a/src/core/system.cpp b/src/core/system.cpp
index 4fc266cb0..f2bf648bd 100644
--- a/src/core/system.cpp
+++ b/src/core/system.cpp
@@ -6,18 +6,18 @@
 #include "core/core.h"
 #include "core/core_timing.h"
-#include "core/system.h"
 #include "core/gdbstub/gdbstub.h"
-#include "core/hw/hw.h"
 #include "core/hle/hle.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/memory.h"
+#include "core/hw/hw.h"
+#include "core/system.h"
 #include "video_core/video_core.h"
 namespace System {
-static bool is_powered_on{ false };
+static bool is_powered_on{false};
 Result Init(EmuWindow* emu_window) {
    Core::Init();
diff --git a/src/core/system.h b/src/core/system.h
index fb0ca4e1b..6d672b1b5 100644
--- a/src/core/system.h
+++ b/src/core/system.h
@@ -9,14 +9,13 @@ class EmuWindow;
 namespace System {
 enum class Result {
-    Success,                ///< Everything is fine
+    Success,            ///< Everything is fine
-    Error,                  ///< Something went wrong (no module specified)
+    Error,              ///< Something went wrong (no module specified)
-    ErrorInitCore,          ///< Something went wrong during core init
+    ErrorInitCore,      ///< Something went wrong during core init
-    ErrorInitVideoCore,     ///< Something went wrong during video core init
+    ErrorInitVideoCore, ///< Something went wrong during video core init
 };
 Result Init(EmuWindow* emu_window);
 bool IsPoweredOn();
 void Shutdown();
 }
diff --git a/src/core/tracer/citrace.h b/src/core/tracer/citrace.h
index 709abdfb3..ac26e872b 100644
--- a/src/core/tracer/citrace.h
+++ b/src/core/tracer/citrace.h
@@ -61,8 +61,8 @@ struct CTHeader {
 };
 enum CTStreamElementType : u32 {
-    FrameMarker   = 0xE1,
+    FrameMarker = 0xE1,
-    MemoryLoad    = 0xE2,
+    MemoryLoad = 0xE2,
    RegisterWrite = 0xE3,
 };
@@ -76,12 +76,7 @@ struct CTMemoryLoad {
 struct CTRegisterWrite {
    u32 physical_address;
-    enum : u32 {
+    enum : u32 { SIZE_8 = 0xD1, SIZE_16 = 0xD2, SIZE_32 = 0xD3, SIZE_64 = 0xD4 } size;
-        SIZE_8  = 0xD1,
-        SIZE_16 = 0xD2,
-        SIZE_32 = 0xD3,
-        SIZE_64 = 0xD4
-    } size;
    // TODO: Make it clearer which bits of this member are used for sizes other than 32 bits
    u64 value;
@@ -97,5 +92,4 @@ struct CTStreamElement {
 };
 #pragma pack()
 }
diff --git a/src/core/tracer/recorder.cpp b/src/core/tracer/recorder.cpp
index 7abaacf70..8fd0018c4 100644
--- a/src/core/tracer/recorder.cpp
+++ b/src/core/tracer/recorder.cpp
@@ -13,7 +13,6 @@
 namespace CiTrace {
 Recorder::Recorder(const InitialState& initial_state) : initial_state(initial_state) {
 }
 void Recorder::Finish(const std::string& filename) {
@@ -26,35 +25,41 @@ void Recorder::Finish(const std::string& filename) {
    // Calculate file offsets
    auto& initial = header.initial_state_offsets;
-    initial.gpu_registers_size      = static_cast<u32>(initial_state.gpu_registers.size());
+    initial.gpu_registers_size = static_cast<u32>(initial_state.gpu_registers.size());
-    initial.lcd_registers_size      = static_cast<u32>(initial_state.lcd_registers.size());
+    initial.lcd_registers_size = static_cast<u32>(initial_state.lcd_registers.size());
-    initial.pica_registers_size     = static_cast<u32>(initial_state.pica_registers.size());
+    initial.pica_registers_size = static_cast<u32>(initial_state.pica_registers.size());
    initial.default_attributes_size = static_cast<u32>(initial_state.default_attributes.size());
-    initial.vs_program_binary_size  = static_cast<u32>(initial_state.vs_program_binary.size());
+    initial.vs_program_binary_size = static_cast<u32>(initial_state.vs_program_binary.size());
-    initial.vs_swizzle_data_size    = static_cast<u32>(initial_state.vs_swizzle_data.size());
+    initial.vs_swizzle_data_size = static_cast<u32>(initial_state.vs_swizzle_data.size());
-    initial.vs_float_uniforms_size  = static_cast<u32>(initial_state.vs_float_uniforms.size());
+    initial.vs_float_uniforms_size = static_cast<u32>(initial_state.vs_float_uniforms.size());
-    initial.gs_program_binary_size  = static_cast<u32>(initial_state.gs_program_binary.size());
+    initial.gs_program_binary_size = static_cast<u32>(initial_state.gs_program_binary.size());
-    initial.gs_swizzle_data_size    = static_cast<u32>(initial_state.gs_swizzle_data.size());
+    initial.gs_swizzle_data_size = static_cast<u32>(initial_state.gs_swizzle_data.size());
-    initial.gs_float_uniforms_size  = static_cast<u32>(initial_state.gs_float_uniforms.size());
+    initial.gs_float_uniforms_size = static_cast<u32>(initial_state.gs_float_uniforms.size());
-    header.stream_size              = static_cast<u32>(stream.size());
+    header.stream_size = static_cast<u32>(stream.size());
-    initial.gpu_registers      = sizeof(header);
+    initial.gpu_registers = sizeof(header);
-    initial.lcd_registers      = initial.gpu_registers      + initial.gpu_registers_size * sizeof(u32);
+    initial.lcd_registers = initial.gpu_registers + initial.gpu_registers_size * sizeof(u32);
-    initial.pica_registers     = initial.lcd_registers      + initial.lcd_registers_size * sizeof(u32);;
+    initial.pica_registers = initial.lcd_registers + initial.lcd_registers_size * sizeof(u32);
-    initial.default_attributes = initial.pica_registers     + initial.pica_registers_size * sizeof(u32);
+    ;
-    initial.vs_program_binary  = initial.default_attributes + initial.default_attributes_size * sizeof(u32);
+    initial.default_attributes = initial.pica_registers + initial.pica_registers_size * sizeof(u32);
-    initial.vs_swizzle_data    = initial.vs_program_binary  + initial.vs_program_binary_size * sizeof(u32);
+    initial.vs_program_binary =
-    initial.vs_float_uniforms  = initial.vs_swizzle_data    + initial.vs_swizzle_data_size * sizeof(u32);
+        initial.default_attributes + initial.default_attributes_size * sizeof(u32);
-    initial.gs_program_binary  = initial.vs_float_uniforms  + initial.vs_float_uniforms_size * sizeof(u32);
+    initial.vs_swizzle_data =
-    initial.gs_swizzle_data    = initial.gs_program_binary  + initial.gs_program_binary_size * sizeof(u32);
+        initial.vs_program_binary + initial.vs_program_binary_size * sizeof(u32);
-    initial.gs_float_uniforms  = initial.gs_swizzle_data    + initial.gs_swizzle_data_size * sizeof(u32);
+    initial.vs_float_uniforms =
-    header.stream_offset       = initial.gs_float_uniforms  + initial.gs_float_uniforms_size * sizeof(u32);
+        initial.vs_swizzle_data + initial.vs_swizzle_data_size * sizeof(u32);
+    initial.gs_program_binary =
+        initial.vs_float_uniforms + initial.vs_float_uniforms_size * sizeof(u32);
+    initial.gs_swizzle_data =
+        initial.gs_program_binary + initial.gs_program_binary_size * sizeof(u32);
+    initial.gs_float_uniforms =
+        initial.gs_swizzle_data + initial.gs_swizzle_data_size * sizeof(u32);
+    header.stream_offset = initial.gs_float_uniforms + initial.gs_float_uniforms_size * sizeof(u32);
    // Iterate through stream elements, update relevant stream element data
    for (auto& stream_element : stream) {
        switch (stream_element.data.type) {
-        case MemoryLoad:
+        case MemoryLoad: {
-        {
            auto& file_offset = memory_regions[stream_element.hash];
            if (!stream_element.uses_existing_data) {
                file_offset = header.stream_offset;
@@ -79,44 +84,62 @@ void Recorder::Finish(const std::string& filename) {
            throw "Failed to write header";
        // Write initial state
-        written = file.WriteArray(initial_state.gpu_registers.data(), initial_state.gpu_registers.size());
+        written =
+            file.WriteArray(initial_state.gpu_registers.data(), initial_state.gpu_registers.size());
        if (written != initial_state.gpu_registers.size() || file.Tell() != initial.lcd_registers)
            throw "Failed to write GPU registers";
-        written = file.WriteArray(initial_state.lcd_registers.data(), initial_state.lcd_registers.size());
+        written =
+            file.WriteArray(initial_state.lcd_registers.data(), initial_state.lcd_registers.size());
        if (written != initial_state.lcd_registers.size() || file.Tell() != initial.pica_registers)
            throw "Failed to write LCD registers";
-        written = file.WriteArray(initial_state.pica_registers.data(), initial_state.pica_registers.size());
+        written = file.WriteArray(initial_state.pica_registers.data(),
-        if (written != initial_state.pica_registers.size() || file.Tell() != initial.default_attributes)
+                                  initial_state.pica_registers.size());
+        if (written != initial_state.pica_registers.size() ||
+            file.Tell() != initial.default_attributes)
            throw "Failed to write Pica registers";
-        written = file.WriteArray(initial_state.default_attributes.data(), initial_state.default_attributes.size());
+        written = file.WriteArray(initial_state.default_attributes.data(),
-        if (written != initial_state.default_attributes.size() || file.Tell() != initial.vs_program_binary)
+                                  initial_state.default_attributes.size());
+        if (written != initial_state.default_attributes.size() ||
+            file.Tell() != initial.vs_program_binary)
            throw "Failed to write default vertex attributes";
-        written = file.WriteArray(initial_state.vs_program_binary.data(), initial_state.vs_program_binary.size());
+        written = file.WriteArray(initial_state.vs_program_binary.data(),
-        if (written != initial_state.vs_program_binary.size() || file.Tell() != initial.vs_swizzle_data)
+                                  initial_state.vs_program_binary.size());
+        if (written != initial_state.vs_program_binary.size() ||
+            file.Tell() != initial.vs_swizzle_data)
            throw "Failed to write vertex shader program binary";
-        written = file.WriteArray(initial_state.vs_swizzle_data.data(), initial_state.vs_swizzle_data.size());
+        written = file.WriteArray(initial_state.vs_swizzle_data.data(),
-        if (written != initial_state.vs_swizzle_data.size() || file.Tell() != initial.vs_float_uniforms)
+                                  initial_state.vs_swizzle_data.size());
+        if (written != initial_state.vs_swizzle_data.size() ||
+            file.Tell() != initial.vs_float_uniforms)
            throw "Failed to write vertex shader swizzle data";
-        written = file.WriteArray(initial_state.vs_float_uniforms.data(), initial_state.vs_float_uniforms.size());
+        written = file.WriteArray(initial_state.vs_float_uniforms.data(),
-        if (written != initial_state.vs_float_uniforms.size() || file.Tell() != initial.gs_program_binary)
+                                  initial_state.vs_float_uniforms.size());
+        if (written != initial_state.vs_float_uniforms.size() ||
+            file.Tell() != initial.gs_program_binary)
            throw "Failed to write vertex shader float uniforms";
-        written = file.WriteArray(initial_state.gs_program_binary.data(), initial_state.gs_program_binary.size());
+        written = file.WriteArray(initial_state.gs_program_binary.data(),
-        if (written != initial_state.gs_program_binary.size() || file.Tell() != initial.gs_swizzle_data)
+                                  initial_state.gs_program_binary.size());
+        if (written != initial_state.gs_program_binary.size() ||
+            file.Tell() != initial.gs_swizzle_data)
            throw "Failed to write geomtry shader program binary";
-        written = file.WriteArray(initial_state.gs_swizzle_data.data(), initial_state.gs_swizzle_data.size());
+        written = file.WriteArray(initial_state.gs_swizzle_data.data(),
-        if (written != initial_state.gs_swizzle_data.size() || file.Tell() != initial.gs_float_uniforms)
+                                  initial_state.gs_swizzle_data.size());
+        if (written != initial_state.gs_swizzle_data.size() ||
+            file.Tell() != initial.gs_float_uniforms)
            throw "Failed to write geometry shader swizzle data";
-        written = file.WriteArray(initial_state.gs_float_uniforms.data(), initial_state.gs_float_uniforms.size());
+        written = file.WriteArray(initial_state.gs_float_uniforms.data(),
-        if (written != initial_state.gs_float_uniforms.size() || file.Tell() != initial.gs_float_uniforms + sizeof(u32) * initial.gs_float_uniforms_size)
+                                  initial_state.gs_float_uniforms.size());
+        if (written != initial_state.gs_float_uniforms.size() ||
+            file.Tell() != initial.gs_float_uniforms + sizeof(u32) * initial.gs_float_uniforms_size)
            throw "Failed to write geometry shader float uniforms";
        // Iterate through stream elements, write "extra data"
@@ -124,7 +147,8 @@ void Recorder::Finish(const std::string& filename) {
            if (stream_element.extra_data.size() == 0)
                continue;
-            written = file.WriteBytes(stream_element.extra_data.data(), stream_element.extra_data.size());
+            written =
+                file.WriteBytes(stream_element.extra_data.data(), stream_element.extra_data.size());
            if (written != stream_element.extra_data.size())
                throw "Failed to write extra data";
        }
@@ -137,17 +161,17 @@ void Recorder::Finish(const std::string& filename) {
            if (1 != file.WriteObject(stream_element.data))
                throw "Failed to write stream element";
        }
-    } catch(const char* str) {
+    } catch (const char* str) {
        LOG_ERROR(HW_GPU, "Writing CiTrace file failed: %s", str);
    }
 }
 void Recorder::FrameFinished() {
-    stream.push_back( { { FrameMarker } } );
+    stream.push_back({{FrameMarker}});
 }
 void Recorder::MemoryAccessed(const u8* data, u32 size, u32 physical_address) {
-    StreamElement element = { { MemoryLoad } };
+    StreamElement element = {{MemoryLoad}};
    element.data.memory_load.size = size;
    element.data.memory_load.physical_address = physical_address;
@@ -166,22 +190,22 @@ void Recorder::MemoryAccessed(const u8* data, u32 size, u32 physical_address) {
    stream.push_back(element);
 }
-template<typename T>
+template <typename T>
 void Recorder::RegisterWritten(u32 physical_address, T value) {
-    StreamElement element = { { RegisterWrite } };
+    StreamElement element = {{RegisterWrite}};
-    element.data.register_write.size = (sizeof(T) == 1) ? CTRegisterWrite::SIZE_8
+    element.data.register_write.size =
-                                     : (sizeof(T) == 2) ? CTRegisterWrite::SIZE_16
+        (sizeof(T) == 1) ? CTRegisterWrite::SIZE_8
-                                     : (sizeof(T) == 4) ? CTRegisterWrite::SIZE_32
+                         : (sizeof(T) == 2) ? CTRegisterWrite::SIZE_16
-                                     :                    CTRegisterWrite::SIZE_64;
+                                            : (sizeof(T) == 4) ? CTRegisterWrite::SIZE_32
+                                                               : CTRegisterWrite::SIZE_64;
    element.data.register_write.physical_address = physical_address;
    element.data.register_write.value = value;
    stream.push_back(element);
 }
-template void Recorder::RegisterWritten(u32,u8);
+template void Recorder::RegisterWritten(u32, u8);
-template void Recorder::RegisterWritten(u32,u16);
+template void Recorder::RegisterWritten(u32, u16);
-template void Recorder::RegisterWritten(u32,u32);
+template void Recorder::RegisterWritten(u32, u32);
-template void Recorder::RegisterWritten(u32,u64);
+template void Recorder::RegisterWritten(u32, u64);
 }
diff --git a/src/core/tracer/recorder.h b/src/core/tracer/recorder.h
index febf883c8..6f5354f84 100644
--- a/src/core/tracer/recorder.h
+++ b/src/core/tracer/recorder.h
@@ -54,7 +54,7 @@ public:
     * Record a register write.
     * @note Use this whenever a GPU-related MMIO register has been written to.
     */
-    template<typename T>
+    template <typename T>
    void RegisterWritten(u32 physical_address, T value);
 private: