218 files changed, 10685 insertions, 10727 deletions

diff --git a/src/core/arm/arm_interface.h b/src/core/arm/arm_interface.h
index 480c90e66..e466b21b2 100644
--- a/src/core/arm/arm_interface.h
+++ b/src/core/arm/arm_interface.h
@@ -9,14 +9,13 @@
 #include "core/arm/skyeye_common/vfp/asm_vfp.h"
 
 namespace Core {
-    struct ThreadContext;
+struct ThreadContext;
 }
 
 /// Generic ARM11 CPU interface
 class ARM_Interface : NonCopyable {
 public:
-    virtual ~ARM_Interface() {
-    }
+    virtual ~ARM_Interface() {}
 
     /**
      * Runs the CPU for the given number of instructions
@@ -141,10 +140,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 +151,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..05d6ed1fb 100644
--- a/src/core/arm/disassembler/arm_disasm.cpp
+++ b/src/core/arm/disassembler/arm_disasm.cpp
@@ -2,408 +2,230 @@
 
 #include <string>
 #include <unordered_set>
-
 #include "common/common_types.h"
 #include "common/string_util.h"
-
 #include "core/arm/disassembler/arm_disasm.h"
 #include "core/arm/skyeye_common/armsupp.h"
 
-static const char *cond_names[] = {
-    "eq",
-    "ne",
-    "cs",
-    "cc",
-    "mi",
-    "pl",
-    "vs",
-    "vc",
-    "hi",
-    "ls",
-    "ge",
-    "lt",
-    "gt",
-    "le",
-    "",
-    "RESERVED"
-};
-
-static const char *opcode_names[] = {
-    "invalid",
-    "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",
+static const char* cond_names[] = {"eq", "ne", "cs", "cc", "mi", "pl", "vs", "vc",
+                                   "hi", "ls", "ge", "lt", "gt", "le", "",   "RESERVED"};
+
+static const char* opcode_names[] = {
+    "invalid",   "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",
-    "adc",
-    "add",
-    "and",
-    "asr",
-    "b",
-    "bic",
-    "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
-};
+    "undefined", "adc",       "add",    "and",     "asr",    "b",      "bic",    "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[] = {
-    "LSL",
-    "LSR",
-    "ASR",
-    "ROR"
-};
+static const char* shift_names[] = {"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:
-            return "Invalid";
-        case OP_UNDEFINED:
-            return "Undefined";
-        case OP_ADC:
-        case OP_ADD:
-        case OP_AND:
-        case OP_BIC:
-        case OP_CMN:
-        case OP_CMP:
-        case OP_EOR:
-        case OP_MOV:
-        case OP_MVN:
-        case OP_ORR:
-        case OP_RSB:
-        case OP_RSC:
-        case OP_SBC:
-        case OP_SUB:
-        case OP_TEQ:
-        case OP_TST:
-            return DisassembleALU(opcode, insn);
-        case OP_B:
-        case OP_BL:
-            return DisassembleBranch(addr, opcode, insn);
-        case OP_BKPT:
-            return DisassembleBKPT(insn);
-        case OP_BLX:
-            // not supported yet
-            break;
-        case OP_BX:
-            return DisassembleBX(insn);
-        case OP_CDP:
-            return "cdp";
-        case OP_CLREX:
-            return "clrex";
-        case OP_CLZ:
-            return DisassembleCLZ(insn);
-        case OP_LDC:
-            return "ldc";
-        case OP_LDM:
-        case OP_STM:
-            return DisassembleMemblock(opcode, insn);
-        case OP_LDR:
-        case OP_LDRB:
-        case OP_LDRBT:
-        case OP_LDRT:
-        case OP_STR:
-        case OP_STRB:
-        case OP_STRBT:
-        case OP_STRT:
-            return DisassembleMem(insn);
-        case OP_LDREX:
-        case OP_LDREXB:
-        case OP_LDREXD:
-        case OP_LDREXH:
-        case OP_STREX:
-        case OP_STREXB:
-        case OP_STREXD:
-        case OP_STREXH:
-            return DisassembleREX(opcode, insn);
-        case OP_LDRH:
-        case OP_LDRSB:
-        case OP_LDRSH:
-        case OP_STRH:
-            return DisassembleMemHalf(insn);
-        case OP_MCR:
-        case OP_MRC:
-            return DisassembleMCR(opcode, insn);
-        case OP_MLA:
-            return DisassembleMLA(opcode, insn);
-        case OP_MRS:
-            return DisassembleMRS(insn);
-        case OP_MSR:
-            return DisassembleMSR(insn);
-        case OP_MUL:
-            return DisassembleMUL(opcode, insn);
-        case OP_NOP:
-        case OP_SEV:
-        case OP_WFE:
-        case OP_WFI:
-        case OP_YIELD:
-            return DisassembleNoOperands(opcode, insn);
-        case OP_PKH:
-            return DisassemblePKH(insn);
-        case OP_PLD:
-            return DisassemblePLD(insn);
-        case OP_QADD16:
-        case OP_QADD8:
-        case OP_QASX:
-        case OP_QSAX:
-        case OP_QSUB16:
-        case OP_QSUB8:
-        case OP_SADD16:
-        case OP_SADD8:
-        case OP_SASX:
-        case OP_SHADD16:
-        case OP_SHADD8:
-        case OP_SHASX:
-        case OP_SHSAX:
-        case OP_SHSUB16:
-        case OP_SHSUB8:
-        case OP_SSAX:
-        case OP_SSUB16:
-        case OP_SSUB8:
-        case OP_UADD16:
-        case OP_UADD8:
-        case OP_UASX:
-        case OP_UHADD16:
-        case OP_UHADD8:
-        case OP_UHASX:
-        case OP_UHSAX:
-        case OP_UHSUB16:
-        case OP_UHSUB8:
-        case OP_UQADD16:
-        case OP_UQADD8:
-        case OP_UQASX:
-        case OP_UQSAX:
-        case OP_UQSUB16:
-        case OP_UQSUB8:
-        case OP_USAX:
-        case OP_USUB16:
-        case OP_USUB8:
-            return DisassembleParallelAddSub(opcode, insn);
-        case OP_REV:
-        case OP_REV16:
-        case OP_REVSH:
-            return DisassembleREV(opcode, insn);
-        case OP_SEL:
-            return DisassembleSEL(insn);
-        case OP_SMLAD:
-        case OP_SMLALD:
-        case OP_SMLSD:
-        case OP_SMLSLD:
-        case OP_SMMLA:
-        case OP_SMMLS:
-        case OP_SMMUL:
-        case OP_SMUAD:
-        case OP_SMUSD:
-        case OP_USAD8:
-        case OP_USADA8:
-            return DisassembleMediaMulDiv(opcode, insn);
-        case OP_SSAT:
-        case OP_SSAT16:
-        case OP_USAT:
-        case OP_USAT16:
-            return DisassembleSAT(opcode, insn);
-        case OP_STC:
-            return "stc";
-        case OP_SWI:
-            return DisassembleSWI(insn);
-        case OP_SWP:
-        case OP_SWPB:
-            return DisassembleSWP(opcode, insn);
-        case OP_SXTAB:
-        case OP_SXTAB16:
-        case OP_SXTAH:
-        case OP_SXTB:
-        case OP_SXTB16:
-        case OP_SXTH:
-        case OP_UXTAB:
-        case OP_UXTAB16:
-        case OP_UXTAH:
-        case OP_UXTB:
-        case OP_UXTB16:
-        case OP_UXTH:
-            return DisassembleXT(opcode, insn);
-        case OP_UMLAL:
-        case OP_UMULL:
-        case OP_SMLAL:
-        case OP_SMULL:
-            return DisassembleUMLAL(opcode, insn);
-        default:
-            return "Error";
+    case OP_INVALID:
+        return "Invalid";
+    case OP_UNDEFINED:
+        return "Undefined";
+    case OP_ADC:
+    case OP_ADD:
+    case OP_AND:
+    case OP_BIC:
+    case OP_CMN:
+    case OP_CMP:
+    case OP_EOR:
+    case OP_MOV:
+    case OP_MVN:
+    case OP_ORR:
+    case OP_RSB:
+    case OP_RSC:
+    case OP_SBC:
+    case OP_SUB:
+    case OP_TEQ:
+    case OP_TST:
+        return DisassembleALU(opcode, insn);
+    case OP_B:
+    case OP_BL:
+        return DisassembleBranch(addr, opcode, insn);
+    case OP_BKPT:
+        return DisassembleBKPT(insn);
+    case OP_BLX:
+        // not supported yet
+        break;
+    case OP_BX:
+        return DisassembleBX(insn);
+    case OP_CDP:
+        return "cdp";
+    case OP_CLREX:
+        return "clrex";
+    case OP_CLZ:
+        return DisassembleCLZ(insn);
+    case OP_LDC:
+        return "ldc";
+    case OP_LDM:
+    case OP_STM:
+        return DisassembleMemblock(opcode, insn);
+    case OP_LDR:
+    case OP_LDRB:
+    case OP_LDRBT:
+    case OP_LDRT:
+    case OP_STR:
+    case OP_STRB:
+    case OP_STRBT:
+    case OP_STRT:
+        return DisassembleMem(insn);
+    case OP_LDREX:
+    case OP_LDREXB:
+    case OP_LDREXD:
+    case OP_LDREXH:
+    case OP_STREX:
+    case OP_STREXB:
+    case OP_STREXD:
+    case OP_STREXH:
+        return DisassembleREX(opcode, insn);
+    case OP_LDRH:
+    case OP_LDRSB:
+    case OP_LDRSH:
+    case OP_STRH:
+        return DisassembleMemHalf(insn);
+    case OP_MCR:
+    case OP_MRC:
+        return DisassembleMCR(opcode, insn);
+    case OP_MLA:
+        return DisassembleMLA(opcode, insn);
+    case OP_MRS:
+        return DisassembleMRS(insn);
+    case OP_MSR:
+        return DisassembleMSR(insn);
+    case OP_MUL:
+        return DisassembleMUL(opcode, insn);
+    case OP_NOP:
+    case OP_SEV:
+    case OP_WFE:
+    case OP_WFI:
+    case OP_YIELD:
+        return DisassembleNoOperands(opcode, insn);
+    case OP_PKH:
+        return DisassemblePKH(insn);
+    case OP_PLD:
+        return DisassemblePLD(insn);
+    case OP_QADD16:
+    case OP_QADD8:
+    case OP_QASX:
+    case OP_QSAX:
+    case OP_QSUB16:
+    case OP_QSUB8:
+    case OP_SADD16:
+    case OP_SADD8:
+    case OP_SASX:
+    case OP_SHADD16:
+    case OP_SHADD8:
+    case OP_SHASX:
+    case OP_SHSAX:
+    case OP_SHSUB16:
+    case OP_SHSUB8:
+    case OP_SSAX:
+    case OP_SSUB16:
+    case OP_SSUB8:
+    case OP_UADD16:
+    case OP_UADD8:
+    case OP_UASX:
+    case OP_UHADD16:
+    case OP_UHADD8:
+    case OP_UHASX:
+    case OP_UHSAX:
+    case OP_UHSUB16:
+    case OP_UHSUB8:
+    case OP_UQADD16:
+    case OP_UQADD8:
+    case OP_UQASX:
+    case OP_UQSAX:
+    case OP_UQSUB16:
+    case OP_UQSUB8:
+    case OP_USAX:
+    case OP_USUB16:
+    case OP_USUB8:
+        return DisassembleParallelAddSub(opcode, insn);
+    case OP_REV:
+    case OP_REV16:
+    case OP_REVSH:
+        return DisassembleREV(opcode, insn);
+    case OP_SEL:
+        return DisassembleSEL(insn);
+    case OP_SMLAD:
+    case OP_SMLALD:
+    case OP_SMLSD:
+    case OP_SMLSLD:
+    case OP_SMMLA:
+    case OP_SMMLS:
+    case OP_SMMUL:
+    case OP_SMUAD:
+    case OP_SMUSD:
+    case OP_USAD8:
+    case OP_USADA8:
+        return DisassembleMediaMulDiv(opcode, insn);
+    case OP_SSAT:
+    case OP_SSAT16:
+    case OP_USAT:
+    case OP_USAT16:
+        return DisassembleSAT(opcode, insn);
+    case OP_STC:
+        return "stc";
+    case OP_SWI:
+        return DisassembleSWI(insn);
+    case OP_SWP:
+    case OP_SWPB:
+        return DisassembleSWP(opcode, insn);
+    case OP_SXTAB:
+    case OP_SXTAB16:
+    case OP_SXTAH:
+    case OP_SXTB:
+    case OP_SXTB16:
+    case OP_SXTH:
+    case OP_UXTAB:
+    case OP_UXTAB16:
+    case OP_UXTAH:
+    case OP_UXTB:
+    case OP_UXTB16:
+    case OP_UXTH:
+        return DisassembleXT(opcode, insn);
+    case OP_UMLAL:
+    case OP_UMULL:
+    case OP_SMLAL:
+    case OP_SMULL:
+        return DisassembleUMLAL(opcode, insn);
+    default:
+        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 +243,18 @@ std::string ARM_Disasm::DisassembleALU(Opcode opcode, u32 insn)
 
     const char* opname = opcode_names[opcode];
     switch (opcode) {
-        case OP_CMN:
-        case OP_CMP:
-        case OP_TEQ:
-        case OP_TST:
-            flags = kNoDest | kNoSbit;
-            break;
-        case OP_MOV:
-        case OP_MVN:
-            flags = kNoOperand1;
-            break;
-        default:
-            break;
+    case OP_CMN:
+    case OP_CMP:
+    case OP_TEQ:
+    case OP_TST:
+        flags = kNoDest | kNoSbit;
+        break;
+    case OP_MOV:
+    case OP_MVN:
+        flags = kNoOperand1;
+        break;
+    default:
+        break;
     }
 
     // The "mov" instruction ignores the first operand (rn).
@@ -448,13 +270,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",
-                opname, cond_to_str(cond), sbit_str, rd_str.c_str(), rn_str.c_str(), immed, immed);
+        return Common::StringFromFormat("%s%s%s\t%s%s#%u  ; 0x%x", opname, cond_to_str(cond),
+                                        sbit_str, rd_str.c_str(), rn_str.c_str(), immed, immed);
     }
 
     u8 shift_is_reg = (insn >> 4) & 1;
@@ -468,30 +290,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",
-                opname, cond_to_str(cond), sbit_str, rd_str.c_str(), rn_str.c_str(), rm);
+        return Common::StringFromFormat("%s%s%s\t%s%sr%d", opname, cond_to_str(cond), sbit_str,
+                                        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",
-                opname, cond_to_str(cond), sbit_str, rd_str.c_str(), rn_str.c_str(), rm,
-                shift_name, rs);
+        return Common::StringFromFormat("%s%s%s\t%s%sr%d, %s r%d", opname, cond_to_str(cond),
+                                        sbit_str, rd_str.c_str(), rn_str.c_str(), rm, shift_name,
+                                        rs);
     }
     if (shift_amount == 0) {
         if (shift_type == 3) {
-            return Common::StringFromFormat("%s%s%s\t%s%sr%d, RRX",
-                    opname, cond_to_str(cond), sbit_str, rd_str.c_str(), rn_str.c_str(), rm);
+            return Common::StringFromFormat("%s%s%s\t%s%sr%d, RRX", opname, cond_to_str(cond),
+                                            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",
-            opname, cond_to_str(cond), sbit_str, rd_str.c_str(), rn_str.c_str(), rm,
-            shift_name, shift_amount);
+    return Common::StringFromFormat("%s%s%s\t%s%sr%d, %s #%u", opname, cond_to_str(cond), sbit_str,
+                                    rd_str.c_str(), rn_str.c_str(), rm, 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 +322,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 +362,8 @@ std::string ARM_Disasm::DisassembleMediaMulDiv(Opcode opcode, u32 insn) {
     }
 
     std::string ext_reg = "";
-    std::unordered_set<Opcode, std::hash<int>> with_ext_reg = {
-            OP_SMLAD, OP_SMLSD, OP_SMMLA, OP_SMMLS, OP_USADA8
-    };
+    std::unordered_set<Opcode, std::hash<int>> with_ext_reg = {OP_SMLAD, OP_SMLSD, OP_SMMLA,
+                                                               OP_SMMLS, OP_USADA8};
     if (with_ext_reg.find(opcode) != with_ext_reg.end())
         ext_reg = Common::StringFromFormat(", r%u", ra);
 
@@ -560,8 +376,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 +387,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 +406,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 +421,11 @@ std::string ARM_Disasm::DisassembleMemblock(Opcode opcode, u32 insn)
         }
     }
 
-    return Common::StringFromFormat("%s%s%s\tr%d%s, {%s}%s",
-            opname, cond_to_str(cond), addr_mode, rn, bang, tmp_list.c_str(), carret);
+    return Common::StringFromFormat("%s%s%s\tr%d%s, {%s}%s", opname, cond_to_str(cond), addr_mode,
+                                    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 +437,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]",
-                        opname, cond_to_str(cond), byte, rd, rn);
+                return Common::StringFromFormat("%s%s%s\tr%d, [r%d]", opname, cond_to_str(cond),
+                                                byte, rd, rn);
             } else {
-                return Common::StringFromFormat("%s%s%s\tr%d, [r%d, #%s%u]%s",
-                        opname, cond_to_str(cond), byte, rd, rn, minus, offset, bang);
+                return Common::StringFromFormat("%s%s%s\tr%d, [r%d, #%s%u]%s", opname,
+                                                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",
-                    opname, cond_to_str(cond), byte, transfer, rd, rn, minus, offset);
+            return Common::StringFromFormat("%s%s%s%s\tr%d, [r%d], #%s%u", opname,
+                                            cond_to_str(cond), byte, transfer, rd, rn, minus,
+                                            offset);
         }
     }
 
@@ -662,48 +478,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",
-                        opname, cond_to_str(cond), byte, rd, rn, minus, rm, bang);
+                return Common::StringFromFormat("%s%s%s\tr%d, [r%d, %sr%d]%s", opname,
+                                                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",
-                        opname, cond_to_str(cond), byte, rd, rn, minus, rm, bang);
+                return Common::StringFromFormat("%s%s%s\tr%d, [r%d, %sr%d, RRX]%s", opname,
+                                                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",
-                opname, cond_to_str(cond), byte, rd, rn, minus, rm,
-                shift_name, shift_amount, bang);
+        return Common::StringFromFormat("%s%s%s\tr%d, [r%d, %sr%d, %s #%u]%s", opname,
+                                        cond_to_str(cond), byte, rd, rn, minus, rm, shift_name,
+                                        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",
-                    opname, cond_to_str(cond), byte, transfer, rd, rn, minus, rm);
+            return Common::StringFromFormat("%s%s%s%s\tr%d, [r%d], %sr%d", opname,
+                                            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",
-                    opname, cond_to_str(cond), byte, transfer, rd, rn, minus, rm);
+            return Common::StringFromFormat("%s%s%s%s\tr%d, [r%d], %sr%d, RRX", opname,
+                                            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",
-            opname, cond_to_str(cond), byte, transfer, rd, rn, minus, rm,
-            shift_name, shift_amount);
+    return Common::StringFromFormat("%s%s%s%s\tr%d, [r%d], %sr%d, %s #%u", opname,
+                                    cond_to_str(cond), byte, transfer, rd, rn, minus, rm,
+                                    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 +531,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 +543,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",
-                        opname, cond_to_str(cond), width, rd, rn, minus, offset, bang);
+                return Common::StringFromFormat("%s%s%s\tr%d, [r%d, #%s%u]%s", opname,
+                                                cond_to_str(cond), width, rd, rn, minus, offset,
+                                                bang);
             }
         } else {
-            return Common::StringFromFormat("%s%s%s\tr%d, [r%d], #%s%u",
-                    opname, cond_to_str(cond), width, rd, rn, minus, offset);
+            return Common::StringFromFormat("%s%s%s\tr%d, [r%d], #%s%u", opname, cond_to_str(cond),
+                                            width, rd, rn, minus, offset);
         }
     }
 
     if (is_pre) {
-        return Common::StringFromFormat("%s%s%s\tr%d, [r%d, %sr%d]%s",
-                opname, cond_to_str(cond), width, rd, rn, minus, rm, bang);
+        return Common::StringFromFormat("%s%s%s\tr%d, [r%d, %sr%d]%s", opname, cond_to_str(cond),
+                                        width, rd, rn, minus, rm, bang);
     } else {
-        return Common::StringFromFormat("%s%s%s\tr%d, [r%d], %sr%d",
-                opname, cond_to_str(cond), width, rd, rn, minus, rm);
+        return Common::StringFromFormat("%s%s%s\tr%d, [r%d], %sr%d", opname, cond_to_str(cond),
+                                        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 +583,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];
-    return Common::StringFromFormat("%s%s\t%d, 0, r%d, cr%d, cr%d, {%d}",
-            opname, cond_to_str(cond), cpnum, crd, crn, crm, opcode2);
+    const char* opname = opcode_names[opcode];
+    return Common::StringFromFormat("%s%s\t%d, 0, r%d, cr%d, cr%d, {%d}", opname, cond_to_str(cond),
+                                    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 +596,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];
-    return Common::StringFromFormat("%s%s%s\tr%d, r%d, r%d, r%d",
-            opname, cond_to_str(cond), bit_s ? "s" : "", rd, rm, rs, rn);
+    const char* opname = opcode_names[opcode];
+    return Common::StringFromFormat("%s%s%s\tr%d, r%d, r%d, r%d", opname, cond_to_str(cond),
+                                    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 +609,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];
-    return Common::StringFromFormat("%s%s%s\tr%d, r%d, r%d, r%d",
-            opname, cond_to_str(cond), bit_s ? "s" : "", rdlo, rdhi, rm, rs);
+    const char* opname = opcode_names[opcode];
+    return Common::StringFromFormat("%s%s%s\tr%d, r%d, r%d, r%d", opname, cond_to_str(cond),
+                                    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];
-    return Common::StringFromFormat("%s%s%s\tr%d, r%d, r%d",
-            opname, cond_to_str(cond), bit_s ? "s" : "", rd, rm, rs);
+    const char* opname = opcode_names[opcode];
+    return Common::StringFromFormat("%s%s%s\tr%d, r%d, r%d", opname, cond_to_str(cond),
+                                    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 +634,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 +657,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",
-                cond_to_str(cond), pd ? "spsr" : "cpsr", flags, rotated_val);
+        return Common::StringFromFormat("msr%s\t%s_%s, #0x%x", cond_to_str(cond),
+                                        pd ? "spsr" : "cpsr", flags, rotated_val);
     }
 
     u8 rm = insn & 0xf;
 
-    return Common::StringFromFormat("msr%s\t%s_%s, r%d",
-            cond_to_str(cond), pd ? "spsr" : "cpsr", flags, rm);
+    return Common::StringFromFormat("msr%s\t%s_%s, r%d", cond_to_str(cond), pd ? "spsr" : "cpsr",
+                                    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 +682,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 +705,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 +732,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),
-                                    rd, rm);
+    return Common::StringFromFormat("%s%s\tr%u, r%u", opcode_names[opcode], cond_to_str(cond), rd,
+                                    rm);
 }
 
 std::string ARM_Disasm::DisassembleREX(Opcode opcode, u32 insn) {
@@ -935,26 +743,26 @@ std::string ARM_Disasm::DisassembleREX(Opcode opcode, u32 insn) {
     u32 cond = BITS(insn, 28, 31);
 
     switch (opcode) {
-        case OP_STREX:
-        case OP_STREXB:
-        case OP_STREXH:
-            return Common::StringFromFormat("%s%s\tr%d, r%d, [r%d]", opcode_names[opcode],
-                                            cond_to_str(cond), rd, rt, rn);
-        case OP_STREXD:
-            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);
-
-        // for LDREX instructions, rd corresponds to Rt from reference manual
-        case OP_LDREX:
-        case OP_LDREXB:
-        case OP_LDREXH:
-            return Common::StringFromFormat("%s%s\tr%d, [r%d]", opcode_names[opcode],
-                                            cond_to_str(cond), rd, rn);
-        case OP_LDREXD:
-            return Common::StringFromFormat("%s%s\tr%d, r%d, [r%d]", opcode_names[opcode],
-                                            cond_to_str(cond), rd, rd + 1, rn);
-        default:
-            return opcode_names[OP_UNDEFINED];
+    case OP_STREX:
+    case OP_STREXB:
+    case OP_STREXH:
+        return Common::StringFromFormat("%s%s\tr%d, r%d, [r%d]", opcode_names[opcode],
+                                        cond_to_str(cond), rd, rt, rn);
+    case OP_STREXD:
+        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);
+
+    // for LDREX instructions, rd corresponds to Rt from reference manual
+    case OP_LDREX:
+    case OP_LDREXB:
+    case OP_LDREXH:
+        return Common::StringFromFormat("%s%s\tr%d, [r%d]", opcode_names[opcode], cond_to_str(cond),
+                                        rd, rn);
+    case OP_LDREXD:
+        return Common::StringFromFormat("%s%s\tr%d, r%d, [r%d]", opcode_names[opcode],
+                                        cond_to_str(cond), rd, rd + 1, rn);
+    default:
+        return opcode_names[OP_UNDEFINED];
     }
 }
 
@@ -982,8 +790,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,
-                                    sat_imm, rn, shift_part.c_str());
+    return Common::StringFromFormat("%s%s\tr%u, #%u, r%u%s", opcode_names[opcode],
+                                    cond_to_str(cond), rd, sat_imm, rn, shift_part.c_str());
 }
 
 std::string ARM_Disasm::DisassembleSEL(u32 insn) {
@@ -996,27 +804,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 +830,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_UXTAB, OP_UXTAB16, OP_UXTAH
-    };
+        OP_SXTAB, OP_SXTAB16, OP_SXTAH, 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 +845,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:
-            return Decode00(insn);
-        case 0x1:
-            return Decode01(insn);
-        case 0x2:
-            return Decode10(insn);
-        case 0x3:
-            return Decode11(insn);
+    case 0x0:
+        return Decode00(insn);
+    case 0x1:
+        return Decode01(insn);
+    case 0x2:
+        return Decode10(insn);
+    case 0x3:
+        return Decode11(insn);
     }
     return OP_INVALID;
 }
@@ -1198,28 +1001,28 @@ Opcode ARM_Disasm::DecodeSyncPrimitive(u32 insn) {
     u32 op = BITS(insn, 20, 23);
     u32 bit22 = BIT(insn, 22);
     switch (op) {
-        case 0x0:
-            if (bit22)
-                return OP_SWPB;
-            return OP_SWP;
-        case 0x8:
-            return OP_STREX;
-        case 0x9:
-            return OP_LDREX;
-        case 0xA:
-            return OP_STREXD;
-        case 0xB:
-            return OP_LDREXD;
-        case 0xC:
-            return OP_STREXB;
-        case 0xD:
-            return OP_LDREXB;
-        case 0xE:
-            return OP_STREXH;
-        case 0xF:
-            return OP_LDREXH;
-        default:
-            return OP_UNDEFINED;
+    case 0x0:
+        if (bit22)
+            return OP_SWPB;
+        return OP_SWP;
+    case 0x8:
+        return OP_STREX;
+    case 0x9:
+        return OP_LDREX;
+    case 0xA:
+        return OP_STREXD;
+    case 0xB:
+        return OP_LDREXD;
+    case 0xC:
+        return OP_STREXB;
+    case 0xD:
+        return OP_LDREXB;
+    case 0xE:
+        return OP_STREXH;
+    case 0xF:
+        return OP_LDREXH;
+    default:
+        return OP_UNDEFINED;
     }
 }
 
@@ -1240,27 +1043,14 @@ Opcode ARM_Disasm::DecodeParallelAddSub(u32 insn) {
 
     static std::vector<Opcode> opcodes = {
         // op1 = 0
-        OP_SADD16, OP_UADD16,
-        OP_SASX, OP_UASX,
-        OP_SSAX, OP_USAX,
-        OP_SSUB16, OP_USUB16,
-        OP_SADD8, OP_UADD8,
-        OP_SSUB8, OP_USUB8,
+        OP_SADD16, OP_UADD16, OP_SASX, OP_UASX, OP_SSAX, OP_USAX, OP_SSUB16, OP_USUB16, OP_SADD8,
+        OP_UADD8, OP_SSUB8, OP_USUB8,
         // op1 = 1
-        OP_QADD16, OP_UQADD16,
-        OP_QASX, OP_UQASX,
-        OP_QSAX, OP_UQSAX,
-        OP_QSUB16, OP_UQSUB16,
-        OP_QADD8, OP_UQADD8,
-        OP_QSUB8, OP_UQSUB8,
+        OP_QADD16, OP_UQADD16, OP_QASX, OP_UQASX, OP_QSAX, OP_UQSAX, OP_QSUB16, OP_UQSUB16,
+        OP_QADD8, OP_UQADD8, OP_QSUB8, OP_UQSUB8,
         // op1 = 2
-        OP_SHADD16, OP_UHADD16,
-        OP_SHASX, OP_UHASX,
-        OP_SHSAX, OP_UHSAX,
-        OP_SHSUB16, OP_UHSUB16,
-        OP_SHADD8, OP_UHADD8,
-        OP_SHSUB8, OP_UHSUB8
-    };
+        OP_SHADD16, OP_UHADD16, OP_SHASX, OP_UHASX, 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 +1062,66 @@ Opcode ARM_Disasm::DecodePackingSaturationReversal(u32 insn) {
     u32 op2 = BITS(insn, 5, 7);
 
     switch (op1) {
-        case 0x0:
-            if (BIT(op2, 0) == 0)
-                return OP_PKH;
-            if (op2 == 0x3 && a != 0xf)
-                return OP_SXTAB16;
-            if (op2 == 0x3 && a == 0xf)
-                return OP_SXTB16;
-            if (op2 == 0x5)
-                return OP_SEL;
-            break;
-        case 0x2:
-            if (BIT(op2, 0) == 0)
-                return OP_SSAT;
-            if (op2 == 0x1)
-                return OP_SSAT16;
-            if (op2 == 0x3 && a != 0xf)
-                return OP_SXTAB;
-            if (op2 == 0x3 && a == 0xf)
-                return OP_SXTB;
-            break;
-        case 0x3:
-            if (op2 == 0x1)
-                return OP_REV;
-            if (BIT(op2, 0) == 0)
-                return OP_SSAT;
-            if (op2 == 0x3 && a != 0xf)
-                return OP_SXTAH;
-            if (op2 == 0x3 && a == 0xf)
-                return OP_SXTH;
-            if (op2 == 0x5)
-                return OP_REV16;
-            break;
-        case 0x4:
-            if (op2 == 0x3 && a != 0xf)
-                return OP_UXTAB16;
-            if (op2 == 0x3 && a == 0xf)
-                return OP_UXTB16;
-            break;
-        case 0x6:
-            if (BIT(op2, 0) == 0)
-                return OP_USAT;
-            if (op2 == 0x1)
-                return OP_USAT16;
-            if (op2 == 0x3 && a != 0xf)
-                return OP_UXTAB;
-            if (op2 == 0x3 && a == 0xf)
-                return OP_UXTB;
-            break;
-        case 0x7:
-            if (BIT(op2, 0) == 0)
-                return OP_USAT;
-            if (op2 == 0x3 && a != 0xf)
-                return OP_UXTAH;
-            if (op2 == 0x3 && a == 0xf)
-                return OP_UXTH;
-            if (op2 == 0x5)
-                return OP_REVSH;
-            break;
-        default:
-            break;
+    case 0x0:
+        if (BIT(op2, 0) == 0)
+            return OP_PKH;
+        if (op2 == 0x3 && a != 0xf)
+            return OP_SXTAB16;
+        if (op2 == 0x3 && a == 0xf)
+            return OP_SXTB16;
+        if (op2 == 0x5)
+            return OP_SEL;
+        break;
+    case 0x2:
+        if (BIT(op2, 0) == 0)
+            return OP_SSAT;
+        if (op2 == 0x1)
+            return OP_SSAT16;
+        if (op2 == 0x3 && a != 0xf)
+            return OP_SXTAB;
+        if (op2 == 0x3 && a == 0xf)
+            return OP_SXTB;
+        break;
+    case 0x3:
+        if (op2 == 0x1)
+            return OP_REV;
+        if (BIT(op2, 0) == 0)
+            return OP_SSAT;
+        if (op2 == 0x3 && a != 0xf)
+            return OP_SXTAH;
+        if (op2 == 0x3 && a == 0xf)
+            return OP_SXTH;
+        if (op2 == 0x5)
+            return OP_REV16;
+        break;
+    case 0x4:
+        if (op2 == 0x3 && a != 0xf)
+            return OP_UXTAB16;
+        if (op2 == 0x3 && a == 0xf)
+            return OP_UXTB16;
+        break;
+    case 0x6:
+        if (BIT(op2, 0) == 0)
+            return OP_USAT;
+        if (op2 == 0x1)
+            return OP_USAT16;
+        if (op2 == 0x3 && a != 0xf)
+            return OP_UXTAB;
+        if (op2 == 0x3 && a == 0xf)
+            return OP_UXTB;
+        break;
+    case 0x7:
+        if (BIT(op2, 0) == 0)
+            return OP_USAT;
+        if (op2 == 0x3 && a != 0xf)
+            return OP_UXTAH;
+        if (op2 == 0x3 && a == 0xf)
+            return OP_UXTH;
+        if (op2 == 0x5)
+            return OP_REVSH;
+        break;
+    default:
+        break;
     }
 
     return OP_UNDEFINED;
@@ -1378,18 +1168,18 @@ Opcode ARM_Disasm::DecodeMSRImmAndHints(u32 insn) {
 
     if (op == 0 && op1 == 0) {
         switch (op2) {
-            case 0x0:
-                return OP_NOP;
-            case 0x1:
-                return OP_YIELD;
-            case 0x2:
-                return OP_WFE;
-            case 0x3:
-                return OP_WFI;
-            case 0x4:
-                return OP_SEV;
-            default:
-                return OP_UNDEFINED;
+        case 0x0:
+            return OP_NOP;
+        case 0x1:
+            return OP_YIELD;
+        case 0x2:
+            return OP_WFE;
+        case 0x3:
+            return OP_WFI;
+        case 0x4:
+            return OP_SEV;
+        default:
+            return OP_UNDEFINED;
         }
     }
 
@@ -1402,37 +1192,37 @@ Opcode ARM_Disasm::DecodeMediaMulDiv(u32 insn) {
     u32 a = BITS(insn, 12, 15);
 
     switch (op1) {
-        case 0x0:
-            if (op2_h == 0x0) {
-                if (a != 0xf)
-                    return OP_SMLAD;
-                else
-                    return OP_SMUAD;
-            } else if (op2_h == 0x1) {
-                if (a != 0xf)
-                    return OP_SMLSD;
-                else
-                    return OP_SMUSD;
-            }
-            break;
-        case 0x4:
-            if (op2_h == 0x0)
-                return OP_SMLALD;
-            else if (op2_h == 0x1)
-                return OP_SMLSLD;
-            break;
-        case 0x5:
-            if (op2_h == 0x0) {
-                if (a != 0xf)
-                    return OP_SMMLA;
-                else
-                    return OP_SMMUL;
-            } else if (op2_h == 0x3) {
-                return OP_SMMLS;
-            }
-            break;
-        default:
-            break;
+    case 0x0:
+        if (op2_h == 0x0) {
+            if (a != 0xf)
+                return OP_SMLAD;
+            else
+                return OP_SMUAD;
+        } else if (op2_h == 0x1) {
+            if (a != 0xf)
+                return OP_SMLSD;
+            else
+                return OP_SMUSD;
+        }
+        break;
+    case 0x4:
+        if (op2_h == 0x0)
+            return OP_SMLALD;
+        else if (op2_h == 0x1)
+            return OP_SMLSLD;
+        break;
+    case 0x5:
+        if (op2_h == 0x0) {
+            if (a != 0xf)
+                return OP_SMMLA;
+            else
+                return OP_SMMUL;
+        } else if (op2_h == 0x3) {
+            return OP_SMMLS;
+        }
+        break;
+    default:
+        break;
     }
 
     return OP_UNDEFINED;
@@ -1444,23 +1234,23 @@ Opcode ARM_Disasm::DecodeMedia(u32 insn) {
     u32 op2 = BITS(insn, 5, 7);
 
     switch (BITS(op1, 3, 4)) {
-        case 0x0:
-            // unsigned and signed parallel addition and subtraction
-            return DecodeParallelAddSub(insn);
-        case 0x1:
-            // Packing, unpacking, saturation, and reversal
-            return DecodePackingSaturationReversal(insn);
-        case 0x2:
-            // Signed multiply, signed and unsigned divide
-            return DecodeMediaMulDiv(insn);
-        case 0x3:
-            if (op2 == 0 && rd == 0xf)
-                return OP_USAD8;
-            if (op2 == 0 && rd != 0xf)
-                return OP_USADA8;
-            break;
-        default:
-            break;
+    case 0x0:
+        // unsigned and signed parallel addition and subtraction
+        return DecodeParallelAddSub(insn);
+    case 0x1:
+        // Packing, unpacking, saturation, and reversal
+        return DecodePackingSaturationReversal(insn);
+    case 0x2:
+        // Signed multiply, signed and unsigned divide
+        return DecodeMediaMulDiv(insn);
+    case 0x3:
+        if (op2 == 0 && rd == 0xf)
+            return OP_USAD8;
+        if (op2 == 0 && rd != 0xf)
+            return OP_USADA8;
+        break;
+    default:
+        break;
     }
 
     return OP_UNDEFINED;
@@ -1508,46 +1298,46 @@ Opcode ARM_Disasm::DecodeALU(u32 insn) {
         return OP_UNDEFINED;
     }
     switch (opcode) {
-        case 0x0:
-            return OP_AND;
-        case 0x1:
-            return OP_EOR;
-        case 0x2:
-            return OP_SUB;
-        case 0x3:
-            return OP_RSB;
-        case 0x4:
-            return OP_ADD;
-        case 0x5:
-            return OP_ADC;
-        case 0x6:
-            return OP_SBC;
-        case 0x7:
-            return OP_RSC;
-        case 0x8:
-            if (bit_s)
-                return OP_TST;
-            return OP_MRS;
-        case 0x9:
-            if (bit_s)
-                return OP_TEQ;
-            return OP_MSR;
-        case 0xa:
-            if (bit_s)
-                return OP_CMP;
-            return OP_MRS;
-        case 0xb:
-            if (bit_s)
-                return OP_CMN;
-            return OP_MSR;
-        case 0xc:
-            return OP_ORR;
-        case 0xd:
-            return OP_MOV;
-        case 0xe:
-            return OP_BIC;
-        case 0xf:
-            return OP_MVN;
+    case 0x0:
+        return OP_AND;
+    case 0x1:
+        return OP_EOR;
+    case 0x2:
+        return OP_SUB;
+    case 0x3:
+        return OP_RSB;
+    case 0x4:
+        return OP_ADD;
+    case 0x5:
+        return OP_ADC;
+    case 0x6:
+        return OP_SBC;
+    case 0x7:
+        return OP_RSC;
+    case 0x8:
+        if (bit_s)
+            return OP_TST;
+        return OP_MRS;
+    case 0x9:
+        if (bit_s)
+            return OP_TEQ;
+        return OP_MSR;
+    case 0xa:
+        if (bit_s)
+            return OP_CMP;
+        return OP_MRS;
+    case 0xb:
+        if (bit_s)
+            return OP_CMN;
+        return OP_MSR;
+    case 0xc:
+        return OP_ORR;
+    case 0xd:
+        return OP_MOV;
+    case 0xe:
+        return OP_BIC;
+    case 0xf:
+        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..300e228ed 100644
--- a/src/core/arm/disassembler/arm_disasm.h
+++ b/src/core/arm/disassembler/arm_disasm.h
@@ -3,7 +3,6 @@
 #pragma once
 
 #include <string>
-
 #include "common/common_types.h"
 
 // Note: this list of opcodes must match the list used to initialize
@@ -187,53 +186,53 @@ enum Opcode {
     OP_THUMB_SWI,
     OP_THUMB_TST,
 
-    OP_END                // must be last
+    OP_END // must be last
 };
 
 class ARM_Disasm {
- public:
-  static std::string Disassemble(u32 addr, u32 insn);
-  static Opcode Decode(u32 insn);
+public:
+    static std::string Disassemble(u32 addr, u32 insn);
+    static Opcode Decode(u32 insn);
 
- private:
-  static Opcode Decode00(u32 insn);
-  static Opcode Decode01(u32 insn);
-  static Opcode Decode10(u32 insn);
-  static Opcode Decode11(u32 insn);
-  static Opcode DecodeSyncPrimitive(u32 insn);
-  static Opcode DecodeParallelAddSub(u32 insn);
-  static Opcode DecodePackingSaturationReversal(u32 insn);
-  static Opcode DecodeMUL(u32 insn);
-  static Opcode DecodeMSRImmAndHints(u32 insn);
-  static Opcode DecodeMediaMulDiv(u32 insn);
-  static Opcode DecodeMedia(u32 insn);
-  static Opcode DecodeLDRH(u32 insn);
-  static Opcode DecodeALU(u32 insn);
+private:
+    static Opcode Decode00(u32 insn);
+    static Opcode Decode01(u32 insn);
+    static Opcode Decode10(u32 insn);
+    static Opcode Decode11(u32 insn);
+    static Opcode DecodeSyncPrimitive(u32 insn);
+    static Opcode DecodeParallelAddSub(u32 insn);
+    static Opcode DecodePackingSaturationReversal(u32 insn);
+    static Opcode DecodeMUL(u32 insn);
+    static Opcode DecodeMSRImmAndHints(u32 insn);
+    static Opcode DecodeMediaMulDiv(u32 insn);
+    static Opcode DecodeMedia(u32 insn);
+    static Opcode DecodeLDRH(u32 insn);
+    static Opcode DecodeALU(u32 insn);
 
-  static std::string DisassembleALU(Opcode opcode, u32 insn);
-  static std::string DisassembleBranch(u32 addr, Opcode opcode, u32 insn);
-  static std::string DisassembleBX(u32 insn);
-  static std::string DisassembleBKPT(u32 insn);
-  static std::string DisassembleCLZ(u32 insn);
-  static std::string DisassembleMediaMulDiv(Opcode opcode, u32 insn);
-  static std::string DisassembleMemblock(Opcode opcode, u32 insn);
-  static std::string DisassembleMem(u32 insn);
-  static std::string DisassembleMemHalf(u32 insn);
-  static std::string DisassembleMCR(Opcode opcode, u32 insn);
-  static std::string DisassembleMLA(Opcode opcode, u32 insn);
-  static std::string DisassembleUMLAL(Opcode opcode, u32 insn);
-  static std::string DisassembleMUL(Opcode opcode, u32 insn);
-  static std::string DisassembleMRS(u32 insn);
-  static std::string DisassembleMSR(u32 insn);
-  static std::string DisassembleNoOperands(Opcode opcode, u32 insn);
-  static std::string DisassembleParallelAddSub(Opcode opcode, u32 insn);
-  static std::string DisassemblePKH(u32 insn);
-  static std::string DisassemblePLD(u32 insn);
-  static std::string DisassembleREV(Opcode opcode, u32 insn);
-  static std::string DisassembleREX(Opcode opcode, u32 insn);
-  static std::string DisassembleSAT(Opcode opcode, u32 insn);
-  static std::string DisassembleSEL(u32 insn);
-  static std::string DisassembleSWI(u32 insn);
-  static std::string DisassembleSWP(Opcode opcode, u32 insn);
-  static std::string DisassembleXT(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 DisassembleBX(u32 insn);
+    static std::string DisassembleBKPT(u32 insn);
+    static std::string DisassembleCLZ(u32 insn);
+    static std::string DisassembleMediaMulDiv(Opcode opcode, u32 insn);
+    static std::string DisassembleMemblock(Opcode opcode, u32 insn);
+    static std::string DisassembleMem(u32 insn);
+    static std::string DisassembleMemHalf(u32 insn);
+    static std::string DisassembleMCR(Opcode opcode, u32 insn);
+    static std::string DisassembleMLA(Opcode opcode, u32 insn);
+    static std::string DisassembleUMLAL(Opcode opcode, u32 insn);
+    static std::string DisassembleMUL(Opcode opcode, u32 insn);
+    static std::string DisassembleMRS(u32 insn);
+    static std::string DisassembleMSR(u32 insn);
+    static std::string DisassembleNoOperands(Opcode opcode, u32 insn);
+    static std::string DisassembleParallelAddSub(Opcode opcode, u32 insn);
+    static std::string DisassemblePKH(u32 insn);
+    static std::string DisassemblePLD(u32 insn);
+    static std::string DisassembleREV(Opcode opcode, u32 insn);
+    static std::string DisassembleREX(Opcode opcode, u32 insn);
+    static std::string DisassembleSAT(Opcode opcode, u32 insn);
+    static std::string DisassembleSEL(u32 insn);
+    static std::string DisassembleSWI(u32 insn);
+    static std::string DisassembleSWP(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..6863c103a 100644
--- a/src/core/arm/disassembler/load_symbol_map.cpp
+++ b/src/core/arm/disassembler/load_symbol_map.cpp
@@ -5,10 +5,8 @@
 #include <sstream>
 #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/dynarmic/arm_dynarmic.cpp b/src/core/arm/dynarmic/arm_dynarmic.cpp
index a521aec7c..b4444c869 100644
--- a/src/core/arm/dynarmic/arm_dynarmic.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic.cpp
@@ -2,11 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <dynarmic/dynarmic.h>
 #include "common/assert.h"
 #include "common/microprofile.h"
-
-#include <dynarmic/dynarmic.h>
-
 #include "core/arm/dynarmic/arm_dynarmic.h"
 #include "core/arm/dyncom/arm_dyncom_interpreter.h"
 #include "core/core.h"
diff --git a/src/core/arm/dynarmic/arm_dynarmic.h b/src/core/arm/dynarmic/arm_dynarmic.h
index d493cabd5..ced86d29b 100644
--- a/src/core/arm/dynarmic/arm_dynarmic.h
+++ b/src/core/arm/dynarmic/arm_dynarmic.h
@@ -5,11 +5,8 @@
 #pragma once
 
 #include <memory>
-
 #include <dynarmic/dynarmic.h>
-
 #include "common/common_types.h"
-
 #include "core/arm/arm_interface.h"
 #include "core/arm/skyeye_common/armstate.h"
 
diff --git a/src/core/arm/dyncom/arm_dyncom.cpp b/src/core/arm/dyncom/arm_dyncom.cpp
index d84917529..34c7f945e 100644
--- a/src/core/arm/dyncom/arm_dyncom.cpp
+++ b/src/core/arm/dyncom/arm_dyncom.cpp
@@ -4,16 +4,13 @@
 
 #include <cstring>
 #include <memory>
-
-#include "core/arm/skyeye_common/armstate.h"
-#include "core/arm/skyeye_common/armsupp.h"
-#include "core/arm/skyeye_common/vfp/vfp.h"
-
 #include "core/arm/dyncom/arm_dyncom.h"
 #include "core/arm/dyncom/arm_dyncom_interpreter.h"
 #include "core/arm/dyncom/arm_dyncom_run.h"
 #include "core/arm/dyncom/arm_dyncom_trans.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/core.h"
 #include "core/core_timing.h"
 
@@ -21,8 +18,7 @@ ARM_DynCom::ARM_DynCom(PrivilegeMode initial_mode) {
     state = std::make_unique<ARMul_State>(initial_mode);
 }
 
-ARM_DynCom::~ARM_DynCom() {
-}
+ARM_DynCom::~ARM_DynCom() {}
 
 void ARM_DynCom::ClearInstructionCache() {
     state->instruction_cache.clear();
diff --git a/src/core/arm/dyncom/arm_dyncom.h b/src/core/arm/dyncom/arm_dyncom.h
index 70f71a828..65db1f0f9 100644
--- a/src/core/arm/dyncom/arm_dyncom.h
+++ b/src/core/arm/dyncom/arm_dyncom.h
@@ -5,9 +5,7 @@
 #pragma once
 
 #include <memory>
-
 #include "common/common_types.h"
-
 #include "core/arm/arm_interface.h"
 #include "core/arm/skyeye_common/arm_regformat.h"
 #include "core/arm/skyeye_common/armstate.h"
diff --git a/src/core/arm/dyncom/arm_dyncom_dec.cpp b/src/core/arm/dyncom/arm_dyncom_dec.cpp
index 247d379e3..64dcaae08 100644
--- a/src/core/arm/dyncom/arm_dyncom_dec.cpp
+++ b/src/core/arm/dyncom/arm_dyncom_dec.cpp
@@ -5,6 +5,7 @@
 #include "core/arm/dyncom/arm_dyncom_dec.h"
 #include "core/arm/skyeye_common/armsupp.h"
 
+// clang-format off
 const InstructionSetEncodingItem arm_instruction[] = {
     { "vmla", 5, ARMVFP2,      { 23, 27, 0x1C, 20, 21, 0x0, 9, 11, 0x5, 6, 6, 0, 4, 4, 0 }},
     { "vmls", 5, ARMVFP2,      { 23, 27, 0x1C, 20, 21, 0x0, 9, 11, 0x5, 6, 6, 1, 4, 4, 0 }},
@@ -206,6 +207,7 @@ const InstructionSetEncodingItem arm_instruction[] = {
     { "bbl", 1, 0,         { 25, 27, 0x00000005 }},
 };
 
+
 const InstructionSetEncodingItem arm_exclusion_code[] = {
     { "vmla", 0, ARMVFP2,      { 0 }},
     { "vmls", 0, ARMVFP2,      { 0 }},
@@ -411,6 +413,7 @@ const InstructionSetEncodingItem arm_exclusion_code[] = {
     { "blx_1_thumb", 0, INVALID, { 0 }}, // Should be located at table[-2]
     { "invalid", 0, INVALID,     { 0 }}
 };
+// clang-format on
 
 ARMDecodeStatus DecodeARMInstruction(u32 instr, s32* idx) {
     int n = 0;
@@ -427,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;
@@ -448,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 {
-    SUCCESS,
-    FAILURE
-};
+enum class ARMDecodeStatus { 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..7b8616702 100644
--- a/src/core/arm/dyncom/arm_dyncom_interpreter.cpp
+++ b/src/core/arm/dyncom/arm_dyncom_interpreter.cpp
@@ -6,34 +6,31 @@
 
 #include <algorithm>
 #include <cstdio>
-
 #include "common/common_types.h"
 #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/gdbstub/gdbstub.h"
+#include "core/hle/svc.h"
+#include "core/memory.h"
 
-#define RM    BITS(sht_oper, 0, 3)
-#define RS    BITS(sht_oper, 8, 11)
+#define RM BITS(sht_oper, 0, 3)
+#define RS BITS(sht_oper, 8, 11)
 
-#define glue(x, y)            x ## y
-#define DPO(s)                glue(DataProcessingOperands, s)
+#define glue(x, y) x##y
+#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 +229,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 MLnS(s)      glue(MLnS, s)
-#define LdnStM(s)    glue(LdnStM, s)
+#define LnSWoUB(s) glue(LnSWoUB, s)
+#define MLnS(s) glue(MLnS, s)
+#define LdnStM(s) glue(LdnStM, s)
 
-#define W_BIT        BIT(inst, 21)
-#define U_BIT        BIT(inst, 23)
-#define I_BIT        BIT(inst, 25)
-#define P_BIT        BIT(inst, 24)
-#define OFFSET_12    BITS(inst, 0, 11)
+#define W_BIT BIT(inst, 21)
+#define U_BIT BIT(inst, 23)
+#define I_BIT BIT(inst, 25)
+#define P_BIT BIT(inst, 24)
+#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 +270,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 +283,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 +302,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 +317,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 +337,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 +389,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 +439,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 +459,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 +475,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 +487,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) {
-    unsigned int Rn     = BITS(inst, 16, 19);
-    unsigned int immedH = BITS(inst,  8, 11);
-    unsigned int immedL = BITS(inst,  0,  3);
+static void MLnS(ImmediatePreIndexed)(ARMul_State* cpu, unsigned int inst,
+                                      unsigned int& virt_addr) {
+    unsigned int Rn = BITS(inst, 16, 19);
+    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 +507,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) {
-    unsigned int Rn     = BITS(inst, 16, 19);
-    unsigned int immedH = BITS(inst,  8, 11);
-    unsigned int immedL = BITS(inst,  0,  3);
+static void MLnS(ImmediatePostIndexed)(ARMul_State* cpu, unsigned int inst,
+                                       unsigned int& virt_addr) {
+    unsigned int Rn = BITS(inst, 16, 19);
+    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 +527,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 +549,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 +566,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 +582,9 @@ static void LdnStM(IncrementAfter)(ARMul_State* cpu, unsigned int inst, unsigned
     unsigned int i = BITS(inst, 0, 15);
     int count = 0;
 
-    while(i) {
-        if (i & 1) count++;
+    while (i) {
+        if (i & 1)
+            count++;
         i = i >> 1;
     }
 
@@ -587,8 +598,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) {
-        if(i & 1) count++;
+    while (i) {
+        if (i & 1)
+            count++;
         i = i >> 1;
     }
     unsigned int rn = CHECK_READ_REG15_WA(cpu, Rn);
@@ -601,7 +613,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 +706,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 +751,12 @@ get_addr_fp_t GetAddressingOpLoadStoreT(unsigned int inst) {
     return nullptr;
 }
 
-enum {
-    FETCH_SUCCESS,
-    FETCH_FAILURE
-};
+enum { 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 +765,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 +802,21 @@ static ThumbDecodeStatus DecodeThumbInstruction(u32 inst, u32 addr, u32* arm_ins
     return ret;
 }
 
-enum {
-    KEEP_GOING,
-    FETCH_EXCEPTION
-};
+enum { 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 +828,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, "cpsr=0x%x, cpu->TFlag=%d, r15=0x%x", cpu->Cpsr, cpu->TFlag, cpu->Reg[15]);
+        LOG_ERROR(Core_ARM11, "Decode failure.\tPC : [0x%x]\tInstruction : %s [%x]", phys_addr,
+                  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 +894,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 >> 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;}
+    if ((x >> 16) == 0) {
+        n = n + 16;
+        x = x << 16;
+    }
+    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 +924,698 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) {
 
     GDBStub::BreakpointAddress breakpoint_data;
 
-    #undef RM
-    #undef RS
-
-    #define CRn             inst_cream->crn
-    #define OPCODE_1        inst_cream->opcode_1
-    #define OPCODE_2        inst_cream->opcode_2
-    #define CRm             inst_cream->crm
-    #define RD              cpu->Reg[inst_cream->Rd]
-    #define RD2             cpu->Reg[inst_cream->Rd + 1]
-    #define RN              cpu->Reg[inst_cream->Rn]
-    #define RM              cpu->Reg[inst_cream->Rm]
-    #define RS              cpu->Reg[inst_cream->Rs]
-    #define RDHI            cpu->Reg[inst_cream->RdHi]
-    #define RDLO            cpu->Reg[inst_cream->RdLo]
-    #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 SHIFTER_OPERAND inst_cream->shtop_func(cpu, inst_cream->shifter_operand)
-
-    #define FETCH_INST if (inst_base->br != TransExtData::NON_BRANCH) goto DISPATCH; \
-                       inst_base = (arm_inst *)&trans_cache_buf[ptr]
-
-    #define INC_PC(l)   ptr += sizeof(arm_inst) + l
-    #define INC_PC_STUB ptr += sizeof(arm_inst)
-
-#define GDB_BP_CHECK \
-    cpu->Cpsr &= ~(1 << 5); \
-    cpu->Cpsr |= cpu->TFlag << 5; \
-    if (GDBStub::g_server_enabled) { \
-        if (GDBStub::IsMemoryBreak() || (breakpoint_data.type != GDBStub::BreakpointType::None && PC == breakpoint_data.address)) { \
-            GDBStub::Break(); \
-            goto END; \
-        } \
+#undef RM
+#undef RS
+
+#define CRn inst_cream->crn
+#define OPCODE_1 inst_cream->opcode_1
+#define OPCODE_2 inst_cream->opcode_2
+#define CRm inst_cream->crm
+#define RD cpu->Reg[inst_cream->Rd]
+#define RD2 cpu->Reg[inst_cream->Rd + 1]
+#define RN cpu->Reg[inst_cream->Rn]
+#define RM cpu->Reg[inst_cream->Rm]
+#define RS cpu->Reg[inst_cream->Rs]
+#define RDHI cpu->Reg[inst_cream->RdHi]
+#define RDLO cpu->Reg[inst_cream->RdLo]
+#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 SHIFTER_OPERAND inst_cream->shtop_func(cpu, inst_cream->shifter_operand)
+
+#define FETCH_INST                                                                                 \
+    if (inst_base->br != TransExtData::NON_BRANCH)                                                 \
+        goto DISPATCH;                                                                             \
+    inst_base = (arm_inst*)&trans_cache_buf[ptr]
+
+#define INC_PC(l) ptr += sizeof(arm_inst) + l
+#define INC_PC_STUB ptr += sizeof(arm_inst)
+
+#define GDB_BP_CHECK                                                                               \
+    cpu->Cpsr &= ~(1 << 5);                                                                        \
+    cpu->Cpsr |= cpu->TFlag << 5;                                                                  \
+    if (GDBStub::g_server_enabled) {                                                               \
+        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 \
-    GDB_BP_CHECK; \
-    if (num_instrs >= cpu->NumInstrsToExecute) goto END; \
-    num_instrs++; \
-    goto *InstLabel[inst_base->idx]
+#define GOTO_NEXT_INST                                                                             \
+    GDB_BP_CHECK;                                                                                  \
+    if (num_instrs >= cpu->NumInstrsToExecute)                                                     \
+        goto END;                                                                                  \
+    num_instrs++;                                                                                  \
+    goto* InstLabel[inst_base->idx]
 #else
-#define GOTO_NEXT_INST \
-    GDB_BP_CHECK; \
-    if (num_instrs >= cpu->NumInstrsToExecute) goto END; \
-    num_instrs++; \
-    switch(inst_base->idx) { \
-    case 0: goto VMLA_INST; \
-    case 1: goto VMLS_INST; \
-    case 2: goto VNMLA_INST; \
-    case 3: goto VNMLS_INST; \
-    case 4: goto VNMUL_INST; \
-    case 5: goto VMUL_INST; \
-    case 6: goto VADD_INST; \
-    case 7: goto VSUB_INST; \
-    case 8: goto VDIV_INST; \
-    case 9: goto VMOVI_INST; \
-    case 10: goto VMOVR_INST; \
-    case 11: goto VABS_INST; \
-    case 12: goto VNEG_INST; \
-    case 13: goto VSQRT_INST; \
-    case 14: goto VCMP_INST; \
-    case 15: goto VCMP2_INST; \
-    case 16: goto VCVTBDS_INST; \
-    case 17: goto VCVTBFF_INST; \
-    case 18: goto VCVTBFI_INST; \
-    case 19: goto VMOVBRS_INST; \
-    case 20: goto VMSR_INST; \
-    case 21: goto VMOVBRC_INST; \
-    case 22: goto VMRS_INST; \
-    case 23: goto VMOVBCR_INST; \
-    case 24: goto VMOVBRRSS_INST; \
-    case 25: goto VMOVBRRD_INST; \
-    case 26: goto VSTR_INST; \
-    case 27: goto VPUSH_INST; \
-    case 28: goto VSTM_INST; \
-    case 29: goto VPOP_INST; \
-    case 30: goto VLDR_INST; \
-    case 31: goto VLDM_INST ; \
-    case 32: goto SRS_INST; \
-    case 33: goto RFE_INST; \
-    case 34: goto BKPT_INST; \
-    case 35: goto BLX_INST; \
-    case 36: goto CPS_INST; \
-    case 37: goto PLD_INST; \
-    case 38: goto SETEND_INST; \
-    case 39: goto CLREX_INST; \
-    case 40: goto REV16_INST; \
-    case 41: goto USAD8_INST; \
-    case 42: goto SXTB_INST; \
-    case 43: goto UXTB_INST; \
-    case 44: goto SXTH_INST; \
-    case 45: goto SXTB16_INST; \
-    case 46: goto UXTH_INST; \
-    case 47: goto UXTB16_INST; \
-    case 48: goto CPY_INST; \
-    case 49: goto UXTAB_INST; \
-    case 50: goto SSUB8_INST; \
-    case 51: goto SHSUB8_INST; \
-    case 52: goto SSUBADDX_INST; \
-    case 53: goto STREX_INST; \
-    case 54: goto STREXB_INST; \
-    case 55: goto SWP_INST; \
-    case 56: goto SWPB_INST; \
-    case 57: goto SSUB16_INST; \
-    case 58: goto SSAT16_INST; \
-    case 59: goto SHSUBADDX_INST; \
-    case 60: goto QSUBADDX_INST; \
-    case 61: goto SHADDSUBX_INST; \
-    case 62: goto SHADD8_INST; \
-    case 63: goto SHADD16_INST; \
-    case 64: goto SEL_INST; \
-    case 65: goto SADDSUBX_INST; \
-    case 66: goto SADD8_INST; \
-    case 67: goto SADD16_INST; \
-    case 68: goto SHSUB16_INST; \
-    case 69: goto UMAAL_INST; \
-    case 70: goto UXTAB16_INST; \
-    case 71: goto USUBADDX_INST; \
-    case 72: goto USUB8_INST; \
-    case 73: goto USUB16_INST; \
-    case 74: goto USAT16_INST; \
-    case 75: goto USADA8_INST; \
-    case 76: goto UQSUBADDX_INST; \
-    case 77: goto UQSUB8_INST; \
-    case 78: goto UQSUB16_INST; \
-    case 79: goto UQADDSUBX_INST; \
-    case 80: goto UQADD8_INST; \
-    case 81: goto UQADD16_INST; \
-    case 82: goto SXTAB_INST; \
-    case 83: goto UHSUBADDX_INST; \
-    case 84: goto UHSUB8_INST; \
-    case 85: goto UHSUB16_INST; \
-    case 86: goto UHADDSUBX_INST; \
-    case 87: goto UHADD8_INST; \
-    case 88: goto UHADD16_INST; \
-    case 89: goto UADDSUBX_INST; \
-    case 90: goto UADD8_INST; \
-    case 91: goto UADD16_INST; \
-    case 92: goto SXTAH_INST; \
-    case 93: goto SXTAB16_INST; \
-    case 94: goto QADD8_INST; \
-    case 95: goto BXJ_INST; \
-    case 96: goto CLZ_INST; \
-    case 97: goto UXTAH_INST; \
-    case 98: goto BX_INST; \
-    case 99: goto REV_INST; \
-    case 100: goto BLX_INST; \
-    case 101: 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; \
+#define GOTO_NEXT_INST                                                                             \
+    GDB_BP_CHECK;                                                                                  \
+    if (num_instrs >= cpu->NumInstrsToExecute)                                                     \
+        goto END;                                                                                  \
+    num_instrs++;                                                                                  \
+    switch (inst_base->idx) {                                                                      \
+    case 0:                                                                                        \
+        goto VMLA_INST;                                                                            \
+    case 1:                                                                                        \
+        goto VMLS_INST;                                                                            \
+    case 2:                                                                                        \
+        goto VNMLA_INST;                                                                           \
+    case 3:                                                                                        \
+        goto VNMLS_INST;                                                                           \
+    case 4:                                                                                        \
+        goto VNMUL_INST;                                                                           \
+    case 5:                                                                                        \
+        goto VMUL_INST;                                                                            \
+    case 6:                                                                                        \
+        goto VADD_INST;                                                                            \
+    case 7:                                                                                        \
+        goto VSUB_INST;                                                                            \
+    case 8:                                                                                        \
+        goto VDIV_INST;                                                                            \
+    case 9:                                                                                        \
+        goto VMOVI_INST;                                                                           \
+    case 10:                                                                                       \
+        goto VMOVR_INST;                                                                           \
+    case 11:                                                                                       \
+        goto VABS_INST;                                                                            \
+    case 12:                                                                                       \
+        goto VNEG_INST;                                                                            \
+    case 13:                                                                                       \
+        goto VSQRT_INST;                                                                           \
+    case 14:                                                                                       \
+        goto VCMP_INST;                                                                            \
+    case 15:                                                                                       \
+        goto VCMP2_INST;                                                                           \
+    case 16:                                                                                       \
+        goto VCVTBDS_INST;                                                                         \
+    case 17:                                                                                       \
+        goto VCVTBFF_INST;                                                                         \
+    case 18:                                                                                       \
+        goto VCVTBFI_INST;                                                                         \
+    case 19:                                                                                       \
+        goto VMOVBRS_INST;                                                                         \
+    case 20:                                                                                       \
+        goto VMSR_INST;                                                                            \
+    case 21:                                                                                       \
+        goto VMOVBRC_INST;                                                                         \
+    case 22:                                                                                       \
+        goto VMRS_INST;                                                                            \
+    case 23:                                                                                       \
+        goto VMOVBCR_INST;                                                                         \
+    case 24:                                                                                       \
+        goto VMOVBRRSS_INST;                                                                       \
+    case 25:                                                                                       \
+        goto VMOVBRRD_INST;                                                                        \
+    case 26:                                                                                       \
+        goto VSTR_INST;                                                                            \
+    case 27:                                                                                       \
+        goto VPUSH_INST;                                                                           \
+    case 28:                                                                                       \
+        goto VSTM_INST;                                                                            \
+    case 29:                                                                                       \
+        goto VPOP_INST;                                                                            \
+    case 30:                                                                                       \
+        goto VLDR_INST;                                                                            \
+    case 31:                                                                                       \
+        goto VLDM_INST;                                                                            \
+    case 32:                                                                                       \
+        goto SRS_INST;                                                                             \
+    case 33:                                                                                       \
+        goto RFE_INST;                                                                             \
+    case 34:                                                                                       \
+        goto BKPT_INST;                                                                            \
+    case 35:                                                                                       \
+        goto BLX_INST;                                                                             \
+    case 36:                                                                                       \
+        goto CPS_INST;                                                                             \
+    case 37:                                                                                       \
+        goto PLD_INST;                                                                             \
+    case 38:                                                                                       \
+        goto SETEND_INST;                                                                          \
+    case 39:                                                                                       \
+        goto CLREX_INST;                                                                           \
+    case 40:                                                                                       \
+        goto REV16_INST;                                                                           \
+    case 41:                                                                                       \
+        goto USAD8_INST;                                                                           \
+    case 42:                                                                                       \
+        goto SXTB_INST;                                                                            \
+    case 43:                                                                                       \
+        goto UXTB_INST;                                                                            \
+    case 44:                                                                                       \
+        goto SXTH_INST;                                                                            \
+    case 45:                                                                                       \
+        goto SXTB16_INST;                                                                          \
+    case 46:                                                                                       \
+        goto UXTH_INST;                                                                            \
+    case 47:                                                                                       \
+        goto UXTB16_INST;                                                                          \
+    case 48:                                                                                       \
+        goto CPY_INST;                                                                             \
+    case 49:                                                                                       \
+        goto UXTAB_INST;                                                                           \
+    case 50:                                                                                       \
+        goto SSUB8_INST;                                                                           \
+    case 51:                                                                                       \
+        goto SHSUB8_INST;                                                                          \
+    case 52:                                                                                       \
+        goto SSUBADDX_INST;                                                                        \
+    case 53:                                                                                       \
+        goto STREX_INST;                                                                           \
+    case 54:                                                                                       \
+        goto STREXB_INST;                                                                          \
+    case 55:                                                                                       \
+        goto SWP_INST;                                                                             \
+    case 56:                                                                                       \
+        goto SWPB_INST;                                                                            \
+    case 57:                                                                                       \
+        goto SSUB16_INST;                                                                          \
+    case 58:                                                                                       \
+        goto SSAT16_INST;                                                                          \
+    case 59:                                                                                       \
+        goto SHSUBADDX_INST;                                                                       \
+    case 60:                                                                                       \
+        goto QSUBADDX_INST;                                                                        \
+    case 61:                                                                                       \
+        goto SHADDSUBX_INST;                                                                       \
+    case 62:                                                                                       \
+        goto SHADD8_INST;                                                                          \
+    case 63:                                                                                       \
+        goto SHADD16_INST;                                                                         \
+    case 64:                                                                                       \
+        goto SEL_INST;                                                                             \
+    case 65:                                                                                       \
+        goto SADDSUBX_INST;                                                                        \
+    case 66:                                                                                       \
+        goto SADD8_INST;                                                                           \
+    case 67:                                                                                       \
+        goto SADD16_INST;                                                                          \
+    case 68:                                                                                       \
+        goto SHSUB16_INST;                                                                         \
+    case 69:                                                                                       \
+        goto UMAAL_INST;                                                                           \
+    case 70:                                                                                       \
+        goto UXTAB16_INST;                                                                         \
+    case 71:                                                                                       \
+        goto USUBADDX_INST;                                                                        \
+    case 72:                                                                                       \
+        goto USUB8_INST;                                                                           \
+    case 73:                                                                                       \
+        goto USUB16_INST;                                                                          \
+    case 74:                                                                                       \
+        goto USAT16_INST;                                                                          \
+    case 75:                                                                                       \
+        goto USADA8_INST;                                                                          \
+    case 76:                                                                                       \
+        goto UQSUBADDX_INST;                                                                       \
+    case 77:                                                                                       \
+        goto UQSUB8_INST;                                                                          \
+    case 78:                                                                                       \
+        goto UQSUB16_INST;                                                                         \
+    case 79:                                                                                       \
+        goto UQADDSUBX_INST;                                                                       \
+    case 80:                                                                                       \
+        goto UQADD8_INST;                                                                          \
+    case 81:                                                                                       \
+        goto UQADD16_INST;                                                                         \
+    case 82:                                                                                       \
+        goto SXTAB_INST;                                                                           \
+    case 83:                                                                                       \
+        goto UHSUBADDX_INST;                                                                       \
+    case 84:                                                                                       \
+        goto UHSUB8_INST;                                                                          \
+    case 85:                                                                                       \
+        goto UHSUB16_INST;                                                                         \
+    case 86:                                                                                       \
+        goto UHADDSUBX_INST;                                                                       \
+    case 87:                                                                                       \
+        goto UHADD8_INST;                                                                          \
+    case 88:                                                                                       \
+        goto UHADD16_INST;                                                                         \
+    case 89:                                                                                       \
+        goto UADDSUBX_INST;                                                                        \
+    case 90:                                                                                       \
+        goto UADD8_INST;                                                                           \
+    case 91:                                                                                       \
+        goto UADD16_INST;                                                                          \
+    case 92:                                                                                       \
+        goto SXTAH_INST;                                                                           \
+    case 93:                                                                                       \
+        goto SXTAB16_INST;                                                                         \
+    case 94:                                                                                       \
+        goto QADD8_INST;                                                                           \
+    case 95:                                                                                       \
+        goto BXJ_INST;                                                                             \
+    case 96:                                                                                       \
+        goto CLZ_INST;                                                                             \
+    case 97:                                                                                       \
+        goto UXTAH_INST;                                                                           \
+    case 98:                                                                                       \
+        goto BX_INST;                                                                              \
+    case 99:                                                                                       \
+        goto REV_INST;                                                                             \
+    case 100:                                                                                      \
+        goto BLX_INST;                                                                             \
+    case 101:                                                                                      \
+        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_ZFLAG(dst)    (cpu->ZFlag = dst ? 0 : 1)
-    #define UPDATE_CFLAG_WITH_SC (cpu->CFlag = cpu->shifter_carry_out)
-
-    #define SAVE_NZCVT cpu->Cpsr = (cpu->Cpsr & 0x0fffffdf) | \
-                      (cpu->NFlag << 31) | \
-                      (cpu->ZFlag << 30) | \
-                      (cpu->CFlag << 29) | \
-                      (cpu->VFlag << 28) | \
-                      (cpu->TFlag << 5)
-    #define LOAD_NZCVT cpu->NFlag = (cpu->Cpsr >> 31);     \
-                       cpu->ZFlag = (cpu->Cpsr >> 30) & 1; \
-                       cpu->CFlag = (cpu->Cpsr >> 29) & 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])
-
-    // GCC and Clang have a C++ extension to support a lookup table of labels. Otherwise, fallback
-    // to a clunky switch statement.
+#define UPDATE_NFLAG(dst) (cpu->NFlag = BIT(dst, 31) ? 1 : 0)
+#define UPDATE_ZFLAG(dst) (cpu->ZFlag = dst ? 0 : 1)
+#define UPDATE_CFLAG_WITH_SC (cpu->CFlag = cpu->shifter_carry_out)
+
+#define SAVE_NZCVT                                                                                 \
+    cpu->Cpsr = (cpu->Cpsr & 0x0fffffdf) | (cpu->NFlag << 31) | (cpu->ZFlag << 30) |               \
+                (cpu->CFlag << 29) | (cpu->VFlag << 28) | (cpu->TFlag << 5)
+#define LOAD_NZCVT                                                                                 \
+    cpu->NFlag = (cpu->Cpsr >> 31);                                                                \
+    cpu->ZFlag = (cpu->Cpsr >> 30) & 1;                                                            \
+    cpu->CFlag = (cpu->Cpsr >> 29) & 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])
+
+// 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[] = {
-        &&VMLA_INST, &&VMLS_INST, &&VNMLA_INST, &&VNMLS_INST, &&VNMUL_INST, &&VMUL_INST, &&VADD_INST, &&VSUB_INST,
-        &&VDIV_INST, &&VMOVI_INST, &&VMOVR_INST, &&VABS_INST, &&VNEG_INST, &&VSQRT_INST, &&VCMP_INST, &&VCMP2_INST, &&VCVTBDS_INST,
-        &&VCVTBFF_INST, &&VCVTBFI_INST, &&VMOVBRS_INST, &&VMSR_INST, &&VMOVBRC_INST, &&VMRS_INST, &&VMOVBCR_INST, &&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
-        };
+    void* InstLabel[] = {&&VMLA_INST,
+                         &&VMLS_INST,
+                         &&VNMLA_INST,
+                         &&VNMLS_INST,
+                         &&VNMUL_INST,
+                         &&VMUL_INST,
+                         &&VADD_INST,
+                         &&VSUB_INST,
+                         &&VDIV_INST,
+                         &&VMOVI_INST,
+                         &&VMOVR_INST,
+                         &&VABS_INST,
+                         &&VNEG_INST,
+                         &&VSQRT_INST,
+                         &&VCMP_INST,
+                         &&VCMP2_INST,
+                         &&VCVTBDS_INST,
+                         &&VCVTBFF_INST,
+                         &&VCVTBFI_INST,
+                         &&VMOVBRS_INST,
+                         &&VMSR_INST,
+                         &&VMOVBRC_INST,
+                         &&VMRS_INST,
+                         &&VMOVBCR_INST,
+                         &&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 +1624,517 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) {
     int ptr;
 
     LOAD_NZCVT;
-    DISPATCH:
-    {
-        if (!cpu->NirqSig) {
-            if (!(cpu->Cpsr & 0x80)) {
-                goto END;
-            }
+DISPATCH : {
+    if (!cpu->NirqSig) {
+        if (!(cpu->Cpsr & 0x80)) {
+            goto END;
         }
+    }
 
-        if (cpu->TFlag)
-            cpu->Reg[15] &= 0xfffffffe;
-        else
-            cpu->Reg[15] &= 0xfffffffc;
-
-        // Find the cached instruction cream, otherwise translate it...
-        auto itr = cpu->instruction_cache.find(cpu->Reg[15]);
-        if (itr != cpu->instruction_cache.end()) {
-            ptr = itr->second;
-        } else if (cpu->NumInstrsToExecute != 1) {
-            if (InterpreterTranslateBlock(cpu, ptr, cpu->Reg[15]) == FETCH_EXCEPTION)
-                goto END;
-        } else {
-            if (InterpreterTranslateSingle(cpu, ptr, cpu->Reg[15]) == FETCH_EXCEPTION)
-                goto END;
-        }
+    if (cpu->TFlag)
+        cpu->Reg[15] &= 0xfffffffe;
+    else
+        cpu->Reg[15] &= 0xfffffffc;
+
+    // Find the cached instruction cream, otherwise translate it...
+    auto itr = cpu->instruction_cache.find(cpu->Reg[15]);
+    if (itr != cpu->instruction_cache.end()) {
+        ptr = itr->second;
+    } else if (cpu->NumInstrsToExecute != 1) {
+        if (InterpreterTranslateBlock(cpu, ptr, cpu->Reg[15]) == FETCH_EXCEPTION)
+            goto END;
+    } else {
+        if (InterpreterTranslateSingle(cpu, ptr, cpu->Reg[15]) == FETCH_EXCEPTION)
+            goto END;
+    }
 
-        // Find breakpoint if one exists within the block
-        if (GDBStub::g_server_enabled && GDBStub::IsConnected()) {
-            breakpoint_data = GDBStub::GetNextBreakpointFromAddress(cpu->Reg[15], GDBStub::BreakpointType::Execute);
-        }
+    // Find breakpoint if one exists within the block
+    if (GDBStub::g_server_enabled && GDBStub::IsConnected()) {
+        breakpoint_data =
+            GDBStub::GetNextBreakpointFromAddress(cpu->Reg[15], GDBStub::BreakpointType::Execute);
+    }
 
-        inst_base = (arm_inst *)&trans_cache_buf[ptr];
-        GOTO_NEXT_INST;
+    inst_base = (arm_inst*)&trans_cache_buf[ptr];
+    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:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            adc_inst* const inst_cream = (adc_inst*)inst_base->component;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(adc_inst));
+    FETCH_INST;
+    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;
-            if (inst_cream->Rn == 15)
-                rn_val += 2 * cpu->GetInstructionSize();
+        u32 rn_val = CHECK_READ_REG15_WA(cpu, inst_cream->Rn);
 
-            bool carry;
-            bool overflow;
-            RD = AddWithCarry(rn_val, SHIFTER_OPERAND, cpu->CFlag, &carry, &overflow);
+        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->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;
+        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;
         }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(adc_inst));
-        FETCH_INST;
-        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;
-            }
+        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:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            and_inst* const inst_cream = (and_inst*)inst_base->component;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(add_inst));
+    FETCH_INST;
+    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 rop = SHIFTER_OPERAND;
+        u32 lop = RN;
+        u32 rop = SHIFTER_OPERAND;
 
-            if (inst_cream->Rn == 15)
-                lop += 2 * cpu->GetInstructionSize();
+        if (inst_cream->Rn == 15)
+            lop += 2 * cpu->GetInstructionSize();
 
-            RD = lop & rop;
+        RD = lop & rop;
 
-            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);
-                UPDATE_CFLAG_WITH_SC;
-            }
-            if (inst_cream->Rd == 15) {
-                INC_PC(sizeof(and_inst));
-                goto DISPATCH;
+        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);
+            UPDATE_CFLAG_WITH_SC;
         }
-        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));
+        if (inst_cream->Rd == 15) {
+            INC_PC(sizeof(and_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:
-    {
-        bic_inst *inst_cream = (bic_inst *)inst_base->component;
-        if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
-            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) {
-                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();
+    INC_PC(sizeof(bbl_inst));
+    goto DISPATCH;
+}
+BIC_INST : {
+    bic_inst* inst_cream = (bic_inst*)inst_base->component;
+    if ((inst_base->cond == ConditionCode::AL) || CondPassed(cpu, inst_base->cond)) {
+        u32 lop = RN;
+        if (inst_cream->Rn == 15) {
+            lop += 2 * cpu->GetInstructionSize();
         }
-        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);
+        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;
             }
-            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:
-    BXJ_INST:
-    {
-        // Note that only the 'fail' case of BXJ is emulated. This is because
-        // the facilities for Jazelle emulation are not implemented.
-        //
-        // 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.
-        //
-        // 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)) {
-            bx_inst* const inst_cream = (bx_inst*)inst_base->component;
+BX_INST:
+BXJ_INST : {
+    // Note that only the 'fail' case of BXJ is emulated. This is because
+    // the facilities for Jazelle emulation are not implemented.
+    //
+    // 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.
+    //
+    // This is sufficient for citra, as the CPU for the 3DS does not implement Jazelle.
 
-            u32 address = RM;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        bx_inst* const inst_cream = (bx_inst*)inst_base->component;
 
-            if (inst_cream->Rm == 15)
-                address += 2 * cpu->GetInstructionSize();
+        u32 address = RM;
 
-            cpu->TFlag   = address & 1;
-            cpu->Reg[15] = address & 0xfffffffe;
-            INC_PC(sizeof(bx_inst));
-            goto DISPATCH;
-        }
+        if (inst_cream->Rm == 15)
+            address += 2 * cpu->GetInstructionSize();
 
-        cpu->Reg[15] += cpu->GetInstructionSize();
+        cpu->TFlag = address & 1;
+        cpu->Reg[15] = address & 0xfffffffe;
         INC_PC(sizeof(bx_inst));
         goto DISPATCH;
     }
 
-    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(bx_inst));
+    goto DISPATCH;
+}
+
+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();
-        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);
+        if (inst_cream->mmod) {
+            cpu->Cpsr = (cpu->Cpsr & 0xffffffe0) | inst_cream->mode;
+            cpu->ChangePrivilegeMode(inst_cream->mode);
         }
-        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(cps_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+CPY_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        mov_inst* inst_cream = (mov_inst*)inst_base->component;
+
+        RD = SHIFTER_OPERAND;
+        if (inst_cream->Rd == 15) {
+            INC_PC(sizeof(mov_inst));
+            goto DISPATCH;
         }
-        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(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();
         }
-        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;
-            }
-            if (inst_cream->mmod) {
-                cpu->Cpsr = (cpu->Cpsr & 0xffffffe0) | inst_cream->mode;
-                cpu->ChangePrivilegeMode(inst_cream->mode);
+        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) {
+            INC_PC(sizeof(eor_inst));
+            goto DISPATCH;
         }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(cps_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
     }
-    CPY_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            mov_inst* inst_cream = (mov_inst*)inst_base->component;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(eor_inst));
+    FETCH_INST;
+    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;
-            if (inst_cream->Rd == 15) {
-                INC_PC(sizeof(mov_inst));
-                goto DISPATCH;
-            }
-        }
-        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;
+        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;
                 }
-            } 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;
+            if (BIT(inst, 13)) {
+                if (cpu->Mode == USER32MODE)
+                    cpu->Reg[13] = cpu->ReadMemory32(addr);
+                else
+                    cpu->Reg_usr[0] = cpu->ReadMemory32(addr);
+
+                addr += 4;
             }
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(eor_inst));
-        FETCH_INST;
-        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);
-
-            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, 14)) {
+                if (cpu->Mode == USER32MODE)
+                    cpu->Reg[14] = cpu->ReadMemory32(addr);
+                else
+                    cpu->Reg_usr[1] = 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;
                     }
-                }
-                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)
-                        cpu->Reg[14] = cpu->ReadMemory32(addr);
-                    else
-                        cpu->Reg_usr[1] = cpu->ReadMemory32(addr);
-
+            }
+        } 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;
                 }
-            } 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)) {
-                INC_PC(sizeof(ldst_inst));
-                goto DISPATCH;
+            if (CurrentModeHasSPSR) {
+                cpu->Cpsr = cpu->Spsr_copy;
+                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:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            sxth_inst* inst_cream = (sxth_inst*)inst_base->component;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(ldst_inst));
+    FETCH_INST;
+    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);
-            if (BIT(operand2, 15)) {
-                operand2 |= 0xffff0000;
-            } else {
-                operand2 &= 0xffff;
-            }
-            RD = operand2;
+        unsigned int operand2 = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate);
+        if (BIT(operand2, 15)) {
+            operand2 |= 0xffff0000;
+        } else {
+            operand2 &= 0xffff;
         }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(sxth_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    LDR_INST:
-    {
-        ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
+        RD = operand2;
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(sxth_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+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 +2147,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();
-        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);
-            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;
-    }
-    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;
+        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);
     }
-    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);
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(ldst_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+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 previous_mode = cpu->Mode;
+        const u32 dest_index = BITS(inst_cream->inst, 12, 15);
+        const u32 previous_mode = cpu->Mode;
 
-            cpu->ChangePrivilegeMode(USER32MODE);
-            const u8 value = cpu->ReadMemory8(addr);
-            cpu->ChangePrivilegeMode(previous_mode);
+        cpu->ChangePrivilegeMode(USER32MODE);
+        const u8 value = cpu->ReadMemory8(addr);
+        cpu->ChangePrivilegeMode(previous_mode);
 
-            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[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);
 
-    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;
-
-            cpu->SetExclusiveMemoryAddress(read_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);
 
-            RD = cpu->ReadMemory32(read_addr);
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        // No dispatch since this operation should not modify R15
     }
-    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->Reg[15] += 4;
+    INC_PC(sizeof(ldst_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-            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->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        cpu->SetExclusiveMemoryAddress(read_addr);
+
+        RD = cpu->ReadMemory32(read_addr);
     }
-    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->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(generic_arm_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+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);
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        RD = cpu->ReadMemory8(read_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;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(generic_arm_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+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);
-            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;
+        RD = cpu->ReadMemory16(read_addr);
     }
-    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);
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(generic_arm_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+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);
-            const u32 previous_mode = cpu->Mode;
+        cpu->SetExclusiveMemoryAddress(read_addr);
 
-            cpu->ChangePrivilegeMode(USER32MODE);
-            const u32 value = cpu->ReadMemory32(addr);
-            cpu->ChangePrivilegeMode(previous_mode);
+        RD = cpu->ReadMemory32(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[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();
-        INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        cpu->Reg[BITS(inst_cream->inst, 12, 15)] = value;
     }
-    MCR_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            mcr_inst* inst_cream = (mcr_inst*)inst_base->component;
+    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 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);
-            }
+        unsigned int value = cpu->ReadMemory16(addr);
+        if (BIT(value, 15)) {
+            value |= 0xffff0000;
         }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(mcr_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        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 : {
+    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);
 
-    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;
+        const u32 dest_index = BITS(inst_cream->inst, 12, 15);
+        const u32 previous_mode = cpu->Mode;
 
-            LOG_ERROR(Core_ARM11, "MCRR executed | Coprocessor: %u, CRm %u, opc1: %u, Rt: %u, Rt2: %u",
-                      inst_cream->cp_num, inst_cream->crm, inst_cream->opcode_1, inst_cream->rt, inst_cream->rt2);
+        cpu->ChangePrivilegeMode(USER32MODE);
+        const u32 value = cpu->ReadMemory32(addr);
+        cpu->ChangePrivilegeMode(previous_mode);
+
+        cpu->Reg[dest_index] = value;
+    }
+    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();
-        INC_PC(sizeof(mcrr_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        LOG_ERROR(Core_ARM11, "MCRR executed | Coprocessor: %u, CRm %u, opc1: %u, Rt: %u, Rt2: %u",
+                  inst_cream->cp_num, inst_cream->crm, inst_cream->opcode_1, inst_cream->rt,
+                  inst_cream->rt2);
     }
 
-    MLA_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            mla_inst* inst_cream = (mla_inst*)inst_base->component;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(mcrr_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-            u64 rm = RM;
-            u64 rs = RS;
-            u64 rn = RN;
+MLA_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        mla_inst* inst_cream = (mla_inst*)inst_base->component;
 
-            RD = static_cast<u32>((rm * rs + rn) & 0xffffffff);
-            if (inst_cream->S) {
-                UPDATE_NFLAG(RD);
-                UPDATE_ZFLAG(RD);
-            }
+        u64 rm = RM;
+        u64 rs = RS;
+        u64 rn = RN;
+
+        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));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    MOV_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            mov_inst* inst_cream = (mov_inst*)inst_base->component;
-
-            RD = SHIFTER_OPERAND;
-            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(mov_inst));
-                goto DISPATCH;
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(mla_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+MOV_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        mov_inst* inst_cream = (mov_inst*)inst_base->component;
+
+        RD = SHIFTER_OPERAND;
+        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;
         }
-        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;
-
-            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;
-                }
-            }
+        if (inst_cream->Rd == 15) {
+            INC_PC(sizeof(mov_inst));
+            goto DISPATCH;
         }
-        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:
-    {
-        // 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;
+        if (inst_cream->cp_num == 15) {
+            const uint32_t value = cpu->ReadCP15Register(CRn, OPCODE_1, CRm, OPCODE_2);
 
-            LOG_ERROR(Core_ARM11, "MRRC executed | Coprocessor: %u, CRm %u, opc1: %u, Rt: %u, Rt2: %u",
-                      inst_cream->cp_num, inst_cream->crm, inst_cream->opcode_1, inst_cream->rt, inst_cream->rt2);
+            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(mcrr_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;
+
+        LOG_ERROR(Core_ARM11, "MRRC executed | Coprocessor: %u, CRm %u, opc1: %u, Rt: %u, Rt2: %u",
+                  inst_cream->cp_num, inst_cream->crm, inst_cream->opcode_1, inst_cream->rt,
+                  inst_cream->rt2);
     }
 
-    MRS_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            mrs_inst* inst_cream = (mrs_inst*)inst_base->component;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(mcrr_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-            if (inst_cream->R) {
-                RD = cpu->Spsr_copy;
-            } else {
-                SAVE_NZCVT;
-                RD = cpu->Cpsr;
-            }
+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) {
+            RD = cpu->Spsr_copy;
+        } else {
+            SAVE_NZCVT;
+            RD = cpu->Cpsr;
+        }
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(mrs_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+MSR_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        msr_inst* inst_cream = (msr_inst*)inst_base->component;
+        const u32 UserMask = 0xf80f0200, PrivMask = 0x000001df, StateMask = 0x01000020;
+        unsigned int inst = inst_cream->inst;
+        unsigned int operand;
+
+        if (BIT(inst, 25)) {
+            int rot_imm = BITS(inst, 8, 11) * 2;
+            operand = ROTATE_RIGHT_32(BITS(inst, 0, 7), rot_imm);
+        } else {
+            operand = cpu->Reg[BITS(inst, 0, 3)];
         }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(mrs_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    MSR_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            msr_inst* inst_cream = (msr_inst*)inst_base->component;
-            const u32 UserMask = 0xf80f0200, PrivMask = 0x000001df, StateMask = 0x01000020;
-            unsigned int inst = inst_cream->inst;
-            unsigned int operand;
-
-            if (BIT(inst, 25)) {
-                int rot_imm = BITS(inst, 8, 11) * 2;
-                operand = ROTATE_RIGHT_32(BITS(inst, 0, 7), rot_imm);
+        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)
-                        | (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;
+            SAVE_NZCVT;
 
-                cpu->Cpsr = (cpu->Cpsr & ~mask) | (operand & mask);
-                cpu->ChangePrivilegeMode(cpu->Cpsr & 0x1F);
-                LOAD_NZCVT;
-            } else {
-                if (CurrentModeHasSPSR) {
-                    mask = byte_mask & (UserMask | PrivMask | StateMask);
-                    cpu->Spsr_copy = (cpu->Spsr_copy & ~mask) | (operand & mask);
-                }
+            cpu->Cpsr = (cpu->Cpsr & ~mask) | (operand & mask);
+            cpu->ChangePrivilegeMode(cpu->Cpsr & 0x1F);
+            LOAD_NZCVT;
+        } else {
+            if (CurrentModeHasSPSR) {
+                mask = byte_mask & (UserMask | PrivMask | StateMask);
+                cpu->Spsr_copy = (cpu->Spsr_copy & ~mask) | (operand & mask);
             }
         }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(msr_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    MUL_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            mul_inst* inst_cream = (mul_inst*)inst_base->component;
-
-            u64 rm = RM;
-            u64 rs = RS;
-            RD = static_cast<u32>((rm * rs) & 0xffffffff);
-            if (inst_cream->S) {
-                UPDATE_NFLAG(RD);
-                UPDATE_ZFLAG(RD);
-            }
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(msr_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+MUL_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        mul_inst* inst_cream = (mul_inst*)inst_base->component;
+
+        u64 rm = RM;
+        u64 rs = RS;
+        RD = static_cast<u32>((rm * rs) & 0xffffffff);
+        if (inst_cream->S) {
+            UPDATE_NFLAG(RD);
+            UPDATE_ZFLAG(RD);
         }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(mul_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-    MVN_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            mvn_inst* const inst_cream = (mvn_inst*)inst_base->component;
-
-            RD = ~SHIFTER_OPERAND;
-
-            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(mvn_inst));
-                goto DISPATCH;
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(mul_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+MVN_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        mvn_inst* const inst_cream = (mvn_inst*)inst_base->component;
+
+        RD = ~SHIFTER_OPERAND;
+
+        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(mvn_inst));
+            goto DISPATCH;
         }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(mvn_inst));
-        FETCH_INST;
-        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;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(mvn_inst));
+    FETCH_INST;
+    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 rop = SHIFTER_OPERAND;
+        u32 lop = RN;
+        u32 rop = SHIFTER_OPERAND;
 
-            if (inst_cream->Rn == 15)
-                lop += 2 * cpu->GetInstructionSize();
+        if (inst_cream->Rn == 15)
+            lop += 2 * cpu->GetInstructionSize();
 
-            RD = lop | rop;
+        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) {
-                INC_PC(sizeof(orr_inst));
-                goto DISPATCH;
+        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(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 : {
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC_STUB;
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+
+PKHBT_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        pkh_inst* inst_cream = (pkh_inst*)inst_base->component;
+        RD = (RN & 0xFFFF) | ((RM << inst_cream->imm) & 0xFFFF0000);
     }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(pkh_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-    PKHBT_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            pkh_inst *inst_cream = (pkh_inst *)inst_base->component;
-            RD = (RN & 0xFFFF) | ((RM << inst_cream->imm) & 0xFFFF0000);
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(pkh_inst));
-        FETCH_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;
+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;
+}
 
-            u32 result = 0;
+PLD_INST : {
+    // Not implemented. PLD is a hint instruction, so it's optional.
 
-            // QADD
-            if (op1 == 0x00) {
-                result = rm_val + rn_val;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(pld_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-                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;
+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;
 
-                if (SubOverflow(rm_val, rn_val, result)) {
-                    result = POS(result) ? 0x80000000 : 0x7FFFFFFF;
-                    cpu->Cpsr |= (1 << 27);
-                }
-            }
-            // QDADD
-            else if (op1 == 0x02) {
-                u32 mul = (rn_val * 2);
+        u32 result = 0;
 
-                if (AddOverflow(rn_val, rn_val, rn_val * 2)) {
-                    mul = POS(mul) ? 0x80000000 : 0x7FFFFFFF;
-                    cpu->Cpsr |= (1 << 27);
-                }
+        // QADD
+        if (op1 == 0x00) {
+            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)) {
-                    result = POS(result) ? 0x80000000 : 0x7FFFFFFF;
-                    cpu->Cpsr |= (1 << 27);
-                }
+            if (SubOverflow(rm_val, rn_val, result)) {
+                result = POS(result) ? 0x80000000 : 0x7FFFFFFF;
+                cpu->Cpsr |= (1 << 27);
             }
-            // QDSUB
-            else if (op1 == 0x03) {
-                u32 mul = (rn_val * 2);
+        }
+        // QDADD
+        else if (op1 == 0x02) {
+            u32 mul = (rn_val * 2);
 
-                if (AddOverflow(rn_val, rn_val, mul)) {
-                    mul = POS(mul) ? 0x80000000 : 0x7FFFFFFF;
-                    cpu->Cpsr |= (1 << 27);
-                }
+            if (AddOverflow(rn_val, rn_val, rn_val * 2)) {
+                mul = POS(mul) ? 0x80000000 : 0x7FFFFFFF;
+                cpu->Cpsr |= (1 << 27);
+            }
 
-                result = rm_val - mul;
+            result = mul + rm_val;
 
-                if (SubOverflow(rm_val, mul, result)) {
-                    result = POS(result) ? 0x80000000 : 0x7FFFFFFF;
-                    cpu->Cpsr |= (1 << 27);
-                }
+            if (AddOverflow(rm_val, mul, result)) {
+                result = POS(result) ? 0x80000000 : 0x7FFFFFFF;
+                cpu->Cpsr |= (1 << 27);
             }
-
-            RD = result;
         }
+        // QDSUB
+        else if (op1 == 0x03) {
+            u32 mul = (rn_val * 2);
 
-        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;
+            if (AddOverflow(rn_val, rn_val, mul)) {
+                mul = POS(mul) ? 0x80000000 : 0x7FFFFFFF;
+                cpu->Cpsr |= (1 << 27);
             }
-            // 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;
+
+            result = rm_val - mul;
+
+            if (SubOverflow(rm_val, mul, result)) {
+                result = POS(result) ? 0x80000000 : 0x7FFFFFFF;
+                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();
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        RD = (lo_result & 0xFFFF) | ((hi_result & 0xFFFF) << 16);
     }
 
-    REV_INST:
-    REV16_INST:
-    REVSH_INST:
-    {
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(generic_arm_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            rev_inst* const inst_cream = (rev_inst*)inst_base->component;
+REV_INST:
+REV16_INST:
+REVSH_INST : {
 
-            const u8 op1 = inst_cream->op1;
-            const u8 op2 = inst_cream->op2;
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        rev_inst* const inst_cream = (rev_inst*)inst_base->component;
 
-            // REV
-            if (op1 == 0x03 && op2 == 0x01) {
-                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;
-            }
-        }
+        const u8 op1 = inst_cream->op1;
+        const u8 op2 = inst_cream->op2;
 
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(rev_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        // REV
+        if (op1 == 0x03 && op2 == 0x01) {
+            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;
+        }
     }
 
-    RFE_INST:
-    {
-        // RFE is unconditional
-        ldst_inst* const inst_cream = (ldst_inst*)inst_base->component;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(rev_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-        u32 address = 0;
-        inst_cream->get_addr(cpu, inst_cream->inst, address);
+RFE_INST : {
+    // RFE is unconditional
+    ldst_inst* const inst_cream = (ldst_inst*)inst_base->component;
 
-        cpu->Cpsr    = cpu->ReadMemory32(address);
-        cpu->Reg[15] = cpu->ReadMemory32(address + 4);
+    u32 address = 0;
+    inst_cream->get_addr(cpu, inst_cream->inst, address);
 
-        INC_PC(sizeof(ldst_inst));
-        goto DISPATCH;
-    }
+    cpu->Cpsr = cpu->ReadMemory32(address);
+    cpu->Reg[15] = cpu->ReadMemory32(address + 4);
+
+    INC_PC(sizeof(ldst_inst));
+    goto DISPATCH;
+}
 
-    RSB_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            rsb_inst* const inst_cream = (rsb_inst*)inst_base->component;
+RSB_INST : {
+    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;
-            if (inst_cream->Rn == 15)
-                rn_val += 2 * cpu->GetInstructionSize();
+        u32 rn_val = RN;
+        if (inst_cream->Rn == 15)
+            rn_val += 2 * cpu->GetInstructionSize();
 
-            bool carry;
-            bool overflow;
-            RD = AddWithCarry(~rn_val, SHIFTER_OPERAND, 1, &carry, &overflow);
+        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;
+        if (inst_cream->S && (inst_cream->Rd == 15)) {
+            if (CurrentModeHasSPSR) {
+                cpu->Cpsr = cpu->Spsr_copy;
+                cpu->ChangePrivilegeMode(cpu->Spsr_copy & 0x1F);
+                LOAD_NZCVT;
             }
-            if (inst_cream->Rd == 15) {
-                INC_PC(sizeof(rsb_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(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();
-        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;
+        if (inst_cream->Rd == 15) {
+            INC_PC(sizeof(rsc_inst));
+            goto DISPATCH;
+        }
+    }
+    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);
             }
-            if (inst_cream->Rd == 15) {
-                INC_PC(sizeof(rsc_inst));
-                goto DISPATCH;
+            // 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);
             }
-        }
-        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) {
-                    cpu->Cpsr |= (1 << 16);
-                    cpu->Cpsr |= (1 << 17);
-                } else {
-                    cpu->Cpsr &= ~(1 << 16);
-                    cpu->Cpsr &= ~(1 << 17);
-                }
+            if (lo_result >= 0) {
+                cpu->Cpsr |= (1 << 16);
+                cpu->Cpsr |= (1 << 17);
+            } else {
+                cpu->Cpsr &= ~(1 << 16);
+                cpu->Cpsr &= ~(1 << 17);
+            }
 
-                if (hi_result >= 0) {
-                    cpu->Cpsr |= (1 << 18);
-                    cpu->Cpsr |= (1 << 19);
-                } else {
-                    cpu->Cpsr &= ~(1 << 18);
-                    cpu->Cpsr &= ~(1 << 19);
-                }
+            if (hi_result >= 0) {
+                cpu->Cpsr |= (1 << 18);
+                cpu->Cpsr |= (1 << 19);
+            } else {
+                cpu->Cpsr &= ~(1 << 18);
+                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)
-                    cpu->Cpsr |= (1 << 16);
-                else
-                    cpu->Cpsr &= ~(1 << 16);
+            if (lo_val1 >= 0)
+                cpu->Cpsr |= (1 << 16);
+            else
+                cpu->Cpsr &= ~(1 << 16);
 
-                if (lo_val2 >= 0)
-                    cpu->Cpsr |= (1 << 17);
-                else
-                    cpu->Cpsr &= ~(1 << 17);
+            if (lo_val2 >= 0)
+                cpu->Cpsr |= (1 << 17);
+            else
+                cpu->Cpsr &= ~(1 << 17);
 
-                if (hi_val1 >= 0)
-                    cpu->Cpsr |= (1 << 18);
-                else
-                    cpu->Cpsr &= ~(1 << 18);
+            if (hi_val1 >= 0)
+                cpu->Cpsr |= (1 << 18);
+            else
+                cpu->Cpsr &= ~(1 << 18);
 
-                if (hi_val2 >= 0)
-                    cpu->Cpsr |= (1 << 19);
-                else
-                    cpu->Cpsr &= ~(1 << 19);
-            }
+            if (hi_val2 >= 0)
+                cpu->Cpsr |= (1 << 19);
+            else
+                cpu->Cpsr &= ~(1 << 19);
         }
-
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
     }
 
-    SBC_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            sbc_inst* const inst_cream = (sbc_inst*)inst_base->component;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(generic_arm_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-            u32 rn_val = RN;
-            if (inst_cream->Rn == 15)
-                rn_val += 2 * cpu->GetInstructionSize();
+SBC_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        sbc_inst* const inst_cream = (sbc_inst*)inst_base->component;
 
-            bool carry;
-            bool overflow;
-            RD = AddWithCarry(rn_val, ~SHIFTER_OPERAND, cpu->CFlag, &carry, &overflow);
+        u32 rn_val = RN;
+        if (inst_cream->Rn == 15)
+            rn_val += 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);
-                cpu->CFlag = carry;
-                cpu->VFlag = overflow;
-            }
-            if (inst_cream->Rd == 15) {
-                INC_PC(sizeof(sbc_inst));
-                goto DISPATCH;
+        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(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:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            generic_arm_inst* const inst_cream = (generic_arm_inst*)inst_base->component;
+SEL_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 to = RM;
-            const u32 from = RN;
-            const u32 cpsr = cpu->Cpsr;
+        const u32 to = RM;
+        const u32 from = RN;
+        const u32 cpsr = cpu->Cpsr;
 
-            u32 result;
-            if (cpsr & (1 << 16))
-                result = from & 0xff;
-            else
-                result = to & 0xff;
-
-            if (cpsr & (1 << 17))
-                result |= from & 0x0000ff00;
-            else
-                result |= to & 0x0000ff00;
+        u32 result;
+        if (cpsr & (1 << 16))
+            result = from & 0xff;
+        else
+            result = to & 0xff;
 
-            if (cpsr & (1 << 18))
-                result |= from & 0x00ff0000;
-            else
-                result |= to & 0x00ff0000;
+        if (cpsr & (1 << 17))
+            result |= from & 0x0000ff00;
+        else
+            result |= to & 0x0000ff00;
 
-            if (cpsr & (1 << 19))
-                result |= from & 0xff000000;
-            else
-                result |= to & 0xff000000;
+        if (cpsr & (1 << 18))
+            result |= from & 0x00ff0000;
+        else
+            result |= to & 0x00ff0000;
 
-            RD = result;
-        }
+        if (cpsr & (1 << 19))
+            result |= from & 0xff000000;
+        else
+            result |= to & 0xff000000;
 
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        RD = result;
     }
 
-    SETEND_INST:
-    {
-        // SETEND is unconditional
-        setend_inst* const inst_cream = (setend_inst*)inst_base->component;
-        const bool big_endian = (inst_cream->set_bigend == 1);
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(generic_arm_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-        if (big_endian)
-            cpu->Cpsr |= (1 << 9);
-        else
-            cpu->Cpsr &= ~(1 << 9);
+SETEND_INST : {
+    // SETEND is unconditional
+    setend_inst* const inst_cream = (setend_inst*)inst_base->component;
+    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();
-        INC_PC(sizeof(setend_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
+    LOG_WARNING(Core_ARM11, "SETEND %s executed", big_endian ? "BE" : "LE");
 
-    SEV_INST:
-    {
-        // Stubbed, as SEV is a hint instruction.
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            LOG_TRACE(Core_ARM11, "SEV executed.");
-        }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(setend_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC_STUB;
-        FETCH_INST;
-        GOTO_NEXT_INST;
+SEV_INST : {
+    // Stubbed, as SEV is a hint instruction.
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        LOG_TRACE(Core_ARM11, "SEV executed.");
     }
 
-    SHADD8_INST:
-    SHADD16_INST:
-    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;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC_STUB;
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-            const u8 op2 = inst_cream->op2;
-            const u32 rm_val = RM;
-            const u32 rn_val = RN;
+SHADD8_INST:
+SHADD16_INST:
+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) {
-                s32 lo_result = 0;
-                s32 hi_result = 0;
+        const u8 op2 = inst_cream->op2;
+        const u32 rm_val = RM;
+        const u32 rn_val = RN;
 
-                // 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;
-                }
+        if (op2 == 0x00 || op2 == 0x01 || op2 == 0x02 || op2 == 0x03) {
+            s32 lo_result = 0;
+            s32 hi_result = 0;
 
-                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
-                if (op2 == 0x04) {
-                    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_val2 = ((s8)((rn_val >> 24) & 0xFF) + (s8)((rm_val >> 24) & 0xFF)) >> 1;
-                }
-                // SHSUB8
-                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;
+            RD = ((lo_result & 0xFFFF) | ((hi_result & 0xFFFF) << 16));
+        } else if (op2 == 0x04 || op2 == 0x07) {
+            s16 lo_val1, lo_val2;
+            s16 hi_val1, hi_val2;
 
-                    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;
-                }
+            // SHADD8
+            if (op2 == 0x04) {
+                lo_val1 = ((s8)(rn_val & 0xFF) + (s8)(rm_val & 0xFF)) >> 1;
+                lo_val2 = ((s8)((rn_val >> 8) & 0xFF) + (s8)((rm_val >> 8) & 0xFF)) >> 1;
 
-                RD = (lo_val1 & 0xFF) | ((lo_val2 & 0xFF) << 8) | ((hi_val1 & 0xFF) << 16) | ((hi_val2 & 0xFF) << 24);
+                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;
             }
-        }
-
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(generic_arm_inst));
-        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);
+            // SHSUB8
+            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;
 
-            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);
+                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;
+            }
 
-            u32 product = operand1 * operand2;
-            u32 result = product + RN;
-            if (AddOverflow(product, RN, result))
-                cpu->Cpsr |= (1 << 27);
-            RD = result;
+            RD = (lo_val1 & 0xFF) | ((lo_val2 & 0xFF) << 8) | ((hi_val1 & 0xFF) << 16) |
+                 ((hi_val2 & 0xFF) << 24);
         }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(smla_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
     }
 
-    SMLAD_INST:
-    SMLSD_INST:
-    SMUAD_INST:
-    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;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(generic_arm_inst));
+    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);
 
-            u32 rm_val = cpu->Reg[inst_cream->Rm];
-            const u32 rn_val = cpu->Reg[inst_cream->Rn];
+        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);
+
+        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;
+}
 
-            if (inst_cream->m)
-                rm_val = (((rm_val & 0xFFFF) << 16) | (rm_val >> 16));
+SMLAD_INST:
+SMLSD_INST:
+SMUAD_INST:
+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 s16 rm_lo = (rm_val & 0xFFFF);
-            const s16 rm_hi = ((rm_val >> 16) & 0xFFFF);
-            const s16 rn_lo = (rn_val & 0xFFFF);
-            const s16 rn_hi = ((rn_val >> 16) & 0xFFFF);
+        u32 rm_val = cpu->Reg[inst_cream->Rm];
+        const u32 rn_val = cpu->Reg[inst_cream->Rn];
 
-            const u32 product1 = (rn_lo * rm_lo);
-            const u32 product2 = (rn_hi * rm_hi);
+        if (inst_cream->m)
+            rm_val = (((rm_val & 0xFFFF) << 16) | (rm_val >> 16));
 
-            // SMUAD and SMLAD
-            if (BIT(op2, 1) == 0) {
-                u32 rd_val = (product1 + product2);
+        const s16 rm_lo = (rm_val & 0xFFFF);
+        const s16 rm_hi = ((rm_val >> 16) & 0xFFFF);
+        const s16 rn_lo = (rn_val & 0xFFFF);
+        const s16 rn_hi = ((rn_val >> 16) & 0xFFFF);
 
-                if (inst_cream->Ra != 15) {
-                    rd_val += cpu->Reg[inst_cream->Ra];
+        const u32 product1 = (rn_lo * rm_lo);
+        const u32 product2 = (rn_hi * rm_hi);
 
-                    if (ARMul_AddOverflowQ(product1 + product2, cpu->Reg[inst_cream->Ra]))
-                        cpu->Cpsr |= (1 << 27);
-                }
+        // 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_val += cpu->Reg[inst_cream->Ra];
+            RD = rd_val;
 
-                    if (ARMul_AddOverflowQ(product1 - product2, cpu->Reg[inst_cream->Ra]))
-                        cpu->Cpsr |= (1 << 27);
-                }
+            if (ARMul_AddOverflowQ(product1, product2))
+                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();
-        INC_PC(sizeof(smlad_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+            RD = rd_val;
+        }
     }
 
-    SMLAL_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            umlal_inst* inst_cream = (umlal_inst*)inst_base->component;
-            long long int rm = RM;
-            long long int rs = RS;
-            if (BIT(rm, 31)) {
-                rm |= 0xffffffff00000000LL;
-            }
-            if (BIT(rs, 31)) {
-                rs |= 0xffffffff00000000LL;
-            }
-            long long int rst = rm * rs;
-            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();
+    INC_PC(sizeof(smlad_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+
+SMLAL_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        umlal_inst* inst_cream = (umlal_inst*)inst_base->component;
+        long long int rm = RM;
+        long long int rs = RS;
+        if (BIT(rm, 31)) {
+            rm |= 0xffffffff00000000LL;
         }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(umlal_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
-
-    SMLALXY_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            smlalxy_inst* const inst_cream = (smlalxy_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);
+        if (BIT(rs, 31)) {
+            rs |= 0xffffffff00000000LL;
+        }
+        long long int rst = rm * rs;
+        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();
-        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:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            smlad_inst* const inst_cream = (smlad_inst*)inst_base->component;
+SMLALXY_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        smlalxy_inst* const inst_cream = (smlalxy_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;
-            const u32 rn_val = RN;
-            const u32 ra_val = cpu->Reg[inst_cream->Ra];
-            const bool high = (inst_cream->m == 1);
+SMLAW_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        smlad_inst* const inst_cream = (smlad_inst*)inst_base->component;
 
-            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);
+        const u32 rm_val = RM;
+        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)
-                cpu->Cpsr |= (1 << 27);
-        }
+        RD = BITS(result, 16, 47);
 
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(smlad_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        if ((result >> 16) != (s32)RD)
+            cpu->Cpsr |= (1 << 27);
     }
 
-    SMLALD_INST:
-    SMLSLD_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            smlald_inst* const inst_cream = (smlald_inst*)inst_base->component;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(smlad_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-            const bool do_swap = (inst_cream->swap == 1);
-            const u32 rdlo_val = RDLO;
-            const u32 rdhi_val = RDHI;
-            const u32 rn_val   = RN;
-            u32 rm_val         = RM;
+SMLALD_INST:
+SMLSLD_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        smlald_inst* const inst_cream = (smlald_inst*)inst_base->component;
 
-            if (do_swap)
-                rm_val = (((rm_val & 0xFFFF) << 16) | (rm_val >> 16));
+        const bool do_swap = (inst_cream->swap == 1);
+        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);
-            const s32 product2 = (s16)((rn_val >> 16) & 0xFFFF) * (s16)((rm_val >> 16) & 0xFFFF);
-            s64 result;
+        if (do_swap)
+            rm_val = (((rm_val & 0xFFFF) << 16) | (rm_val >> 16));
 
-            // SMLALD
-            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));
-            }
+        const s32 product1 = (s16)(rn_val & 0xFFFF) * (s16)(rm_val & 0xFFFF);
+        const s32 product2 = (s16)((rn_val >> 16) & 0xFFFF) * (s16)((rm_val >> 16) & 0xFFFF);
+        s64 result;
 
-            RDLO = (result & 0xFFFFFFFF);
-            RDHI = ((result >> 32) & 0xFFFFFFFF);
+        // SMLALD
+        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();
-        INC_PC(sizeof(smlald_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        RDLO = (result & 0xFFFFFFFF);
+        RDHI = ((result >> 32) & 0xFFFFFFFF);
     }
 
-    SMMLA_INST:
-    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;
-
-            const u32 rm_val = RM;
-            const u32 rn_val = RN;
-            const bool do_round = (inst_cream->m == 1);
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(smlald_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-            // Assume SMMUL by default.
-            s64 result = (s64)(s32)rn_val * (s64)(s32)rm_val;
+SMMLA_INST:
+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 ra_val = cpu->Reg[inst_cream->Ra];
+        const u32 rm_val = RM;
+        const u32 rn_val = RN;
+        const bool do_round = (inst_cream->m == 1);
 
-                // SMMLA, otherwise SMMLS
-                if (BIT(inst_cream->op2, 1) == 0)
-                    result += ((s64)ra_val << 32);
-                else
-                    result = ((s64)ra_val << 32) - result;
-            }
+        // Assume SMMUL by default.
+        s64 result = (s64)(s32)rn_val * (s64)(s32)rm_val;
 
-            if (do_round)
-                result += 0x80000000;
+        if (inst_cream->Ra != 15) {
+            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();
-        INC_PC(sizeof(smlad_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        if (do_round)
+            result += 0x80000000;
+
+        RD = ((result >> 32) & 0xFFFFFFFF);
     }
 
-    SMUL_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            smul_inst* inst_cream = (smul_inst*)inst_base->component;
-            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);
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(smlad_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-            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;
+SMUL_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        smul_inst* inst_cream = (smul_inst*)inst_base->component;
+        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)
+            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();
-        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;
-            }
-            if (BIT(rs, 31)) {
-                rs |= 0xffffffff00000000LL;
-            }
-            s64 rst = rm * rs;
-            RDHI = BITS(rst, 32, 63);
-            RDLO = BITS(rst,  0, 31);
+        if (BIT(rs, 31)) {
+            rs |= 0xffffffff00000000LL;
+        }
+        s64 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);
-            }
+        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;
     }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(umull_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-    SMULW_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            smlad_inst* const inst_cream = (smlad_inst*)inst_base->component;
+SMULW_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        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;
-            RD = BITS(result, 16, 47);
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(smlad_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        s64 result = (s64)rm * (s64)(s32)RN;
+        RD = BITS(result, 16, 47);
     }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(smlad_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-    SRS_INST:
-    {
-        // SRS is unconditional
-        ldst_inst* const inst_cream = (ldst_inst*)inst_base->component;
+SRS_INST : {
+    // SRS is unconditional
+    ldst_inst* const inst_cream = (ldst_inst*)inst_base->component;
 
-        u32 address = 0;
-        inst_cream->get_addr(cpu, inst_cream->inst, address);
+    u32 address = 0;
+    inst_cream->get_addr(cpu, inst_cream->inst, address);
 
-        cpu->WriteMemory32(address + 0, cpu->Reg[14]);
-        cpu->WriteMemory32(address + 4, cpu->Spsr_copy);
+    cpu->WriteMemory32(address + 0, cpu->Reg[14]);
+    cpu->WriteMemory32(address + 4, cpu->Spsr_copy);
 
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(ldst_inst));
-        FETCH_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;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(ldst_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-            u8 shift_type = inst_cream->shift_type;
-            u8 shift_amount = inst_cream->imm5;
-            u32 rn_val = RN;
+SSAT_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        ssat_inst* const inst_cream = (ssat_inst*)inst_base->component;
 
-            // 32-bit ASR is encoded as an amount of 0.
-            if (shift_type == 1 && shift_amount == 0)
-                shift_amount = 31;
+        u8 shift_type = inst_cream->shift_type;
+        u8 shift_amount = inst_cream->imm5;
+        u32 rn_val = RN;
 
-            if (shift_type == 0)
-                rn_val <<= shift_amount;
-            else if (shift_type == 1)
-                rn_val = ((s32)rn_val >> shift_amount);
+        // 32-bit ASR is encoded as an amount of 0.
+        if (shift_type == 1 && shift_amount == 0)
+            shift_amount = 31;
 
-            bool saturated = false;
-            rn_val = ARMul_SignedSatQ(rn_val, inst_cream->sat_imm, &saturated);
+        if (shift_type == 0)
+            rn_val <<= shift_amount;
+        else if (shift_type == 1)
+            rn_val = ((s32)rn_val >> shift_amount);
 
-            if (saturated)
-                cpu->Cpsr |= (1 << 27);
+        bool saturated = false;
+        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();
-        INC_PC(sizeof(ssat_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        RD = rn_val;
     }
 
-    SSAT16_INST:
-    {
-        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;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(ssat_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-            bool sat1 = false;
-            bool sat2 = false;
+SSAT16_INST : {
+    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) |
-                 ARMul_SignedSatQ((s32)RN >> 16, saturate_to, &sat2) << 16;
+        bool sat1 = false;
+        bool sat2 = false;
 
-            if (sat1 || sat2)
-                cpu->Cpsr |= (1 << 27);
-        }
+        RD = (ARMul_SignedSatQ((s16)RN, saturate_to, &sat1) & 0xFFFF) |
+             ARMul_SignedSatQ((s32)RN >> 16, saturate_to, &sat2) << 16;
 
-        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, 13)) {
-                    if (cpu->Mode == USER32MODE)
-                        cpu->WriteMemory32(addr, cpu->Reg[13]);
-                    else
-                        cpu->WriteMemory32(addr, cpu->Reg_usr[0]);
+        if (sat1 || sat2)
+            cpu->Cpsr |= (1 << 27);
+    }
 
+    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)
-                        cpu->WriteMemory32(addr, cpu->Reg[14]);
+            }
+            if (BIT(inst_cream->inst, 13)) {
+                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
-                if (BIT(inst_cream->inst, 15)) {
-                    cpu->WriteMemory32(addr, cpu->Reg[15] + 8);
-                }
+            // Check PC reg
+            if (BIT(inst_cream->inst, 15)) {
+                cpu->WriteMemory32(addr, cpu->Reg[15] + 8);
             }
         }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(ldst_inst));
-        FETCH_INST;
-        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;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(ldst_inst));
+    FETCH_INST;
+    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);
-            if (BIT(operand2, 7)) {
-                operand2 |= 0xffffff00;
-            } else {
-                operand2 &= 0xff;
-            }
-            RD = operand2;
+        unsigned int operand2 = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate);
+        if (BIT(operand2, 7)) {
+            operand2 |= 0xffffff00;
+        } else {
+            operand2 &= 0xff;
         }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(sxtb_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        RD = operand2;
     }
-    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);
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(sxtb_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
+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 value = cpu->Reg[reg];
+        unsigned int reg = BITS(inst_cream->inst, 12, 15);
+        unsigned int value = cpu->Reg[reg];
 
-            if (reg == 15)
-                value += 2 * cpu->GetInstructionSize();
+        if (reg == 15)
+            value += 2 * cpu->GetInstructionSize();
 
-            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;
+        cpu->WriteMemory32(addr, value);
     }
-    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->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;
 
-            const u32 previous_mode = cpu->Mode;
-            const u32 value = cpu->Reg[BITS(inst_cream->inst, 12, 15)] & 0xff;
+        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 : {
+    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);
-            cpu->WriteMemory8(addr, value);
-            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);
+        const u32 previous_mode = cpu->Mode;
+        const u32 value = cpu->Reg[BITS(inst_cream->inst, 12, 15)] & 0xff;
 
-                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(generic_arm_inst));
-        FETCH_INST;
-        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->ChangePrivilegeMode(USER32MODE);
+        cpu->WriteMemory8(addr, value);
+        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;
-    }
-    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);
-
-            unsigned int value = cpu->Reg[BITS(inst_cream->inst, 12, 15)] & 0xffff;
-            cpu->WriteMemory16(addr, value);
+    }
+    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(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);
+    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];
 
-            const u32 previous_mode = cpu->Mode;
-            const u32 rt_index = BITS(inst_cream->inst, 12, 15);
+        if (cpu->IsExclusiveMemoryAccess(write_addr)) {
+            cpu->UnsetExclusiveMemoryAddress();
 
-            u32 value = cpu->Reg[rt_index];
-            if (rt_index == 15)
-                value += 2 * cpu->GetInstructionSize();
+            const u32 rt = cpu->Reg[inst_cream->Rm + 0];
+            const u32 rt2 = cpu->Reg[inst_cream->Rm + 1];
+            u64 value;
 
-            cpu->ChangePrivilegeMode(USER32MODE);
-            cpu->WriteMemory32(addr, value);
-            cpu->ChangePrivilegeMode(previous_mode);
+            if (cpu->InBigEndianMode())
+                value = (((u64)rt << 32) | rt2);
+            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:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            sub_inst* const inst_cream = (sub_inst*)inst_base->component;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(generic_arm_inst));
+    FETCH_INST;
+    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;
-            bool overflow;
-            RD = AddWithCarry(rn_val, ~SHIFTER_OPERAND, 1, &carry, &overflow);
+        const u32 previous_mode = cpu->Mode;
+        const u32 rt_index = BITS(inst_cream->inst, 12, 15);
 
-            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(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);
-        }
+        u32 value = cpu->Reg[rt_index];
+        if (rt_index == 15)
+            value += 2 * cpu->GetInstructionSize();
 
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(swi_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        cpu->ChangePrivilegeMode(USER32MODE);
+        cpu->WriteMemory32(addr, value);
+        cpu->ChangePrivilegeMode(previous_mode);
     }
-    SWP_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            swp_inst* inst_cream = (swp_inst*)inst_base->component;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(ldst_inst));
+    FETCH_INST;
+    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;
-            unsigned int value = cpu->ReadMemory32(addr);
-            cpu->WriteMemory32(addr, RM);
+        u32 rn_val = CHECK_READ_REG15_WA(cpu, inst_cream->Rn);
 
-            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();
-        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;
+        if (inst_cream->Rd == 15) {
+            INC_PC(sizeof(sub_inst));
+            goto DISPATCH;
         }
-        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;
+    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);
+    }
 
-            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
-            operand2 = (0x80 & operand2)? (0xFFFFFF00 | operand2):operand2;
-            RD = RN + operand2;
-        }
-        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));
-            }
-        }
+        addr = RN;
+        unsigned int value = cpu->ReadMemory32(addr);
+        cpu->WriteMemory32(addr, RM);
 
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(sxtab_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        RD = value;
     }
+    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:
-    {
-        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) & 0xff;
 
-            unsigned int operand2 = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate) & 0xffff;
-            // Sign extend for half
-            operand2 = (0x8000 & operand2) ? (0xFFFF0000 | operand2) : operand2;
-            RD = RN + operand2;
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(sxtah_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        // Sign extend for byte
+        operand2 = (0x80 & operand2) ? (0xFFFFFF00 | operand2) : operand2;
+        RD = RN + operand2;
     }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(uxtab_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-    TEQ_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            teq_inst* const inst_cream = (teq_inst*)inst_base->component;
-
-            u32 lop = RN;
-            u32 rop = SHIFTER_OPERAND;
+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;
 
-            if (inst_cream->Rn == 15)
-                lop += cpu->GetInstructionSize() * 2;
+        const u8 rotation = inst_cream->rotate * 8;
+        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);
-            UPDATE_ZFLAG(result);
-            UPDATE_CFLAG_WITH_SC;
+        // 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();
-        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;
-            u32 rop = SHIFTER_OPERAND;
-
-            if (inst_cream->Rn == 15)
-                lop += cpu->GetInstructionSize() * 2;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(sxtab_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-            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);
-            UPDATE_ZFLAG(result);
-            UPDATE_CFLAG_WITH_SC;
-        }
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(tst_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;
+        unsigned int operand2 = ROTATE_RIGHT_32(RM, 8 * inst_cream->rotate) & 0xffff;
+        // Sign extend for half
+        operand2 = (0x8000 & operand2) ? (0xFFFF0000 | operand2) : operand2;
+        RD = RN + operand2;
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(sxtah_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-            s32 lo_result = 0;
-            s32 hi_result = 0;
+TEQ_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        teq_inst* const inst_cream = (teq_inst*)inst_base->component;
 
-            // 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);
-                }
+        u32 lop = RN;
+        u32 rop = SHIFTER_OPERAND;
 
-                if (hi_result & 0xFFFF0000) {
-                    cpu->Cpsr |= (1 << 18);
-                    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 (inst_cream->Rn == 15)
+            lop += cpu->GetInstructionSize() * 2;
 
-                if (hi_result >= 0x10000) {
-                    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);
-                }
+        u32 result = lop ^ rop;
 
-                if (hi_result >= 0) {
-                    cpu->Cpsr |= (1 << 18);
-                    cpu->Cpsr |= (1 << 19);
-                } 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);
-                }
+        UPDATE_NFLAG(result);
+        UPDATE_ZFLAG(result);
+        UPDATE_CFLAG_WITH_SC;
+    }
+    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;
 
-                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);
+        u32 lop = RN;
+        u32 rop = SHIFTER_OPERAND;
 
-                if (sum2 >= 0x100)
-                    cpu->Cpsr |= (1 << 17);
-                else
-                    cpu->Cpsr &= ~(1 << 17);
+        if (inst_cream->Rn == 15)
+            lop += cpu->GetInstructionSize() * 2;
 
-                if (sum3 >= 0x100)
-                    cpu->Cpsr |= (1 << 18);
-                else
-                    cpu->Cpsr &= ~(1 << 18);
+        u32 result = lop & rop;
 
-                if (sum4 >= 0x100)
-                    cpu->Cpsr |= (1 << 19);
-                else
-                    cpu->Cpsr &= ~(1 << 19);
+        UPDATE_NFLAG(result);
+        UPDATE_ZFLAG(result);
+        UPDATE_CFLAG_WITH_SC;
+    }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(tst_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-                lo_result = ((sum1 & 0xFF) | (sum2 & 0xFF) << 8);
-                hi_result = ((sum3 & 0xFF) | (sum4 & 0xFF) << 8);
+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;
+        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)
-                    cpu->Cpsr |= (1 << 17);
-                else
-                    cpu->Cpsr &= ~(1 << 17);
-
-                if (diff3 >= 0)
-                    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);
+            if (hi_result & 0xFFFF0000) {
+                cpu->Cpsr |= (1 << 18);
+                cpu->Cpsr |= (1 << 19);
+            } else {
+                cpu->Cpsr &= ~(1 << 18);
+                cpu->Cpsr &= ~(1 << 19);
             }
-
-            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();
-        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 = (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);
+            if (hi_result >= 0x10000) {
+                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);
             }
-            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;
-                sum2 >>= 1;
-                sum3 >>= 1;
-                sum4 >>= 1;
+            if (hi_result >= 0) {
+                cpu->Cpsr |= (1 << 18);
+                cpu->Cpsr |= (1 << 19);
+            } 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();
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
-    }
+            if (sum2 >= 0x100)
+                cpu->Cpsr |= (1 << 17);
+            else
+                cpu->Cpsr &= ~(1 << 17);
 
-    UMAAL_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            umaal_inst* const inst_cream = (umaal_inst*)inst_base->component;
-            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;
+            if (sum3 >= 0x100)
+                cpu->Cpsr |= (1 << 18);
+            else
+                cpu->Cpsr &= ~(1 << 18);
 
-            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);
-            }
+            if (sum4 >= 0x100)
+                cpu->Cpsr |= (1 << 19);
+            else
+                cpu->Cpsr &= ~(1 << 19);
+
+            lo_result = ((sum1 & 0xFF) | (sum2 & 0xFF) << 8);
+            hi_result = ((sum3 & 0xFF) | (sum4 & 0xFF) << 8);
         }
-        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;
+        // 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(CondPassed(cpu, inst_cream->cond))
-            cpu->Reg[15] = cpu->Reg[15] + 4 + inst_cream->imm;
-        else
-            cpu->Reg[15] += 2;
+            if (diff2 >= 0)
+                cpu->Cpsr |= (1 << 17);
+            else
+                cpu->Cpsr &= ~(1 << 17);
 
-        INC_PC(sizeof(b_cond_thumb));
-        goto DISPATCH;
-    }
-    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;
-    }
+            if (diff3 >= 0)
+                cpu->Cpsr |= (1 << 18);
+            else
+                cpu->Cpsr &= ~(1 << 18);
 
-    UQADD8_INST:
-    UQADD16_INST:
-    UQADDSUBX_INST:
-    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;
+            if (diff4 >= 0)
+                cpu->Cpsr |= (1 << 19);
+            else
+                cpu->Cpsr &= ~(1 << 19);
 
-            const u8 op2 = inst_cream->op2;
-            const u32 rm_val = RM;
-            const u32 rn_val = RN;
+            lo_result = (diff1 & 0xFF) | ((diff2 & 0xFF) << 8);
+            hi_result = (diff3 & 0xFF) | ((diff4 & 0xFF) << 8);
+        }
 
-            u16 lo_val = 0;
-            u16 hi_val = 0;
+        RD = (lo_result & 0xFFFF) | ((hi_result & 0xFFFF) << 16);
+    }
 
-            // 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);
-                hi_val = ARMul_UnsignedSaturatedAdd16((rn_val >> 16) & 0xFFFF, (rm_val >> 16) & 0xFFFF);
+                lo_val = (rn_val & 0xFFFF) + (rm_val & 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);
-                hi_val = ARMul_UnsignedSaturatedAdd16((rn_val >> 16) & 0xFFFF, rm_val & 0xFFFF);
+                lo_val = (rn_val & 0xFFFF) - ((rm_val >> 16) & 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);
-                hi_val = ARMul_UnsignedSaturatedSub16((rn_val >> 16) & 0xFFFF, rm_val & 0xFFFF);
+                lo_val = (rn_val & 0xFFFF) + ((rm_val >> 16) & 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);
-                hi_val = ARMul_UnsignedSaturatedSub16((rn_val >> 16) & 0xFFFF, (rm_val >> 16) & 0xFFFF);
+                lo_val = (rn_val & 0xFFFF) - (rm_val & 0xFFFF);
+                hi_val = ((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;
+
+            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);
             }
-            // UQSUB8
+            // UHSUB8
             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;
+                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);
             }
 
-            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();
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+UMAAL_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        umaal_inst* const inst_cream = (umaal_inst*)inst_base->component;
+        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:
-    USADA8_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
+    if (CondPassed(cpu, inst_cream->cond))
+        cpu->Reg[15] = cpu->Reg[15] + 4 + inst_cream->imm;
+    else
+        cpu->Reg[15] += 2;
 
-            const u8 ra_idx = inst_cream->Ra;
-            const u32 rm_val = RM;
-            const u32 rn_val = RN;
+    INC_PC(sizeof(b_cond_thumb));
+    goto DISPATCH;
+}
+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);
-            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);
+UQADD8_INST:
+UQADD16_INST:
+UQADDSUBX_INST:
+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.
-            if (ra_idx != 15)
-                finalDif += cpu->Reg[ra_idx];
+USAD8_INST:
+USADA8_INST : {
+    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();
-        INC_PC(sizeof(generic_arm_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        u32 finalDif = (diff1 + diff2 + diff3 + diff4);
+
+        // Op is USADA8 if true.
+        if (ra_idx != 15)
+            finalDif += cpu->Reg[ra_idx];
+
+        RD = finalDif;
     }
 
-    USAT_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            ssat_inst* const inst_cream = (ssat_inst*)inst_base->component;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(generic_arm_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-            u8 shift_type = inst_cream->shift_type;
-            u8 shift_amount = inst_cream->imm5;
-            u32 rn_val = RN;
+USAT_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        ssat_inst* const inst_cream = (ssat_inst*)inst_base->component;
 
-            // 32-bit ASR is encoded as an amount of 0.
-            if (shift_type == 1 && shift_amount == 0)
-                shift_amount = 31;
+        u8 shift_type = inst_cream->shift_type;
+        u8 shift_amount = inst_cream->imm5;
+        u32 rn_val = RN;
 
-            if (shift_type == 0)
-                rn_val <<= shift_amount;
-            else if (shift_type == 1)
-                rn_val = ((s32)rn_val >> shift_amount);
+        // 32-bit ASR is encoded as an amount of 0.
+        if (shift_type == 1 && shift_amount == 0)
+            shift_amount = 31;
 
-            bool saturated = false;
-            rn_val = ARMul_UnsignedSatQ(rn_val, inst_cream->sat_imm, &saturated);
+        if (shift_type == 0)
+            rn_val <<= shift_amount;
+        else if (shift_type == 1)
+            rn_val = ((s32)rn_val >> shift_amount);
 
-            if (saturated)
-                cpu->Cpsr |= (1 << 27);
+        bool saturated = false;
+        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();
-        INC_PC(sizeof(ssat_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        RD = rn_val;
     }
 
-    USAT16_INST:
-    {
-        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;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(ssat_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-            bool sat1 = false;
-            bool sat2 = false;
+USAT16_INST : {
+    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) |
-                 ARMul_UnsignedSatQ((s32)RN >> 16, saturate_to, &sat2) << 16;
+        bool sat1 = false;
+        bool sat2 = false;
 
-            if (sat1 || sat2)
-                cpu->Cpsr |= (1 << 27);
-        }
+        RD = (ARMul_UnsignedSatQ((s16)RN, saturate_to, &sat1) & 0xFFFF) |
+             ARMul_UnsignedSatQ((s32)RN >> 16, saturate_to, &sat2) << 16;
 
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC(sizeof(ssat_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+        if (sat1 || sat2)
+            cpu->Cpsr |= (1 << 27);
     }
 
-    UXTAB16_INST:
-    UXTB16_INST:
-    {
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            uxtab_inst* const inst_cream = (uxtab_inst*)inst_base->component;
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(ssat_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-            const u8 rn_idx = inst_cream->Rn;
-            const u32 rm_val = RM;
-            const u32 rotation = inst_cream->rotate * 8;
-            const u32 rotated_rm = ((rm_val << (32 - rotation)) | (rm_val >> rotation));
+UXTAB16_INST:
+UXTB16_INST : {
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        uxtab_inst* const inst_cream = (uxtab_inst*)inst_base->component;
 
-            // 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;
+        const u8 rn_idx = inst_cream->Rn;
+        const u32 rm_val = RM;
+        const u32 rotation = inst_cream->rotate * 8;
+        const u32 rotated_rm = ((rm_val << (32 - rotation)) | (rm_val >> rotation));
 
-                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();
-        INC_PC(sizeof(uxtab_inst));
-        FETCH_INST;
-        GOTO_NEXT_INST;
+            RD = ((hi_result << 16) | (lo_result & 0xFFFF));
+        }
     }
 
-    WFE_INST:
-    {
-        // Stubbed, as WFE is a hint instruction.
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            LOG_TRACE(Core_ARM11, "WFE executed.");
-        }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC(sizeof(uxtab_inst));
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC_STUB;
-        FETCH_INST;
-        GOTO_NEXT_INST;
+WFE_INST : {
+    // Stubbed, as WFE is a hint instruction.
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        LOG_TRACE(Core_ARM11, "WFE executed.");
     }
 
-    WFI_INST:
-    {
-        // Stubbed, as WFI is a hint instruction.
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            LOG_TRACE(Core_ARM11, "WFI executed.");
-        }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC_STUB;
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC_STUB;
-        FETCH_INST;
-        GOTO_NEXT_INST;
+WFI_INST : {
+    // Stubbed, as WFI is a hint instruction.
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        LOG_TRACE(Core_ARM11, "WFI executed.");
     }
 
-    YIELD_INST:
-    {
-        // Stubbed, as YIELD is a hint instruction.
-        if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
-            LOG_TRACE(Core_ARM11, "YIELD executed.");
-        }
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC_STUB;
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-        cpu->Reg[15] += cpu->GetInstructionSize();
-        INC_PC_STUB;
-        FETCH_INST;
-        GOTO_NEXT_INST;
+YIELD_INST : {
+    // Stubbed, as YIELD is a hint instruction.
+    if (inst_base->cond == ConditionCode::AL || CondPassed(cpu, inst_base->cond)) {
+        LOG_TRACE(Core_ARM11, "YIELD executed.");
     }
 
-    #define VFP_INTERPRETER_IMPL
-    #include "core/arm/skyeye_common/vfp/vfpinstr.cpp"
-    #undef VFP_INTERPRETER_IMPL
+    cpu->Reg[15] += cpu->GetInstructionSize();
+    INC_PC_STUB;
+    FETCH_INST;
+    GOTO_NEXT_INST;
+}
 
-    END:
-    {
-        SAVE_NZCVT;
-        cpu->NumInstrsToExecute = 0;
-        return num_instrs;
-    }
-    INIT_INST_LENGTH:
-    {
-        cpu->NumInstrsToExecute = 0;
-        return num_instrs;
-    }
+#define VFP_INTERPRETER_IMPL
+#include "core/arm/skyeye_common/vfp/vfpinstr.cpp"
+#undef VFP_INTERPRETER_IMPL
+
+END : {
+    SAVE_NZCVT;
+    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 1: // LSR
-    case 2: // ASR
-        *ainstr = 0xE1B00000                    // base opcode
-            | ((tinstr & 0x1800) >> (11 - 5))   // shift type
-            |((tinstr & 0x07C0) << (7 - 6))     // imm5
-            |((tinstr & 0x0038) >> 3)           // Rs
-            |((tinstr & 0x0007) << 12);         // Rd
+    case 0:                                         // LSL
+    case 1:                                         // LSR
+    case 2:                                         // ASR
+        *ainstr = 0xE1B00000                        // base opcode
+                  | ((tinstr & 0x1800) >> (11 - 5)) // shift type
+                  | ((tinstr & 0x07C0) << (7 - 6))  // imm5
+                  | ((tinstr & 0x0038) >> 3)        // Rs
+                  | ((tinstr & 0x0007) << 12);      // Rd
         break;
 
     case 3: // ADD/SUB
-        {
-            static const u32 subset[4] = {
-                0xE0900000,     // ADDS Rd,Rs,Rn
-                0xE0500000,     // SUBS Rd,Rs,Rn
-                0xE2900000,     // ADDS Rd,Rs,#imm3
-                0xE2500000      // SUBS Rd,Rs,#imm3
-            };
-            // It is quicker indexing into a table, than performing switch or conditionals:
-            *ainstr = subset[(tinstr & 0x0600) >> 9]    // base opcode
-                |((tinstr & 0x01C0) >> 6)               // Rn or imm3
-                |((tinstr & 0x0038) << (16 - 3))        // Rs
-                |((tinstr & 0x0007) << (12 - 0));       // Rd
-        }
-        break;
+    {
+        static const u32 subset[4] = {
+            0xE0900000, // ADDS Rd,Rs,Rn
+            0xE0500000, // SUBS Rd,Rs,Rn
+            0xE2900000, // ADDS Rd,Rs,#imm3
+            0xE2500000  // SUBS Rd,Rs,#imm3
+        };
+        // It is quicker indexing into a table, than performing switch or conditionals:
+        *ainstr = subset[(tinstr & 0x0600) >> 9]     // base opcode
+                  | ((tinstr & 0x01C0) >> 6)         // Rn or imm3
+                  | ((tinstr & 0x0038) << (16 - 3))  // Rs
+                  | ((tinstr & 0x0007) << (12 - 0)); // Rd
+    } break;
 
     case 4: // MOV
     case 5: // CMP
     case 6: // ADD
     case 7: // SUB
-        {
-            static const u32 subset[4] = {
-                0xE3B00000,     // MOVS Rd,#imm8
-                0xE3500000,     // CMP  Rd,#imm8
-                0xE2900000,     // ADDS Rd,Rd,#imm8
-                0xE2500000,     // SUBS Rd,Rd,#imm8
-            };
-
-            *ainstr = subset[(tinstr & 0x1800) >> 11]   // base opcode
-                |((tinstr & 0x00FF) >> 0)               // imm8
-                |((tinstr & 0x0700) << (16 - 8))        // Rn
-                |((tinstr & 0x0700) << (12 - 8));       // Rd
-        }
-        break;
+    {
+        static const u32 subset[4] = {
+            0xE3B00000, // MOVS Rd,#imm8
+            0xE3500000, // CMP  Rd,#imm8
+            0xE2900000, // ADDS Rd,Rd,#imm8
+            0xE2500000, // SUBS Rd,Rd,#imm8
+        };
+
+        *ainstr = subset[(tinstr & 0x1800) >> 11]    // base opcode
+                  | ((tinstr & 0x00FF) >> 0)         // imm8
+                  | ((tinstr & 0x0700) << (16 - 8))  // Rn
+                  | ((tinstr & 0x0700) << (12 - 8)); // Rd
+    } 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 {
-                t_norm,
-                t_shift,
-                t_neg,
-                t_mul
-            };
+            enum otype { t_norm, t_shift, t_neg, t_mul };
 
             static const struct {
                 u32 opcode;
                 otype type;
             } subset[16] = {
-                { 0xE0100000, t_norm },     // ANDS Rd,Rd,Rs
-                { 0xE0300000, t_norm },     // EORS Rd,Rd,Rs
-                { 0xE1B00010, t_shift },    // MOVS Rd,Rd,LSL Rs
-                { 0xE1B00030, t_shift },    // MOVS Rd,Rd,LSR Rs
-                { 0xE1B00050, t_shift },    // MOVS Rd,Rd,ASR Rs
-                { 0xE0B00000, t_norm },     // ADCS Rd,Rd,Rs
-                { 0xE0D00000, t_norm },     // SBCS Rd,Rd,Rs
-                { 0xE1B00070, t_shift },    // MOVS Rd,Rd,ROR Rs
-                { 0xE1100000, t_norm },     // TST  Rd,Rs
-                { 0xE2700000, t_neg },      // RSBS Rd,Rs,#0
-                { 0xE1500000, t_norm },     // CMP  Rd,Rs
-                { 0xE1700000, t_norm },     // CMN  Rd,Rs
-                { 0xE1900000, t_norm },     // ORRS Rd,Rd,Rs
-                { 0xE0100090, t_mul },      // MULS Rd,Rd,Rs
-                { 0xE1D00000, t_norm },     // BICS Rd,Rd,Rs
-                { 0xE1F00000, t_norm }      // MVNS Rd,Rs
+                {0xE0100000, t_norm},  // ANDS Rd,Rd,Rs
+                {0xE0300000, t_norm},  // EORS Rd,Rd,Rs
+                {0xE1B00010, t_shift}, // MOVS Rd,Rd,LSL Rs
+                {0xE1B00030, t_shift}, // MOVS Rd,Rd,LSR Rs
+                {0xE1B00050, t_shift}, // MOVS Rd,Rd,ASR Rs
+                {0xE0B00000, t_norm},  // ADCS Rd,Rd,Rs
+                {0xE0D00000, t_norm},  // SBCS Rd,Rd,Rs
+                {0xE1B00070, t_shift}, // MOVS Rd,Rd,ROR Rs
+                {0xE1100000, t_norm},  // TST  Rd,Rs
+                {0xE2700000, t_neg},   // RSBS Rd,Rs,#0
+                {0xE1500000, t_norm},  // CMP  Rd,Rs
+                {0xE1700000, t_norm},  // CMN  Rd,Rs
+                {0xE1900000, t_norm},  // ORRS Rd,Rd,Rs
+                {0xE0100090, t_mul},   // MULS Rd,Rd,Rs
+                {0xE1D00000, t_norm},  // BICS Rd,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
-                    |((tinstr & 0x0007) << 12)          // Rd
-                    |((tinstr & 0x0038) >> 3);          // Rs
+                *ainstr |= ((tinstr & 0x0007) << 16)   // Rn
+                           | ((tinstr & 0x0007) << 12) // Rd
+                           | ((tinstr & 0x0038) >> 3); // Rs
                 break;
             case t_shift:
-                *ainstr |= ((tinstr & 0x0007) << 12)    // Rd
-                    |((tinstr & 0x0007) >> 0)           // Rm
-                    |((tinstr & 0x0038) << (8 - 3));    // Rs
+                *ainstr |= ((tinstr & 0x0007) << 12)         // Rd
+                           | ((tinstr & 0x0007) >> 0)        // Rm
+                           | ((tinstr & 0x0038) << (8 - 3)); // Rs
                 break;
             case t_neg:
-                *ainstr |= ((tinstr & 0x0007) << 12)    // Rd
-                    |((tinstr & 0x0038) << (16 - 3));   // Rn
+                *ainstr |= ((tinstr & 0x0007) << 12)          // Rd
+                           | ((tinstr & 0x0038) << (16 - 3)); // Rn
                 break;
             case t_mul:
-                *ainstr |= ((tinstr & 0x0007) << 16)    // Rd
-                    |((tinstr & 0x0007) << 8)           // Rs
-                    |((tinstr & 0x0038) >> 3);          // Rm
+                *ainstr |= ((tinstr & 0x0007) << 16)   // Rd
+                           | ((tinstr & 0x0007) << 8)  // Rs
+                           | ((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 0x1:                           // ADD Rd,Rd,Hs
-            case 0x2:                           // ADD Hd,Hd,Rs
-            case 0x3:                           // ADD Hd,Hd,Hs
-                *ainstr = 0xE0800000            // base
-                    | (Rd << 16)                // Rn
-                    |(Rd << 12)                 // Rd
-                    |(Rs << 0);                 // Rm
+            case 0x0:                  // ADD Rd,Rd,Rs
+            case 0x1:                  // ADD Rd,Rd,Hs
+            case 0x2:                  // ADD Hd,Hd,Rs
+            case 0x3:                  // ADD Hd,Hd,Hs
+                *ainstr = 0xE0800000   // base
+                          | (Rd << 16) // Rn
+                          | (Rd << 12) // Rd
+                          | (Rs << 0); // Rm
                 break;
-            case 0x4:                           // CMP Rd,Rs
-            case 0x5:                           // CMP Rd,Hs
-            case 0x6:                           // CMP Hd,Rs
-            case 0x7:                           // CMP Hd,Hs
-                *ainstr = 0xE1500000            // base
-                    | (Rd << 16)                // Rn
-                    |(Rs << 0);                 // Rm
+            case 0x4:                  // CMP Rd,Rs
+            case 0x5:                  // CMP Rd,Hs
+            case 0x6:                  // CMP Hd,Rs
+            case 0x7:                  // CMP Hd,Hs
+                *ainstr = 0xE1500000   // base
+                          | (Rd << 16) // Rn
+                          | (Rs << 0); // Rm
                 break;
-            case 0x8:                           // MOV Rd,Rs
-            case 0x9:                           // MOV Rd,Hs
-            case 0xA:                           // MOV Hd,Rs
-            case 0xB:                           // MOV Hd,Hs
-                *ainstr = 0xE1A00000            // base
-                    |(Rd << 12)                 // Rd
-                    |(Rs << 0);                 // Rm
+            case 0x8:                  // MOV Rd,Rs
+            case 0x9:                  // MOV Rd,Hs
+            case 0xA:                  // MOV Hd,Rs
+            case 0xB:                  // MOV Hd,Hs
+                *ainstr = 0xE1A00000   // base
+                          | (Rd << 12) // Rd
+                          | (Rs << 0); // Rm
                 break;
-            case 0xC:                           // BX Rs
-            case 0xD:                           // BX Hs
-                *ainstr = 0xE12FFF10            // base
-                    | ((tinstr & 0x0078) >> 3); // Rd
+            case 0xC:                                 // BX Rs
+            case 0xD:                                 // BX Hs
+                *ainstr = 0xE12FFF10                  // base
+                          | ((tinstr & 0x0078) >> 3); // Rd
                 break;
-            case 0xE:                           // BLX
-            case 0xF:                           // BLX
-                *ainstr = 0xE1200030            // base
-                    | (Rs << 0);                // Rm
+            case 0xE:                  // BLX
+            case 0xF:                  // BLX
+                *ainstr = 0xE1200030   // base
+                          | (Rs << 0); // Rm
                 break;
             }
         }
         break;
 
-    case 9: // LDR Rd,[PC,#imm8]
-        *ainstr = 0xE59F0000                    // base
-            | ((tinstr & 0x0700) << (12 - 8))   // Rd
-            |((tinstr & 0x00FF) << (2 - 0));    // off8
+    case 9:                                         // LDR Rd,[PC,#imm8]
+        *ainstr = 0xE59F0000                        // base
+                  | ((tinstr & 0x0700) << (12 - 8)) // Rd
+                  | ((tinstr & 0x00FF) << (2 - 0)); // off8
         break;
 
     case 10:
-    case 11:
-        {
-            static const u32 subset[8] = {
-                0xE7800000, // STR   Rd,[Rb,Ro]
-                0xE18000B0, // STRH  Rd,[Rb,Ro]
-                0xE7C00000, // STRB  Rd,[Rb,Ro]
-                0xE19000D0, // LDRSB Rd,[Rb,Ro]
-                0xE7900000, // LDR   Rd,[Rb,Ro]
-                0xE19000B0, // LDRH  Rd,[Rb,Ro]
-                0xE7D00000, // LDRB  Rd,[Rb,Ro]
-                0xE19000F0  // LDRSH Rd,[Rb,Ro]
-            };
-
-            *ainstr = subset[(tinstr & 0xE00) >> 9] // base
-                |((tinstr & 0x0007) << (12 - 0))    // Rd
-                |((tinstr & 0x0038) << (16 - 3))    // Rb
-                |((tinstr & 0x01C0) >> 6);          // Ro
-        }
-        break;
+    case 11: {
+        static const u32 subset[8] = {
+            0xE7800000, // STR   Rd,[Rb,Ro]
+            0xE18000B0, // STRH  Rd,[Rb,Ro]
+            0xE7C00000, // STRB  Rd,[Rb,Ro]
+            0xE19000D0, // LDRSB Rd,[Rb,Ro]
+            0xE7900000, // LDR   Rd,[Rb,Ro]
+            0xE19000B0, // LDRH  Rd,[Rb,Ro]
+            0xE7D00000, // LDRB  Rd,[Rb,Ro]
+            0xE19000F0  // LDRSH Rd,[Rb,Ro]
+        };
+
+        *ainstr = subset[(tinstr & 0xE00) >> 9]     // base
+                  | ((tinstr & 0x0007) << (12 - 0)) // Rd
+                  | ((tinstr & 0x0038) << (16 - 3)) // Rb
+                  | ((tinstr & 0x01C0) >> 6);       // Ro
+    } 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] = {
-                0xE5800000,     // STR  Rd,[Rb,#imm5]
-                0xE5900000,     // LDR  Rd,[Rb,#imm5]
-                0xE5C00000,     // STRB Rd,[Rb,#imm5]
-                0xE5D00000      // LDRB Rd,[Rb,#imm5]
-            };
-            // The offset range defends on whether we are transferring a byte or word value:
-            *ainstr = subset[(tinstr & 0x1800) >> 11]   // base
-                |((tinstr & 0x0007) << (12 - 0))        // Rd
-                |((tinstr & 0x0038) << (16 - 3))        // Rb
-                |((tinstr & 0x07C0) >> (6 - ((tinstr & (1 << 12)) ? 0 : 2))); // off5
-        }
+    {
+        static const u32 subset[4] = {
+            0xE5800000, // STR  Rd,[Rb,#imm5]
+            0xE5900000, // LDR  Rd,[Rb,#imm5]
+            0xE5C00000, // STRB Rd,[Rb,#imm5]
+            0xE5D00000  // LDRB Rd,[Rb,#imm5]
+        };
+        // The offset range defends on whether we are transferring a byte or word value:
+        *ainstr = subset[(tinstr & 0x1800) >> 11]                                // base
+                  | ((tinstr & 0x0007) << (12 - 0))                              // Rd
+                  | ((tinstr & 0x0038) << (16 - 3))                              // Rb
+                  | ((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 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 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
+    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
-                | ((tinstr & 0x0700) << (12 - 8))   // Rd
-                |(tinstr & 0x00FF);                 // off8
+            *ainstr = 0xE28F0F00                        // base
+                      | ((tinstr & 0x0700) << (12 - 8)) // Rd
+                      | (tinstr & 0x00FF);              // off8
         } else {
-            // We encode shift-left-by-2 in the rotate immediate field, so no shift of off8 is needed.
-            *ainstr = 0xE28D0F00                    // base
-                | ((tinstr & 0x0700) << (12 - 8))   // Rd
-                |(tinstr & 0x00FF);                 // off8
+            // We encode shift-left-by-2 in the rotate immediate field, so no shift of off8 is
+            // needed.
+            *ainstr = 0xE28D0F00                        // base
+                      | ((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
-                   ? 0xE24DDF00             // SUB
-                   : 0xE28DDF00)            // ADD
-                |(tinstr & 0x007F);         // off7
+            *ainstr = ((tinstr & (1 << 7)) // base
+                           ? 0xE24DDF00    // SUB
+                           : 0xE28DDF00)   // ADD
+                      | (tinstr & 0x007F); // off7
         } else if ((tinstr & 0x0F00) == 0x0e00) {
             // BKPT
-            *ainstr = 0xEF000000              // base
-                | BITS(tinstr, 0, 3)          // imm4 field;
-                | (BITS(tinstr, 4, 7) << 8);  // beginning 4 bits of imm12
+            *ainstr = 0xEF000000                   // base
+                      | BITS(tinstr, 0, 3)         // imm4 field;
+                      | (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
-                | (BITS(tinstr, 0, 2) << 12)     // Rd
-                | BITS(tinstr, 3, 5);            // Rm
+            *ainstr = subset[BITS(tinstr, 6, 7)]   // base
+                      | (BITS(tinstr, 0, 2) << 12) // Rd
+                      | BITS(tinstr, 3, 5);        // Rm
         } else if ((tinstr & 0x0F00) == 0x600) {
             if (BIT(tinstr, 5) == 0) {
                 // SETEND
-                *ainstr = 0xF1010000         // base
-                    | (BIT(tinstr, 3) << 9); // endian specifier
+                *ainstr = 0xF1010000               // base
+                          | (BIT(tinstr, 3) << 9); // endian specifier
             } else {
                 // CPS
-                *ainstr = 0xF1080000          // base
-                    | (BIT(tinstr, 0) << 6)   // fiq bit
-                    | (BIT(tinstr, 1) << 7)   // irq bit
-                    | (BIT(tinstr, 2) << 8)   // abort bit
-                    | (BIT(tinstr, 4) << 18); // enable bit
+                *ainstr = 0xF1080000                // base
+                          | (BIT(tinstr, 0) << 6)   // fiq bit
+                          | (BIT(tinstr, 1) << 7)   // irq bit
+                          | (BIT(tinstr, 2) << 8)   // abort 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
-                    | (BITS(tinstr, 0, 2) << 12)     // Rd
-                    | BITS(tinstr, 3, 5);            // Rm
+                *ainstr = subset[subset_index]         // base
+                          | (BITS(tinstr, 0, 2) << 12) // Rd
+                          | 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)
-                | (rn << 16)         // Rn
-                | (tinstr & 0x00FF); // Register list
-        }
-        else
-        {
-            *ainstr = 0xE8A00000              // base (STMIA)
-                | (BITS(tinstr, 8, 10) << 16) // Rn
-                | (tinstr & 0x00FF);          // Register list
+            *ainstr = base                 // base (LDMIA)
+                      | (rn << 16)         // Rn
+                      | (tinstr & 0x00FF); // Register list
+        } else {
+            *ainstr = 0xE8A00000                    // base (STMIA)
+                      | (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
-    DECODED,      // Instruction decoded to ARM equivalent
-    BRANCH,       // Thumb branch (already processed)
+    UNDEFINED, // Undefined Thumb instruction
+    DECODED,   // Instruction decoded to ARM equivalent
+    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..780638638 100644
--- a/src/core/arm/dyncom/arm_dyncom_trans.cpp
+++ b/src/core/arm/dyncom/arm_dyncom_trans.cpp
@@ -1,8 +1,6 @@
 #include <cstdlib>
-
 #include "common/assert.h"
 #include "common/common_types.h"
-
 #include "core/arm/dyncom/arm_dyncom_interpreter.h"
 #include "core/arm/dyncom/arm_dyncom_trans.h"
 #include "core/arm/skyeye_common/armstate.h"
@@ -19,24 +17,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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(adc_inst));
-    adc_inst *inst_cream = (adc_inst *)inst_base->component;
+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));
+    adc_inst* inst_cream = (adc_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->I  = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->I = BIT(inst, 25);
+    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 +44,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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(add_inst));
-    add_inst *inst_cream = (add_inst *)inst_base->component;
+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));
+    add_inst* inst_cream = (add_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->I  = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->I = BIT(inst, 25);
+    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 +64,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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(and_inst));
-    and_inst *inst_cream = (and_inst *)inst_base->component;
+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));
+    and_inst* inst_cream = (and_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->I  = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->I = BIT(inst, 25);
+    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 +84,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)
-{
-    #define POSBRANCH ((inst & 0x7fffff) << 2)
-    #define NEGBRANCH ((0xff000000 |(inst & 0xffffff)) << 2)
+static ARM_INST_PTR INTERPRETER_TRANSLATE(bbl)(unsigned int inst, int index) {
+#define POSBRANCH ((inst & 0x7fffff) << 2)
+#define NEGBRANCH ((0xff000000 | (inst & 0xffffff)) << 2)
 
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(bbl_inst));
-    bbl_inst *inst_cream = (bbl_inst *)inst_base->component;
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(bbl_inst));
+    bbl_inst* inst_cream = (bbl_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::DIRECT_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(bic_inst));
-    bic_inst *inst_cream = (bic_inst *)inst_base->component;
+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));
+    bic_inst* inst_cream = (bic_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->I  = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->I = BIT(inst, 25);
+    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 +123,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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(blx_inst));
-    blx_inst *inst_cream = (blx_inst *)inst_base->component;
+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));
+    blx_inst* inst_cream = (blx_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::INDIRECT_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::INDIRECT_BRANCH;
 
     inst_cream->inst = inst;
     if (BITS(inst, 20, 27) == 0x12 && BITS(inst, 4, 7) == 0x3) {
@@ -162,36 +153,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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(bx_inst));
-    bx_inst *inst_cream = (bx_inst *)inst_base->component;
+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));
+    bx_inst* inst_cream = (bx_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::INDIRECT_BRANCH;
+    inst_base->idx = index;
+    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));
-    cdp_inst *inst_cream = (cdp_inst *)inst_base->component;
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(cdp_inst));
+    cdp_inst* inst_cream = (cdp_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->CRm      = BITS(inst,  0,  3);
-    inst_cream->CRd      = BITS(inst, 12, 15);
-    inst_cream->CRn      = BITS(inst, 16, 19);
-    inst_cream->cp_num   = BITS(inst, 8, 11);
+    inst_cream->CRm = BITS(inst, 0, 3);
+    inst_cream->CRd = BITS(inst, 12, 15);
+    inst_cream->CRn = BITS(inst, 16, 19);
+    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 +188,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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(clrex_inst));
+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));
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     return inst_base;
 }
-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));
-    clz_inst *inst_cream = (clz_inst *)inst_base->component;
+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));
+    clz_inst* inst_cream = (clz_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(cmn_inst));
-    cmn_inst *inst_cream = (cmn_inst *)inst_base->component;
+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));
+    cmn_inst* inst_cream = (cmn_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(cmp_inst));
-    cmp_inst *inst_cream = (cmp_inst *)inst_base->component;
+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));
+    cmp_inst* inst_cream = (cmp_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(cps_inst));
-    cps_inst *inst_cream = (cps_inst *)inst_base->component;
+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));
+    cps_inst* inst_cream = (cps_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->A     = BIT(inst, 8);
-    inst_cream->I     = BIT(inst, 7);
-    inst_cream->F     = BIT(inst, 6);
-    inst_cream->mode  = BITS(inst, 0, 4);
+    inst_cream->mmod = BIT(inst, 17);
+    inst_cream->A = BIT(inst, 8);
+    inst_cream->I = BIT(inst, 7);
+    inst_cream->F = BIT(inst, 6);
+    inst_cream->mode = BITS(inst, 0, 4);
 
     return inst_base;
 }
-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));
-    mov_inst *inst_cream = (mov_inst *)inst_base->component;
+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));
+    mov_inst* inst_cream = (mov_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->I  = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->I = BIT(inst, 25);
+    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 +276,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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(eor_inst));
-    eor_inst *inst_cream = (eor_inst *)inst_base->component;
+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));
+    eor_inst* inst_cream = (eor_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->I  = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->I = BIT(inst, 25);
+    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 +296,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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldc_inst));
+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));
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     return inst_base;
 }
-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));
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
+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));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     inst_cream->inst = inst;
     inst_cream->get_addr = GetAddressingOp(inst);
@@ -340,29 +320,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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(sxtb_inst));
-    sxtb_inst *inst_cream = (sxtb_inst *)inst_base->component;
+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));
+    sxtb_inst* inst_cream = (sxtb_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->Rd     = BITS(inst, 12, 15);
-    inst_cream->Rm     = BITS(inst,  0,  3);
+    inst_cream->Rd = BITS(inst, 12, 15);
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
+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));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     inst_cream->inst = inst;
     inst_cream->get_addr = GetAddressingOp(inst);
@@ -373,14 +351,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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
+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));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     inst_cream->inst = inst;
     inst_cream->get_addr = GetAddressingOp(inst);
@@ -391,155 +368,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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(uxth_inst));
-    uxth_inst *inst_cream = (uxth_inst *)inst_base->component;
+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));
+    uxth_inst* inst_cream = (uxth_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(uxtah_inst));
-    uxtah_inst *inst_cream = (uxtah_inst *)inst_base->component;
+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));
+    uxtah_inst* inst_cream = (uxtah_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->Rn     = BITS(inst, 16, 19);
-    inst_cream->Rd     = BITS(inst, 12, 15);
+    inst_cream->Rn = BITS(inst, 16, 19);
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
+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));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
+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));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    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;
+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));
+    generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    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->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
+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));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
+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));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
+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));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     inst_cream->inst = inst;
     inst_cream->get_addr = GetAddressingOpLoadStoreT(inst);
@@ -549,70 +514,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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(mcr_inst));
-    mcr_inst *inst_cream = (mcr_inst *)inst_base->component;
+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));
+    mcr_inst* inst_cream = (mcr_inst*)inst_base->component;
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->crn      = BITS(inst, 16, 19);
-    inst_cream->crm      = BITS(inst,  0,  3);
+    inst_cream->crn = BITS(inst, 16, 19);
+    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->Rd       = BITS(inst, 12, 15);
-    inst_cream->cp_num   = BITS(inst,  8, 11);
-    inst_cream->inst     = inst;
+    inst_cream->opcode_2 = BITS(inst, 5, 7);
+    inst_cream->Rd = BITS(inst, 12, 15);
+    inst_cream->cp_num = BITS(inst, 8, 11);
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->rt       = BITS(inst, 12, 15);
-    inst_cream->rt2      = BITS(inst, 16, 19);
+    inst_cream->cp_num = BITS(inst, 8, 11);
+    inst_cream->rt = BITS(inst, 12, 15);
+    inst_cream->rt2 = BITS(inst, 16, 19);
 
     return inst_base;
 }
 
-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));
-    mla_inst *inst_cream = (mla_inst *)inst_base->component;
+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));
+    mla_inst* inst_cream = (mla_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->Rm = BITS(inst,  0,  3);
+    inst_cream->Rs = BITS(inst, 8, 11);
+    inst_cream->Rm = BITS(inst, 0, 3);
 
     return inst_base;
 }
-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));
-    mov_inst *inst_cream = (mov_inst *)inst_base->component;
+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));
+    mov_inst* inst_cream = (mov_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->I  = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->I = BIT(inst, 25);
+    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 +583,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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(mrc_inst));
-    mrc_inst *inst_cream = (mrc_inst *)inst_base->component;
+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));
+    mrc_inst* inst_cream = (mrc_inst*)inst_base->component;
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->crn      = BITS(inst, 16, 19);
-    inst_cream->crm      = BITS(inst,  0,  3);
+    inst_cream->crn = BITS(inst, 16, 19);
+    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->Rd       = BITS(inst, 12, 15);
-    inst_cream->cp_num   = BITS(inst,  8, 11);
-    inst_cream->inst     = inst;
+    inst_cream->opcode_2 = BITS(inst, 5, 7);
+    inst_cream->Rd = BITS(inst, 12, 15);
+    inst_cream->cp_num = BITS(inst, 8, 11);
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(mrs_inst));
-    mrs_inst *inst_cream = (mrs_inst *)inst_base->component;
+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));
+    mrs_inst* inst_cream = (mrs_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(msr_inst));
-    msr_inst *inst_cream = (msr_inst *)inst_base->component;
+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));
+    msr_inst* inst_cream = (msr_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     inst_cream->field_mask = BITS(inst, 16, 19);
-    inst_cream->R          = BIT(inst, 22);
-    inst_cream->inst       = inst;
+    inst_cream->R = BIT(inst, 22);
+    inst_cream->inst = inst;
 
     return inst_base;
 }
-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));
-    mul_inst *inst_cream = (mul_inst *)inst_base->component;
+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));
+    mul_inst* inst_cream = (mul_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(mvn_inst));
-    mvn_inst *inst_cream = (mvn_inst *)inst_base->component;
+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));
+    mvn_inst* inst_cream = (mvn_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->I  = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->I = BIT(inst, 25);
+    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 +664,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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(orr_inst));
-    orr_inst *inst_cream = (orr_inst *)inst_base->component;
+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));
+    orr_inst* inst_cream = (orr_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->I  = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->I = BIT(inst, 25);
+    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 +687,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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     return inst_base;
 }
 
-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));
-    pkh_inst *inst_cream = (pkh_inst *)inst_base->component;
+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));
+    pkh_inst* inst_cream = (pkh_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->Rd  = BITS(inst, 12, 15);
-    inst_cream->Rn  = BITS(inst, 16, 19);
-    inst_cream->Rm  = BITS(inst, 0, 3);
+    inst_cream->Rd = BITS(inst, 12, 15);
+    inst_cream->Rn = BITS(inst, 16, 19);
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(pld_inst));
+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));
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     inst_cream->op1 = BITS(inst, 21, 22);
-    inst_cream->Rm  = BITS(inst, 0, 3);
-    inst_cream->Rn  = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rm = BITS(inst, 0, 3);
+    inst_cream->Rn = BITS(inst, 16, 19);
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->Rm  = BITS(inst, 0, 3);
-    inst_cream->Rn  = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rm = BITS(inst, 0, 3);
+    inst_cream->Rn = BITS(inst, 16, 19);
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->Rm  = BITS(inst,  0,  3);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rm = BITS(inst, 0, 3);
+    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)
-{
-     return INTERPRETER_TRANSLATE(rev)(inst, index);
+static ARM_INST_PTR INTERPRETER_TRANSLATE(revsh)(unsigned int inst, int 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->br   = TransExtData::INDIRECT_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::INDIRECT_BRANCH;
 
     inst_cream->inst = inst;
     inst_cream->get_addr = GetAddressingOp(inst);
@@ -885,17 +820,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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(rsb_inst));
-    rsb_inst *inst_cream = (rsb_inst *)inst_base->component;
+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));
+    rsb_inst* inst_cream = (rsb_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->I  = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->I = BIT(inst, 25);
+    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 +840,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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(rsc_inst));
-    rsc_inst *inst_cream = (rsc_inst *)inst_base->component;
+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));
+    rsc_inst* inst_cream = (rsc_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->I  = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->I = BIT(inst, 25);
+    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 +860,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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->Rm  = BITS(inst, 0, 3);
-    inst_cream->Rn  = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rm = BITS(inst, 0, 3);
+    inst_cream->Rn = BITS(inst, 16, 19);
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(sbc_inst));
-    sbc_inst *inst_cream = (sbc_inst *)inst_base->component;
+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));
+    sbc_inst* inst_cream = (sbc_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->I  = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->I = BIT(inst, 25);
+    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 +912,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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->Rm  = BITS(inst, 0, 3);
-    inst_cream->Rn  = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rm = BITS(inst, 0, 3);
+    inst_cream->Rn = BITS(inst, 16, 19);
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->Rn  = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rm = BITS(inst, 0, 3);
+    inst_cream->Rn = BITS(inst, 16, 19);
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(smla_inst));
-    smla_inst *inst_cream = (smla_inst *)inst_base->component;
+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));
+    smla_inst* inst_cream = (smla_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->x  = BIT(inst, 5);
-    inst_cream->y  = BIT(inst, 6);
+    inst_cream->x = BIT(inst, 5);
+    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 +1002,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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->m   = BIT(inst, 5);
-    inst_cream->Rn  = BITS(inst, 0, 3);
-    inst_cream->Rm  = BITS(inst, 8, 11);
-    inst_cream->Rd  = BITS(inst, 16, 19);
-    inst_cream->Ra  = BITS(inst, 12, 15);
+    inst_cream->m = BIT(inst, 5);
+    inst_cream->Rn = BITS(inst, 0, 3);
+    inst_cream->Rm = BITS(inst, 8, 11);
+    inst_cream->Rd = BITS(inst, 16, 19);
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(umlal_inst));
-    umlal_inst *inst_cream = (umlal_inst *)inst_base->component;
+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));
+    umlal_inst* inst_cream = (umlal_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->S    = BIT(inst, 20);
-    inst_cream->Rm   = BITS(inst, 0, 3);
-    inst_cream->Rs   = BITS(inst, 8, 11);
+    inst_cream->S = BIT(inst, 20);
+    inst_cream->Rm = BITS(inst, 0, 3);
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->x    = BIT(inst, 5);
-    inst_cream->y    = BIT(inst, 6);
+    inst_cream->x = BIT(inst, 5);
+    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->Rm   = BITS(inst, 8, 11);
+    inst_cream->Rn = BITS(inst, 0, 4);
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->Rm   = BITS(inst, 8, 11);
-    inst_cream->Rn   = BITS(inst, 0, 3);
+    inst_cream->Rm = BITS(inst, 8, 11);
+    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->op2  = BITS(inst, 5, 7);
+    inst_cream->op1 = BITS(inst, 20, 22);
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->m   = BIT(inst, 5);
-    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, 5);
+    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->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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(smul_inst));
-    smul_inst *inst_cream = (smul_inst *)inst_base->component;
+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));
+    smul_inst* inst_cream = (smul_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     inst_cream->Rd = BITS(inst, 16, 19);
-    inst_cream->Rs = BITS(inst,  8, 11);
-    inst_cream->Rm = BITS(inst,  0,  3);
+    inst_cream->Rs = BITS(inst, 8, 11);
+    inst_cream->Rm = BITS(inst, 0, 3);
 
-    inst_cream->x  = BIT(inst, 5);
-    inst_cream->y  = BIT(inst, 6);
+    inst_cream->x = BIT(inst, 5);
+    inst_cream->y = BIT(inst, 6);
 
     return inst_base;
-
 }
-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));
-    umull_inst *inst_cream = (umull_inst *)inst_base->component;
+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));
+    umull_inst* inst_cream = (umull_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->S    = BIT(inst, 20);
-    inst_cream->Rm   = BITS(inst, 0, 3);
-    inst_cream->Rs   = BITS(inst, 8, 11);
+    inst_cream->S = BIT(inst, 20);
+    inst_cream->Rm = BITS(inst, 0, 3);
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(smlad_inst));
-    smlad_inst *inst_cream = (smlad_inst *)inst_base->component;
+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));
+    smlad_inst* inst_cream = (smlad_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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 +1179,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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     inst_cream->Rn = BITS(inst, 0, 3);
     inst_cream->Rd = BITS(inst, 12, 15);
@@ -1311,211 +1209,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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->Rn      = BITS(inst, 0, 3);
-    inst_cream->Rd      = BITS(inst, 12, 15);
+    inst_cream->Rn = BITS(inst, 0, 3);
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(stc_inst));
+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));
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     return inst_base;
 }
-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));
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
+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));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(sxtb_inst));
-    sxtb_inst *inst_cream = (sxtb_inst *)inst_base->component;
+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));
+    sxtb_inst* inst_cream = (sxtb_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->Rd     = BITS(inst, 12, 15);
-    inst_cream->Rm     = BITS(inst,  0,  3);
+    inst_cream->Rd = BITS(inst, 12, 15);
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
+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));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(uxth_inst));
-    uxth_inst *inst_cream = (uxth_inst *)inst_base->component;
+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));
+    uxth_inst* inst_cream = (uxth_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(uxtab_inst));
-    uxtab_inst *inst_cream = (uxtab_inst *)inst_base->component;
+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));
+    uxtab_inst* inst_cream = (uxtab_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->Rn     = BITS(inst, 16, 19);
+    inst_cream->Rm = BITS(inst, 0, 3);
+    inst_cream->Rn = BITS(inst, 16, 19);
 
     return inst_base;
 }
-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));
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
+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));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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){
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
+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));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    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;
+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));
+    generic_arm_inst* inst_cream = (generic_arm_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->Rn  = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
-    inst_cream->Rm  = BITS(inst, 0,   3);
+    inst_cream->Rn = BITS(inst, 16, 19);
+    inst_cream->Rd = BITS(inst, 12, 15);
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(ldst_inst));
-    ldst_inst *inst_cream = (ldst_inst *)inst_base->component;
+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));
+    ldst_inst* inst_cream = (ldst_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(sub_inst));
-    sub_inst *inst_cream = (sub_inst *)inst_base->component;
+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));
+    sub_inst* inst_cream = (sub_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->I  = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->I = BIT(inst, 25);
+    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 +1408,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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(swi_inst));
-    swi_inst *inst_cream = (swi_inst *)inst_base->component;
+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));
+    swi_inst* inst_cream = (swi_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(swp_inst));
-    swp_inst *inst_cream = (swp_inst *)inst_base->component;
+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));
+    swp_inst* inst_cream = (swp_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->Rn  = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
-    inst_cream->Rm  = BITS(inst,  0,  3);
+    inst_cream->Rn = BITS(inst, 16, 19);
+    inst_cream->Rd = BITS(inst, 12, 15);
+    inst_cream->Rm = BITS(inst, 0, 3);
 
     return inst_base;
 }
-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));
-    swp_inst *inst_cream = (swp_inst *)inst_base->component;
+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));
+    swp_inst* inst_cream = (swp_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->Rn  = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
-    inst_cream->Rm  = BITS(inst,  0,  3);
+    inst_cream->Rn = BITS(inst, 16, 19);
+    inst_cream->Rd = BITS(inst, 12, 15);
+    inst_cream->Rm = BITS(inst, 0, 3);
 
     return inst_base;
 }
-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));
-    sxtab_inst *inst_cream = (sxtab_inst *)inst_base->component;
+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));
+    sxtab_inst* inst_cream = (sxtab_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->Rn     = BITS(inst, 16, 19);
+    inst_cream->Rm = BITS(inst, 0, 3);
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     inst_cream->Rm = BITS(inst, 0, 3);
     inst_cream->Rn = BITS(inst, 16, 19);
@@ -1599,54 +1478,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));
-    sxtah_inst *inst_cream = (sxtah_inst *)inst_base->component;
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(sxtah_inst));
+    sxtah_inst* inst_cream = (sxtah_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->Rn     = BITS(inst, 16, 19);
+    inst_cream->Rm = BITS(inst, 0, 3);
+    inst_cream->Rn = BITS(inst, 16, 19);
 
     return inst_base;
 }
 
-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));
-    teq_inst *inst_cream = (teq_inst *)inst_base->component;
+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));
+    teq_inst* inst_cream = (teq_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->I               = BIT(inst, 25);
-    inst_cream->Rn              = BITS(inst, 16, 19);
+    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);
+    inst_cream->shtop_func = GetShifterOp(inst);
 
     return inst_base;
 }
-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));
-    tst_inst *inst_cream = (tst_inst *)inst_base->component;
+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));
+    tst_inst* inst_cream = (tst_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->I  = BIT(inst, 25);
-    inst_cream->S  = BIT(inst, 20);
+    inst_cream->I = BIT(inst, 25);
+    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 +1531,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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->Rn  = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rm = BITS(inst, 0, 3);
+    inst_cream->Rn = BITS(inst, 16, 19);
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->Rn  = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rm = BITS(inst, 0, 3);
+    inst_cream->Rn = BITS(inst, 16, 19);
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->Rm   = BITS(inst, 8, 11);
-    inst_cream->Rn   = BITS(inst, 0, 3);
+    inst_cream->Rm = BITS(inst, 8, 11);
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(umlal_inst));
-    umlal_inst *inst_cream = (umlal_inst *)inst_base->component;
+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));
+    umlal_inst* inst_cream = (umlal_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->S    = BIT(inst, 20);
-    inst_cream->Rm   = BITS(inst, 0, 3);
-    inst_cream->Rs   = BITS(inst, 8, 11);
+    inst_cream->S = BIT(inst, 20);
+    inst_cream->Rm = BITS(inst, 0, 3);
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(umull_inst));
-    umull_inst *inst_cream = (umull_inst *)inst_base->component;
+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));
+    umull_inst* inst_cream = (umull_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->S    = BIT(inst, 20);
-    inst_cream->Rm   = BITS(inst, 0, 3);
-    inst_cream->Rs   = BITS(inst, 8, 11);
+    inst_cream->S = BIT(inst, 20);
+    inst_cream->Rm = BITS(inst, 0, 3);
+    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)
-{
-    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;
+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));
+    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)
-{
-    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;
+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));
+    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->br    = TransExtData::DIRECT_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::DIRECT_BRANCH;
 
     return inst_base;
 }
 
-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));
-    bl_1_thumb *inst_cream = (bl_1_thumb *)inst_base->component;
+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));
+    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)
-{
-    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;
+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));
+    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)
-{
-    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;
+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));
+    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->br     = TransExtData::DIRECT_BRANCH;
+    inst_base->idx = index;
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->Rm  = BITS(inst, 0, 3);
-    inst_cream->Rn  = BITS(inst, 16, 19);
-    inst_cream->Rd  = BITS(inst, 12, 15);
+    inst_cream->Rm = BITS(inst, 0, 3);
+    inst_cream->Rn = BITS(inst, 16, 19);
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->Rm  = BITS(inst, 8, 11);
-    inst_cream->Rn  = BITS(inst, 0, 3);
-    inst_cream->Ra  = BITS(inst, 12, 15);
+    inst_cream->Rd = BITS(inst, 16, 19);
+    inst_cream->Rm = BITS(inst, 8, 11);
+    inst_cream->Rn = BITS(inst, 0, 3);
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->Rm     = BITS(inst, 0, 3);
-    inst_cream->Rn     = BITS(inst, 16, 19);
-    inst_cream->Rd     = BITS(inst, 12, 15);
+    inst_cream->Rm = BITS(inst, 0, 3);
+    inst_cream->Rn = BITS(inst, 16, 19);
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     return inst_base;
 }
@@ -1968,211 +1809,79 @@ 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(vmls),
-    INTERPRETER_TRANSLATE(vnmla),
-    INTERPRETER_TRANSLATE(vnmls),
-    INTERPRETER_TRANSLATE(vnmul),
-    INTERPRETER_TRANSLATE(vmul),
-    INTERPRETER_TRANSLATE(vadd),
-    INTERPRETER_TRANSLATE(vsub),
-    INTERPRETER_TRANSLATE(vdiv),
-    INTERPRETER_TRANSLATE(vmovi),
-    INTERPRETER_TRANSLATE(vmovr),
-    INTERPRETER_TRANSLATE(vabs),
-    INTERPRETER_TRANSLATE(vneg),
-    INTERPRETER_TRANSLATE(vsqrt),
-    INTERPRETER_TRANSLATE(vcmp),
-    INTERPRETER_TRANSLATE(vcmp2),
-    INTERPRETER_TRANSLATE(vcvtbds),
-    INTERPRETER_TRANSLATE(vcvtbff),
-    INTERPRETER_TRANSLATE(vcvtbfi),
-    INTERPRETER_TRANSLATE(vmovbrs),
-    INTERPRETER_TRANSLATE(vmsr),
-    INTERPRETER_TRANSLATE(vmovbrc),
-    INTERPRETER_TRANSLATE(vmrs),
-    INTERPRETER_TRANSLATE(vmovbcr),
-    INTERPRETER_TRANSLATE(vmovbrrss),
-    INTERPRETER_TRANSLATE(vmovbrrd),
-    INTERPRETER_TRANSLATE(vstr),
-    INTERPRETER_TRANSLATE(vpush),
-    INTERPRETER_TRANSLATE(vstm),
-    INTERPRETER_TRANSLATE(vpop),
-    INTERPRETER_TRANSLATE(vldr),
-    INTERPRETER_TRANSLATE(vldm),
-
-    INTERPRETER_TRANSLATE(srs),
-    INTERPRETER_TRANSLATE(rfe),
-    INTERPRETER_TRANSLATE(bkpt),
-    INTERPRETER_TRANSLATE(blx),
-    INTERPRETER_TRANSLATE(cps),
-    INTERPRETER_TRANSLATE(pld),
-    INTERPRETER_TRANSLATE(setend),
-    INTERPRETER_TRANSLATE(clrex),
-    INTERPRETER_TRANSLATE(rev16),
-    INTERPRETER_TRANSLATE(usad8),
-    INTERPRETER_TRANSLATE(sxtb),
-    INTERPRETER_TRANSLATE(uxtb),
-    INTERPRETER_TRANSLATE(sxth),
-    INTERPRETER_TRANSLATE(sxtb16),
-    INTERPRETER_TRANSLATE(uxth),
-    INTERPRETER_TRANSLATE(uxtb16),
-    INTERPRETER_TRANSLATE(cpy),
-    INTERPRETER_TRANSLATE(uxtab),
-    INTERPRETER_TRANSLATE(ssub8),
-    INTERPRETER_TRANSLATE(shsub8),
-    INTERPRETER_TRANSLATE(ssubaddx),
-    INTERPRETER_TRANSLATE(strex),
-    INTERPRETER_TRANSLATE(strexb),
-    INTERPRETER_TRANSLATE(swp),
-    INTERPRETER_TRANSLATE(swpb),
-    INTERPRETER_TRANSLATE(ssub16),
-    INTERPRETER_TRANSLATE(ssat16),
-    INTERPRETER_TRANSLATE(shsubaddx),
-    INTERPRETER_TRANSLATE(qsubaddx),
-    INTERPRETER_TRANSLATE(shaddsubx),
-    INTERPRETER_TRANSLATE(shadd8),
-    INTERPRETER_TRANSLATE(shadd16),
-    INTERPRETER_TRANSLATE(sel),
-    INTERPRETER_TRANSLATE(saddsubx),
-    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(vmla), INTERPRETER_TRANSLATE(vmls), INTERPRETER_TRANSLATE(vnmla),
+    INTERPRETER_TRANSLATE(vnmls), INTERPRETER_TRANSLATE(vnmul), INTERPRETER_TRANSLATE(vmul),
+    INTERPRETER_TRANSLATE(vadd), INTERPRETER_TRANSLATE(vsub), INTERPRETER_TRANSLATE(vdiv),
+    INTERPRETER_TRANSLATE(vmovi), INTERPRETER_TRANSLATE(vmovr), INTERPRETER_TRANSLATE(vabs),
+    INTERPRETER_TRANSLATE(vneg), INTERPRETER_TRANSLATE(vsqrt), INTERPRETER_TRANSLATE(vcmp),
+    INTERPRETER_TRANSLATE(vcmp2), INTERPRETER_TRANSLATE(vcvtbds), INTERPRETER_TRANSLATE(vcvtbff),
+    INTERPRETER_TRANSLATE(vcvtbfi), INTERPRETER_TRANSLATE(vmovbrs), INTERPRETER_TRANSLATE(vmsr),
+    INTERPRETER_TRANSLATE(vmovbrc), INTERPRETER_TRANSLATE(vmrs), INTERPRETER_TRANSLATE(vmovbcr),
+    INTERPRETER_TRANSLATE(vmovbrrss), INTERPRETER_TRANSLATE(vmovbrrd), INTERPRETER_TRANSLATE(vstr),
+    INTERPRETER_TRANSLATE(vpush), INTERPRETER_TRANSLATE(vstm), INTERPRETER_TRANSLATE(vpop),
+    INTERPRETER_TRANSLATE(vldr), INTERPRETER_TRANSLATE(vldm),
+
+    INTERPRETER_TRANSLATE(srs), INTERPRETER_TRANSLATE(rfe), INTERPRETER_TRANSLATE(bkpt),
+    INTERPRETER_TRANSLATE(blx), INTERPRETER_TRANSLATE(cps), INTERPRETER_TRANSLATE(pld),
+    INTERPRETER_TRANSLATE(setend), INTERPRETER_TRANSLATE(clrex), INTERPRETER_TRANSLATE(rev16),
+    INTERPRETER_TRANSLATE(usad8), INTERPRETER_TRANSLATE(sxtb), INTERPRETER_TRANSLATE(uxtb),
+    INTERPRETER_TRANSLATE(sxth), INTERPRETER_TRANSLATE(sxtb16), INTERPRETER_TRANSLATE(uxth),
+    INTERPRETER_TRANSLATE(uxtb16), INTERPRETER_TRANSLATE(cpy), INTERPRETER_TRANSLATE(uxtab),
+    INTERPRETER_TRANSLATE(ssub8), INTERPRETER_TRANSLATE(shsub8), INTERPRETER_TRANSLATE(ssubaddx),
+    INTERPRETER_TRANSLATE(strex), INTERPRETER_TRANSLATE(strexb), INTERPRETER_TRANSLATE(swp),
+    INTERPRETER_TRANSLATE(swpb), INTERPRETER_TRANSLATE(ssub16), INTERPRETER_TRANSLATE(ssat16),
+    INTERPRETER_TRANSLATE(shsubaddx), INTERPRETER_TRANSLATE(qsubaddx),
+    INTERPRETER_TRANSLATE(shaddsubx), INTERPRETER_TRANSLATE(shadd8), INTERPRETER_TRANSLATE(shadd16),
+    INTERPRETER_TRANSLATE(sel), INTERPRETER_TRANSLATE(saddsubx), 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_cond_thumb),
-    INTERPRETER_TRANSLATE(bl_1_thumb),
-    INTERPRETER_TRANSLATE(bl_2_thumb),
-    INTERPRETER_TRANSLATE(blx_1_thumb)
+    INTERPRETER_TRANSLATE(b_2_thumb), INTERPRETER_TRANSLATE(b_cond_thumb),
+    INTERPRETER_TRANSLATE(bl_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..b1ec90662 100644
--- a/src/core/arm/dyncom/arm_dyncom_trans.h
+++ b/src/core/arm/dyncom/arm_dyncom_trans.h
@@ -1,16 +1,19 @@
+#include <cstddef>
+#include "common/common_types.h"
+
 struct ARMul_State;
 typedef unsigned int (*shtop_fp_t)(ARMul_State* cpu, unsigned int sht_oper);
 
 enum class TransExtData {
-    COND            = (1 << 0),
-    NON_BRANCH      = (1 << 1),
-    DIRECT_BRANCH   = (1 << 2),
+    COND = (1 << 0),
+    NON_BRANCH = (1 << 1),
+    DIRECT_BRANCH = (1 << 2),
     INDIRECT_BRANCH = (1 << 3),
-    CALL            = (1 << 4),
-    RET             = (1 << 5),
-    END_OF_PAGE     = (1 << 6),
-    THUMB           = (1 << 7),
-    SINGLE_STEP     = (1 << 8)
+    CALL = (1 << 4),
+    RET = (1 << 5),
+    END_OF_PAGE = (1 << 6),
+    THUMB = (1 << 7),
+    SINGLE_STEP = (1 << 8)
 };
 
 struct arm_inst {
@@ -106,8 +109,7 @@ struct cps_inst {
     unsigned int mode;
 };
 
-struct clrex_inst {
-};
+struct clrex_inst {};
 
 struct cpy_inst {
     unsigned int Rm;
@@ -163,11 +165,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 +369,7 @@ struct msr_inst {
     unsigned int inst;
 };
 
-struct pld_inst {
-};
+struct pld_inst {};
 
 struct sxtb_inst {
     unsigned int Rd;
@@ -475,7 +474,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..1465b074e 100644
--- a/src/core/arm/skyeye_common/armstate.cpp
+++ b/src/core/arm/skyeye_common/armstate.cpp
@@ -3,21 +3,19 @@
 // Refer to the license.txt file included.
 
 #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 (crn == 0 && opcode_1 == 0)
-        {
-            if (crm == 0)
-            {
+    if (InAPrivilegedMode()) {
+        if (crn == 0 && opcode_1 == 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 (opcode_1 == 0 && crm == 12)
-            {
+        if (crn == 15) {
+            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)
-{
-    if (InAPrivilegedMode())
-    {
-        if (crn == 1 && opcode_1 == 0 && crm == 0)
-        {
+void ARMul_State::WriteCP15Register(u32 value, u32 crn, u32 opcode_1, u32 crm, u32 opcode_2) {
+    if (InAPrivilegedMode()) {
+        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)
-        {
-            if (crm == 0 && opcode_2 == 4)
-            {
+        } else if (crn == 7 && opcode_1 == 0) {
+            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)
-        {
-            if (crm == 5)
-            {
+        } else if (crn == 8 && opcode_1 == 0) {
+            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)
-        {
-            if (crm == 0 && opcode_2 == 0)
-            {
+        } else if (crn == 10 && opcode_1 == 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)
-        {
-            if (opcode_1 == 0 && crm == 12)
-            {
+        } else if (crn == 15) {
+            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)
-            {
-                if (crm == 4)
-                {
+            } else if (opcode_1 == 5) {
+                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..1a707ff7e 100644
--- a/src/core/arm/skyeye_common/armstate.h
+++ b/src/core/arm/skyeye_common/armstate.h
@@ -19,80 +19,74 @@
 
 #include <array>
 #include <unordered_map>
-
 #include "common/common_types.h"
 #include "core/arm/skyeye_common/arm_regformat.h"
 
 // Signal levels
-enum {
-    LOW     = 0,
-    HIGH    = 1,
-    LOWHIGH = 1,
-    HIGHLOW = 2
-};
+enum { 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,
-    FIQ32MODE    = 17,
-    IRQ32MODE    = 18,
-    SVC32MODE    = 19,
-    ABORT32MODE  = 23,
-    UNDEF32MODE  = 27,
+    USER32MODE = 16,
+    FIQ32MODE = 17,
+    IRQ32MODE = 18,
+    SVC32MODE = 19,
+    ABORT32MODE = 23,
+    UNDEF32MODE = 27,
     SYSTEM32MODE = 31
 };
 
 // ARM privilege mode register banks
 enum {
-    USERBANK   = 0,
-    FIQBANK    = 1,
-    IRQBANK    = 2,
-    SVCBANK    = 3,
-    ABORTBANK  = 4,
-    UNDEFBANK  = 5,
-    DUMMYBANK  = 6,
+    USERBANK = 0,
+    FIQBANK = 1,
+    IRQBANK = 2,
+    SVCBANK = 3,
+    ABORTBANK = 4,
+    UNDEFBANK = 5,
+    DUMMYBANK = 6,
     SYSTEMBANK = 7
 };
 
 // Hardware vector addresses
 enum {
-    ARMResetV          = 0,
+    ARMResetV = 0,
     ARMUndefinedInstrV = 4,
-    ARMSWIV            = 8,
-    ARMPrefetchAbortV  = 12,
-    ARMDataAbortV      = 16,
-    ARMAddrExceptnV    = 20,
-    ARMIRQV            = 24,
-    ARMFIQV            = 28,
-    ARMErrorV          = 32, // This is an offset, not an address!
-
-    ARMul_ResetV          = ARMResetV,
+    ARMSWIV = 8,
+    ARMPrefetchAbortV = 12,
+    ARMDataAbortV = 16,
+    ARMAddrExceptnV = 20,
+    ARMIRQV = 24,
+    ARMFIQV = 28,
+    ARMErrorV = 32, // This is an offset, not an address!
+
+    ARMul_ResetV = ARMResetV,
     ARMul_UndefinedInstrV = ARMUndefinedInstrV,
-    ARMul_SWIV            = ARMSWIV,
-    ARMul_PrefetchAbortV  = ARMPrefetchAbortV,
-    ARMul_DataAbortV      = ARMDataAbortV,
-    ARMul_AddrExceptnV    = ARMAddrExceptnV,
-    ARMul_IRQV            = ARMIRQV,
-    ARMul_FIQV            = ARMFIQV
+    ARMul_SWIV = ARMSWIV,
+    ARMul_PrefetchAbortV = ARMPrefetchAbortV,
+    ARMul_DataAbortV = ARMDataAbortV,
+    ARMul_AddrExceptnV = ARMAddrExceptnV,
+    ARMul_IRQV = ARMIRQV,
+    ARMul_FIQV = ARMFIQV
 };
 
 // Coprocessor status values
 enum {
-    ARMul_FIRST     = 0,
-    ARMul_TRANSFER  = 1,
-    ARMul_BUSY      = 2,
-    ARMul_DATA      = 3,
+    ARMul_FIRST = 0,
+    ARMul_TRANSFER = 1,
+    ARMul_BUSY = 2,
+    ARMul_DATA = 3,
     ARMul_INTERRUPT = 4,
-    ARMul_DONE      = 0,
-    ARMul_CANT      = 1,
-    ARMul_INC       = 3
+    ARMul_DONE = 0,
+    ARMul_CANT = 1,
+    ARMul_INC = 3
 };
 
 // Instruction condition codes
@@ -136,15 +130,13 @@ enum : u32 {
 
 // Values for Emulate.
 enum {
-    STOP       = 0, // Stop
+    STOP = 0,       // Stop
     CHANGEMODE = 1, // Change mode
-    ONCE       = 2, // Execute just one iteration
-    RUN        = 3  // Continuous execution
+    ONCE = 2,       // Execute just one iteration
+    RUN = 3         // Continuous execution
 };
 
-
-struct ARMul_State final
-{
+struct ARMul_State final {
 public:
     explicit ARMul_State(PrivilegeMode initial_mode);
 
@@ -193,7 +185,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 +208,8 @@ public:
     u32 Spsr_copy;
     u32 phys_pc;
 
-    u32 Mode;          // The current mode
-    u32 Bank;          // The current register bank
+    u32 Mode; // The current mode
+    u32 Bank; // The current register bank
 
     u32 NFlag, ZFlag, CFlag, VFlag, IFFlags; // Dummy flags for speed
     unsigned int shifter_carry_out;
@@ -243,9 +235,9 @@ public:
 private:
     void ResetMPCoreCP15Registers();
 
-    // Defines a reservation granule of 2 words, which protects the first 2 words starting at the tag.
-    // This is the smallest granule allowed by the v7 spec, and is coincidentally just large enough to
-    // support LDR/STREXD.
+    // Defines a reservation granule of 2 words, which protects the first 2 words starting at the
+    // 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;
 
     u32 exclusive_tag; // The address for which the local monitor is in exclusive access mode
diff --git a/src/core/arm/skyeye_common/armsupp.cpp b/src/core/arm/skyeye_common/armsupp.cpp
index 883713e86..06aa1b075 100644
--- a/src/core/arm/skyeye_common/armsupp.cpp
+++ b/src/core/arm/skyeye_common/armsupp.cpp
@@ -16,14 +16,12 @@
     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
 
 #include "common/logging/log.h"
-
 #include "core/arm/skyeye_common/arm_regformat.h"
 #include "core/arm/skyeye_common/armstate.h"
 #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 +29,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 +45,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)
-{
-    return ((NEG(a) && NEG(b) && POS(result)) ||
-            (POS(a) && POS(b) && NEG(result)));
+bool AddOverflow(u32 a, u32 b, u32 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)
-{
-    return ((NEG(a) && POS(b) && POS(result)) ||
-            (POS(a) && NEG(b) && NEG(result)));
+bool SubOverflow(u32 a, u32 b, u32 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 +64,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 +78,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 +92,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 +106,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 +120,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 +130,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 +140,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 +148,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 +156,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 +173,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 NEG(i) ( (i) >> 31 )
+#define POS(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_SW       = 0,    // Software emulation bit value
-    VFP_FPSID_SUBARCH  = 0x1,  // Subarchitecture version number
-    VFP_FPSID_PARTNUM  = 0x20, // Part number
-    VFP_FPSID_VARIANT  = 0xB,  // Variant number
-    VFP_FPSID_REVISION = 0x4   // Revision number
+    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_SUBARCH = 0x1,  // Subarchitecture version number
+    VFP_FPSID_PARTNUM = 0x20, // Part number
+    VFP_FPSID_VARIANT = 0xB,  // Variant number
+    VFP_FPSID_REVISION = 0x4  // Revision number
 };
 
 // FPEXC bits
 enum : u32 {
-    FPEXC_EX          = (1U << 31U),
-    FPEXC_EN          = (1 << 30),
-    FPEXC_DEX         = (1 << 29),
-    FPEXC_FP2V        = (1 << 28),
-    FPEXC_VV          = (1 << 27),
-    FPEXC_TFV         = (1 << 26),
-    FPEXC_LENGTH_BIT  = (8),
+    FPEXC_EX = (1U << 31U),
+    FPEXC_EN = (1 << 30),
+    FPEXC_DEX = (1 << 29),
+    FPEXC_FP2V = (1 << 28),
+    FPEXC_VV = (1 << 27),
+    FPEXC_TFV = (1 << 26),
+    FPEXC_LENGTH_BIT = (8),
     FPEXC_LENGTH_MASK = (7 << FPEXC_LENGTH_BIT),
-    FPEXC_IDF         = (1 << 7),
-    FPEXC_IXF         = (1 << 4),
-    FPEXC_UFF         = (1 << 3),
-    FPEXC_OFF         = (1 << 2),
-    FPEXC_DZF         = (1 << 1),
-    FPEXC_IOF         = (1 << 0),
-    FPEXC_TRAP_MASK   = (FPEXC_IDF|FPEXC_IXF|FPEXC_UFF|FPEXC_OFF|FPEXC_DZF|FPEXC_IOF)
+    FPEXC_IDF = (1 << 7),
+    FPEXC_IXF = (1 << 4),
+    FPEXC_UFF = (1 << 3),
+    FPEXC_OFF = (1 << 2),
+    FPEXC_DZF = (1 << 1),
+    FPEXC_IOF = (1 << 0),
+    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_ZFLAG         = (1 << 30),   // Zero condition flag
-    FPSCR_CFLAG         = (1 << 29),   // Carry condition flag
-    FPSCR_VFLAG         = (1 << 28),   // Overflow condition flag
+    FPSCR_NFLAG = (1U << 31U), // Negative condition flag
+    FPSCR_ZFLAG = (1 << 30),   // Zero condition flag
+    FPSCR_CFLAG = (1 << 29),   // Carry condition flag
+    FPSCR_VFLAG = (1 << 28),   // Overflow condition flag
 
-    FPSCR_QC            = (1 << 27),   // Cumulative saturation bit
-    FPSCR_AHP           = (1 << 26),   // Alternative half-precision 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_RMODE_MASK    = (3 << 22),   // Rounding Mode bit mask
-    FPSCR_STRIDE_MASK   = (3 << 20),   // Vector stride bit mask
-    FPSCR_LENGTH_MASK   = (7 << 16),   // Vector length bit mask
+    FPSCR_QC = (1 << 27),            // Cumulative saturation bit
+    FPSCR_AHP = (1 << 26),           // Alternative half-precision 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_RMODE_MASK = (3 << 22),    // Rounding Mode bit mask
+    FPSCR_STRIDE_MASK = (3 << 20),   // Vector stride bit mask
+    FPSCR_LENGTH_MASK = (7 << 16),   // Vector length bit mask
 
-    FPSCR_IDE           = (1 << 15),   // Input Denormal exception trap enable.
-    FPSCR_IXE           = (1 << 12),   // Inexact exception trap enable
-    FPSCR_UFE           = (1 << 11),   // Undeflow exception trap enable
-    FPSCR_OFE           = (1 << 10),   // Overflow exception trap enable
-    FPSCR_DZE           = (1 << 9),    // Division by Zero exception trap enable
-    FPSCR_IOE           = (1 << 8),    // Invalid Operation exception trap enable
+    FPSCR_IDE = (1 << 15), // Input Denormal exception trap enable.
+    FPSCR_IXE = (1 << 12), // Inexact exception trap enable
+    FPSCR_UFE = (1 << 11), // Undeflow exception trap enable
+    FPSCR_OFE = (1 << 10), // Overflow exception trap enable
+    FPSCR_DZE = (1 << 9),  // Division by Zero exception trap enable
+    FPSCR_IOE = (1 << 8),  // Invalid Operation exception trap enable
 
-    FPSCR_IDC           = (1 << 7),    // Input Denormal cumulative exception bit
-    FPSCR_IXC           = (1 << 4),    // Inexact cumulative exception bit
-    FPSCR_UFC           = (1 << 3),    // Undeflow cumulative exception bit
-    FPSCR_OFC           = (1 << 2),    // Overflow cumulative exception bit
-    FPSCR_DZC           = (1 << 1),    // Division by Zero cumulative exception bit
-    FPSCR_IOC           = (1 << 0),    // Invalid Operation cumulative exception bit
+    FPSCR_IDC = (1 << 7), // Input Denormal cumulative exception bit
+    FPSCR_IXC = (1 << 4), // Inexact cumulative exception bit
+    FPSCR_UFC = (1 << 3), // Undeflow cumulative exception bit
+    FPSCR_OFC = (1 << 2), // Overflow cumulative exception bit
+    FPSCR_DZC = (1 << 1), // Division by Zero 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_PLUSINF  = (1 << 22),
+    FPSCR_ROUND_NEAREST = (0 << 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..f36c75a07 100644
--- a/src/core/arm/skyeye_common/vfp/vfp.cpp
+++ b/src/core/arm/skyeye_common/vfp/vfp.cpp
@@ -23,20 +23,18 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-
 #include "core/arm/skyeye_common/armstate.h"
 #include "core/arm/skyeye_common/vfp/asm_vfp.h"
 #include "core/arm/skyeye_common/vfp/vfp.h"
 
-void VFPInit(ARMul_State* state)
-{
-    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;
+void VFPInit(ARMul_State* state) {
+    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;
     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 +42,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)
-{
-    if (to_arm)
-    {
+void VMOVBRS(ARMul_State* state, u32 to_arm, u32 t, u32 n, u32* value) {
+    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)
-{
-    if (to_arm)
-    {
-        *value2 = state->ExtReg[n*2+1];
-        *value1 = state->ExtReg[n*2];
-    }
-    else
-    {
-        state->ExtReg[n*2+1] = *value2;
-        state->ExtReg[n*2] = *value1;
+void VMOVBRRD(ARMul_State* state, u32 to_arm, u32 t, u32 t2, u32 n, u32* value1, u32* value2) {
+    if (to_arm) {
+        *value2 = state->ExtReg[n * 2 + 1];
+        *value1 = state->ExtReg[n * 2];
+    } 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)
-{
-    if (to_arm)
-    {
-        *value1 = state->ExtReg[n+0];
-        *value2 = state->ExtReg[n+1];
-    }
-    else
-    {
-        state->ExtReg[n+0] = *value1;
-        state->ExtReg[n+1] = *value2;
+void VMOVBRRSS(ARMul_State* state, u32 to_arm, u32 t, u32 t2, u32 n, u32* value1, u32* value2) {
+    if (to_arm) {
+        *value1 = state->ExtReg[n + 0];
+        *value2 = state->ExtReg[n + 1];
+    } else {
+        state->ExtReg[n + 0] = *value1;
+        state->ExtReg[n + 1] = *value2;
     }
 }
 
-void VMOVI(ARMul_State* state, u32 single, u32 d, u32 imm)
-{
-    if (single)
-    {
+void VMOVI(ARMul_State* state, u32 single, u32 d, u32 imm) {
+    if (single) {
         state->ExtReg[d] = imm;
-    }
-    else
-    {
+    } else {
         /* Check endian please */
-        state->ExtReg[d*2+1] = imm;
-        state->ExtReg[d*2] = 0;
+        state->ExtReg[d * 2 + 1] = imm;
+        state->ExtReg[d * 2] = 0;
     }
 }
-void VMOVR(ARMul_State* state, u32 single, u32 d, u32 m)
-{
-    if (single)
-    {
+void VMOVR(ARMul_State* state, u32 single, u32 d, u32 m) {
+    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] = state->ExtReg[m*2];
+        state->ExtReg[d * 2 + 1] = state->ExtReg[m * 2 + 1];
+        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 result = ((u64) state->ExtReg[reg*2+1])<<32 | state->ExtReg[reg*2];
+u64 vfp_get_double(ARMul_State* state, unsigned int reg) {
+    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)
-{
-    LOG_TRACE(Core_ARM11, "VFP put double: s[%d-%d] <= [%08x-%08x]", reg * 2 + 1, reg * 2, (u32)(val >> 32), (u32)(val & 0xffffffff));
-    state->ExtReg[reg*2] = (u32) (val & 0xffffffff);
-    state->ExtReg[reg*2+1] = (u32) (val>>32);
+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,
+              (u32)(val >> 32), (u32)(val & 0xffffffff));
+    state->ExtReg[reg * 2] = (u32)(val & 0xffffffff);
+    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 +128,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))
-        fpscr &= ~(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 |= 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_FMAC  = 0x00000000,
+    FOP_MASK = 0x00b00040,
+    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_FSUB  = 0x00300040,
-    FOP_FDIV  = 0x00800000,
-    FOP_EXT   = 0x00b00040
+    FOP_FADD = 0x00300000,
+    FOP_FSUB = 0x00300040,
+    FOP_FDIV = 0x00800000,
+    FOP_EXT = 0x00b00040
 };
 
 #define FOP_TO_IDX(inst) ((inst & 0x00b00000) >> 20 | (inst & (1 << 6)) >> 4)
 
 enum : u32 {
-    FEXT_MASK   = 0x000f0080,
-    FEXT_FCPY   = 0x00000000,
-    FEXT_FABS   = 0x00000080,
-    FEXT_FNEG   = 0x00010000,
-    FEXT_FSQRT  = 0x00010080,
-    FEXT_FCMP   = 0x00040000,
-    FEXT_FCMPE  = 0x00040080,
-    FEXT_FCMPZ  = 0x00050000,
+    FEXT_MASK = 0x000f0080,
+    FEXT_FCPY = 0x00000000,
+    FEXT_FABS = 0x00000080,
+    FEXT_FNEG = 0x00010000,
+    FEXT_FSQRT = 0x00010080,
+    FEXT_FCMP = 0x00040000,
+    FEXT_FCMPE = 0x00040080,
+    FEXT_FCMPZ = 0x00050000,
     FEXT_FCMPEZ = 0x00050080,
-    FEXT_FCVT   = 0x00070080,
-    FEXT_FUITO  = 0x00080000,
-    FEXT_FSITO  = 0x00080080,
-    FEXT_FTOUI  = 0x000c0000,
+    FEXT_FCVT = 0x00070080,
+    FEXT_FUITO = 0x00080000,
+    FEXT_FSITO = 0x00080080,
+    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_dd(inst)  ((inst & 0x0000f000) >> 12 | (inst & (1 << 22)) >> 18)
-#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_sn(inst)  ((inst & 0x000f0000) >> 15 | (inst & (1 << 7)) >> 7)
-#define vfp_get_dn(inst)  ((inst & 0x000f0000) >> 16 | (inst & (1 << 7)) >> 3)
+#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_sm(inst) ((inst & 0x0000000f) << 1 | (inst & (1 << 5)) >> 5)
+#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_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;
-    u16 sign;
-    u32 significand;
+    s16 exponent;
+    u16 sign;
+    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_negate(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_sign(v) ((v)&0x80000000)
+#define vfp_single_packed_negate(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_mantissa(v) ((v) & ((1 << VFP_SINGLE_MANTISSA_BITS) - 1))
 
 enum : u32 {
-    VFP_NUMBER     = (1 << 0),
-    VFP_ZERO       = (1 << 1),
-    VFP_DENORMAL   = (1 << 2),
-    VFP_INFINITY   = (1 << 3),
-    VFP_NAN        = (1 << 4),
+    VFP_NUMBER = (1 << 0),
+    VFP_ZERO = (1 << 1),
+    VFP_DENORMAL = (1 << 2),
+    VFP_INFINITY = (1 << 3),
+    VFP_NAN = (1 << 4),
     VFP_NAN_SIGNAL = (1 << 5),
 
-    VFP_QNAN       = (VFP_NAN),
-    VFP_SNAN       = (VFP_NAN|VFP_NAN_SIGNAL)
+    VFP_QNAN = (VFP_NAN),
+    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->exponent = vfp_single_packed_exponent(val);
+    s->sign = vfp_single_packed_sign(val) >> 16, 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)
-{
-    u32 val = (s->sign << 16) +
-              (s->exponent << VFP_SINGLE_MANTISSA_BITS) +
+inline s32 vfp_single_pack(const vfp_single* s) {
+    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, const char* func);
+u32 vfp_single_normaliseround(ARMul_State* state, int sd, vfp_single* vs, u32 fpscr,
+                              const char* func);
 
 // Double-precision
 struct vfp_double {
-    s16 exponent;
-    u16 sign;
-    u64 significand;
+    s16 exponent;
+    u16 sign;
+    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_negate(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_sign(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_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)
-{
-    u64 val = ((u64)s->sign << 48) +
-              ((u64)s->exponent << VFP_DOUBLE_MANTISSA_BITS) +
+inline s64 vfp_double_pack(const vfp_double* s) {
+    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 {
-    OP_SCALAR = (1 << 0),
-    OP_SD     = (1 << 1),
-    OP_DD     = (1 << 1),
-    OP_SM     = (1 << 2)
-};
+enum : u32 { 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_normaliseround(ARMul_State* state, int dd, vfp_double* vd, u32 fpscr, const char* func);
+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);
diff --git a/src/core/arm/skyeye_common/vfp/vfpdouble.cpp b/src/core/arm/skyeye_common/vfp/vfpdouble.cpp
index 1d5641810..2886f351f 100644
--- a/src/core/arm/skyeye_common/vfp/vfpdouble.cpp
+++ b/src/core/arm/skyeye_common/vfp/vfpdouble.cpp
@@ -53,24 +53,20 @@
 
 #include <algorithm>
 #include "common/logging/log.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"
-#include "core/arm/skyeye_common/vfp/asm_vfp.h"
 
 static struct vfp_double vfp_double_default_qnan = {
-    2047,
-    0,
-    VFP_DOUBLE_SIGNIFICAND_QNAN,
+    2047, 0, VFP_DOUBLE_SIGNIFICAND_QNAN,
 };
 
-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, d->exponent, d->significand);
+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,
+              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,
-                 dd, d, exceptions);
+        LOG_TRACE(Core_ARM11, "VFP: %s: d(d%d)=%016llx exceptions=%08x", func, 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
-vfp_propagate_nan(struct vfp_double *vdd, struct vfp_double *vdn,
-                  struct vfp_double *vdm, u32 fpscr)
-{
-    struct vfp_double *nan;
+static u32 vfp_propagate_nan(struct vfp_double* vdd, struct vfp_double* vdn, struct vfp_double* vdm,
+                             u32 fpscr) {
+    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_fabs,   0 },                 //0x00000001 - FEXT_FABS
-    { vfp_double_fneg,   0 },                 //0x00000002 - FEXT_FNEG
-    { vfp_double_fsqrt,  0 },                 //0x00000003 - FEXT_FSQRT
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { vfp_double_fcmp,   OP_SCALAR },         //0x00000008 - FEXT_FCMP
-    { vfp_double_fcmpe,  OP_SCALAR },         //0x00000009 - FEXT_FCMPE
-    { vfp_double_fcmpz,  OP_SCALAR },         //0x0000000A - FEXT_FCMPZ
-    { vfp_double_fcmpez, OP_SCALAR },         //0x0000000B - FEXT_FCMPEZ
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { vfp_double_fcvts,  OP_SCALAR|OP_DD },   //0x0000000F - FEXT_FCVT
-    { vfp_double_fuito,  OP_SCALAR|OP_SM },   //0x00000010 - FEXT_FUITO
-    { vfp_double_fsito,  OP_SCALAR|OP_SM },   //0x00000011 - FEXT_FSITO
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { vfp_double_ftoui,  OP_SCALAR|OP_SD },   //0x00000018 - FEXT_FTOUI
-    { vfp_double_ftouiz, OP_SCALAR|OP_SD },   //0x00000019 - FEXT_FTOUIZ
-    { vfp_double_ftosi,  OP_SCALAR|OP_SD },   //0x0000001A - FEXT_FTOSI
-    { vfp_double_ftosiz, OP_SCALAR|OP_SD },   //0x0000001B - FEXT_FTOSIZ
+    {vfp_double_fcpy, 0},  // 0x00000000 - FEXT_FCPY
+    {vfp_double_fabs, 0},  // 0x00000001 - FEXT_FABS
+    {vfp_double_fneg, 0},  // 0x00000002 - FEXT_FNEG
+    {vfp_double_fsqrt, 0}, // 0x00000003 - FEXT_FSQRT
+    {nullptr, 0},
+    {nullptr, 0},
+    {nullptr, 0},
+    {nullptr, 0},
+    {vfp_double_fcmp, OP_SCALAR},   // 0x00000008 - FEXT_FCMP
+    {vfp_double_fcmpe, OP_SCALAR},  // 0x00000009 - FEXT_FCMPE
+    {vfp_double_fcmpz, OP_SCALAR},  // 0x0000000A - FEXT_FCMPZ
+    {vfp_double_fcmpez, OP_SCALAR}, // 0x0000000B - FEXT_FCMPEZ
+    {nullptr, 0},
+    {nullptr, 0},
+    {nullptr, 0},
+    {vfp_double_fcvts, OP_SCALAR | OP_DD}, // 0x0000000F - FEXT_FCVT
+    {vfp_double_fuito, OP_SCALAR | OP_SM}, // 0x00000010 - FEXT_FUITO
+    {vfp_double_fsito, OP_SCALAR | OP_SM}, // 0x00000011 - FEXT_FSITO
+    {nullptr, 0},
+    {nullptr, 0},
+    {nullptr, 0},
+    {nullptr, 0},
+    {nullptr, 0},
+    {nullptr, 0},
+    {vfp_double_ftoui, OP_SCALAR | OP_SD},  // 0x00000018 - FEXT_FTOUI
+    {vfp_double_ftouiz, OP_SCALAR | OP_SD}, // 0x00000019 - FEXT_FTOUIZ
+    {vfp_double_ftosi, OP_SCALAR | OP_SD},  // 0x0000001A - FEXT_FTOSI
+    {vfp_double_ftosiz, OP_SCALAR | OP_SD}, // 0x0000001B - FEXT_FTOSIZ
 };
 
-static u32
-vfp_double_fadd_nonnumber(struct vfp_double *vdd, struct vfp_double *vdn,
-                          struct vfp_double *vdm, u32 fpscr)
-{
-    struct vfp_double *vdp;
+static u32 vfp_double_fadd_nonnumber(struct vfp_double* vdd, struct vfp_double* vdn,
+                                     struct vfp_double* vdm, u32 fpscr) {
+    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) ||
-            vdm->significand & (1ULL << 63)) {
+    if (vdn->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) ==
-                        FPSCR_ROUND_MINUSINF ? 0x8000 : 0;
+            vdd->sign = (fpscr & FPSCR_RMODE_MASK) == 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
-vfp_double_multiply(struct vfp_double *vdd, struct vfp_double *vdn,
-                    struct vfp_double *vdm, u32 fpscr)
-{
+u32 vfp_double_multiply(struct vfp_double* vdd, struct vfp_double* vdn, 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_SUBTRACT    (1 << 1)
+#define NEG_MULTIPLY (1 << 0)
+#define NEG_SUBTRACT (1 << 1)
 
-static u32
-vfp_double_multiply_accumulate(ARMul_State* state, int dd, int dn, int dm, u32 fpscr, u32 negate, const char *func)
-{
+static u32 vfp_double_multiply_accumulate(ARMul_State* state, int dd, int dn, int dm, u32 fpscr,
+                                          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_fmsc,  0 },
-    { vfp_double_fmul,  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 },
+    {vfp_double_fmac, 0},  {vfp_double_fmsc, 0},  {vfp_double_fmul, 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_IDX(x)     ((x) & 3)
+#define FREG_BANK(x) ((x)&0x0c)
+#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)",
-                     vecitr >> FPSCR_LENGTH_BIT,
-                     type, dest, dn, dm);
+            LOG_TRACE(Core_ARM11, "VFP: itr%d (%c%u) = op[%u] (d%u)", vecitr >> FPSCR_LENGTH_BIT,
+                      type, dest, dn, dm);
         else
             LOG_TRACE(Core_ARM11, "VFP: itr%d (%c%u) = (d%u) op[%u] (d%u)",
-                     vecitr >> FPSCR_LENGTH_BIT,
-                     type, dest, dn, FOP_TO_IDX(op), dm);
+                      vecitr >> FPSCR_LENGTH_BIT, 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",
-                 vecitr >> FPSCR_LENGTH_BIT, except);
+        LOG_TRACE(Core_ARM11, "VFP: itr%d: exceptions=%08x", 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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmla_inst));
-    vmla_inst *inst_cream = (vmla_inst *)inst_base->component;
+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));
+    vmla_inst* inst_cream = (vmla_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmls_inst));
-    vmls_inst *inst_cream = (vmls_inst *)inst_base->component;
+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));
+    vmls_inst* inst_cream = (vmls_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vnmla_inst));
-    vnmla_inst *inst_cream = (vnmla_inst *)inst_base->component;
+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));
+    vnmla_inst* inst_cream = (vnmla_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vnmls_inst));
-    vnmls_inst *inst_cream = (vnmls_inst *)inst_base->component;
+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));
+    vnmls_inst* inst_cream = (vnmls_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vnmul_inst));
-    vnmul_inst *inst_cream = (vnmul_inst *)inst_base->component;
+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));
+    vnmul_inst* inst_cream = (vnmul_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmul_inst));
-    vmul_inst *inst_cream = (vmul_inst *)inst_base->component;
+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));
+    vmul_inst* inst_cream = (vmul_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vadd_inst));
-    vadd_inst *inst_cream = (vadd_inst *)inst_base->component;
+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));
+    vadd_inst* inst_cream = (vadd_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vsub_inst));
-    vsub_inst *inst_cream = (vsub_inst *)inst_base->component;
+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));
+    vsub_inst* inst_cream = (vsub_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vdiv_inst));
-    vdiv_inst *inst_cream = (vdiv_inst *)inst_base->component;
+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));
+    vdiv_inst* inst_cream = (vdiv_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmovi_inst));
-    vmovi_inst *inst_cream = (vmovi_inst *)inst_base->component;
+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));
+    vmovi_inst* inst_cream = (vmovi_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmovr_inst));
-    vmovr_inst *inst_cream = (vmovr_inst *)inst_base->component;
+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));
+    vmovr_inst* inst_cream = (vmovr_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->m      = (inst_cream->single ? BITS(inst, 0, 3)<<1 | BIT(inst, 5) : BITS(inst, 0, 3) | BIT(inst, 5)<<4);
+    inst_cream->d = (inst_cream->single ? BITS(inst, 12, 15) << 1 | BIT(inst, 22)
+                                        : 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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vabs_inst));
-    vabs_inst *inst_cream = (vabs_inst *)inst_base->component;
+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));
+    vabs_inst* inst_cream = (vabs_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vneg_inst));
-    vneg_inst *inst_cream = (vneg_inst *)inst_base->component;
+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));
+    vneg_inst* inst_cream = (vneg_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vsqrt_inst));
-    vsqrt_inst *inst_cream = (vsqrt_inst *)inst_base->component;
+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));
+    vsqrt_inst* inst_cream = (vsqrt_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vcmp_inst));
-    vcmp_inst *inst_cream = (vcmp_inst *)inst_base->component;
+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));
+    vcmp_inst* inst_cream = (vcmp_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vcmp2_inst));
-    vcmp2_inst *inst_cream = (vcmp2_inst *)inst_base->component;
+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));
+    vcmp2_inst* inst_cream = (vcmp2_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vcvtbds_inst));
-    vcvtbds_inst *inst_cream = (vcvtbds_inst *)inst_base->component;
+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));
+    vcvtbds_inst* inst_cream = (vcvtbds_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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));
-    vcvtbff_inst *inst_cream = (vcvtbff_inst *)inst_base->component;
+    arm_inst* inst_base = (arm_inst*)AllocBuffer(sizeof(arm_inst) + sizeof(vcvtbff_inst));
+    vcvtbff_inst* inst_cream = (vcvtbff_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vcvtbfi_inst));
-    vcvtbfi_inst *inst_cream = (vcvtbfi_inst *)inst_base->component;
+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));
+    vcvtbfi_inst* inst_cream = (vcvtbfi_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmovbrs_inst));
-    vmovbrs_inst *inst_cream = (vmovbrs_inst *)inst_base->component;
+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));
+    vmovbrs_inst* inst_cream = (vmovbrs_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     inst_cream->to_arm = BIT(inst, 20) == 1;
-    inst_cream->t      = BITS(inst, 12, 15);
-    inst_cream->n      = BIT(inst, 7) | BITS(inst, 16, 19)<<1;
+    inst_cream->t = BITS(inst, 12, 15);
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmsr_inst));
-    vmsr_inst *inst_cream = (vmsr_inst *)inst_base->component;
+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));
+    vmsr_inst* inst_cream = (vmsr_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmovbrc_inst));
-    vmovbrc_inst *inst_cream = (vmovbrc_inst *)inst_base->component;
+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));
+    vmovbrc_inst* inst_cream = (vmovbrc_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->d     = BITS(inst, 16, 19)|BIT(inst, 7)<<4;
-    inst_cream->t     = BITS(inst, 12, 15);
+    inst_cream->d = BITS(inst, 16, 19) | BIT(inst, 7) << 4;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmrs_inst));
-    vmrs_inst *inst_cream = (vmrs_inst *)inst_base->component;
+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));
+    vmrs_inst* inst_cream = (vmrs_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmovbcr_inst));
-    vmovbcr_inst *inst_cream = (vmovbcr_inst *)inst_base->component;
+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));
+    vmovbcr_inst* inst_cream = (vmovbcr_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
-    inst_cream->d     = BITS(inst, 16, 19)|BIT(inst, 7)<<4;
-    inst_cream->t     = BITS(inst, 12, 15);
+    inst_cream->d = BITS(inst, 16, 19) | BIT(inst, 7) << 4;
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmovbrrss_inst));
-    vmovbrrss_inst *inst_cream = (vmovbrrss_inst *)inst_base->component;
+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));
+    vmovbrrss_inst* inst_cream = (vmovbrrss_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     inst_cream->to_arm = BIT(inst, 20) == 1;
-    inst_cream->t      = BITS(inst, 12, 15);
-    inst_cream->t2     = BITS(inst, 16, 19);
-    inst_cream->m      = BITS(inst, 0, 3)<<1|BIT(inst, 5);
+    inst_cream->t = BITS(inst, 12, 15);
+    inst_cream->t2 = BITS(inst, 16, 19);
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vmovbrrd_inst));
-    vmovbrrd_inst *inst_cream = (vmovbrrd_inst *)inst_base->component;
+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));
+    vmovbrrd_inst* inst_cream = (vmovbrrd_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     inst_cream->to_arm = BIT(inst, 20) == 1;
-    inst_cream->t      = BITS(inst, 12, 15);
-    inst_cream->t2     = BITS(inst, 16, 19);
-    inst_cream->m      = BIT(inst, 5)<<4 | BITS(inst, 0, 3);
+    inst_cream->t = BITS(inst, 12, 15);
+    inst_cream->t2 = BITS(inst, 16, 19);
+    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vstr_inst));
-    vstr_inst *inst_cream = (vstr_inst *)inst_base->component;
+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));
+    vstr_inst* inst_cream = (vstr_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     inst_cream->single = BIT(inst, 8) == 0;
-    inst_cream->add    = BIT(inst, 23);
-    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->n      = BITS(inst, 16, 19);
+    inst_cream->add = BIT(inst, 23);
+    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->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
-        {
-            const u32 word1 = cpu->ExtReg[inst_cream->d*2+0];
-            const u32 word2 = cpu->ExtReg[inst_cream->d*2+1];
+        } else {
+            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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vpush_inst));
-    vpush_inst *inst_cream = (vpush_inst *)inst_base->component;
+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));
+    vpush_inst* inst_cream = (vpush_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->imm32   = BITS(inst, 0, 7)<<2;
-    inst_cream->regs    = (inst_cream->single ? BITS(inst, 0, 7) : BITS(inst, 1, 7));
+    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->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++)
-        {
-            if (inst_cream->single)
-            {
-                cpu->WriteMemory32(addr, cpu->ExtReg[inst_cream->d+i]);
+        for (unsigned int i = 0; i < inst_cream->regs; i++) {
+            if (inst_cream->single) {
+                cpu->WriteMemory32(addr, cpu->ExtReg[inst_cream->d + i]);
                 addr += 4;
-            }
-            else
-            {
-                const u32 word1 = cpu->ExtReg[(inst_cream->d+i)*2+0];
-                const u32 word2 = cpu->ExtReg[(inst_cream->d+i)*2+1];
+            } else {
+                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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vstm_inst));
-    vstm_inst *inst_cream = (vstm_inst *)inst_base->component;
+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));
+    vstm_inst* inst_cream = (vstm_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     inst_cream->single = BIT(inst, 8) == 0;
-    inst_cream->add    = BIT(inst, 23);
-    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->n      = BITS(inst, 16, 19);
-    inst_cream->imm32  = BITS(inst, 0, 7)<<2;
-    inst_cream->regs   = (inst_cream->single ? BITS(inst, 0, 7) : BITS(inst, 1, 7));
+    inst_cream->add = BIT(inst, 23);
+    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->n = BITS(inst, 16, 19);
+    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++)
-        {
-            if (inst_cream->single)
-            {
-                cpu->WriteMemory32(address, cpu->ExtReg[inst_cream->d+i]);
+        for (unsigned int i = 0; i < inst_cream->regs; i++) {
+            if (inst_cream->single) {
+                cpu->WriteMemory32(address, cpu->ExtReg[inst_cream->d + i]);
                 address += 4;
-            }
-            else
-            {
-                const u32 word1 = cpu->ExtReg[(inst_cream->d+i)*2+0];
-                const u32 word2 = cpu->ExtReg[(inst_cream->d+i)*2+1];
+            } else {
+                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] - inst_cream->imm32);
+            cpu->Reg[inst_cream->n] =
+                (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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vpop_inst));
-    vpop_inst *inst_cream = (vpop_inst *)inst_base->component;
+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));
+    vpop_inst* inst_cream = (vpop_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    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->imm32   = BITS(inst, 0, 7)<<2;
-    inst_cream->regs    = (inst_cream->single ? BITS(inst, 0, 7) : BITS(inst, 1, 7));
+    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->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++)
-        {
-            if (inst_cream->single)
-            {
-                cpu->ExtReg[inst_cream->d+i] = cpu->ReadMemory32(addr);
+        for (unsigned int i = 0; i < inst_cream->regs; i++) {
+            if (inst_cream->single) {
+                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+1] = word1;
+                    cpu->ExtReg[(inst_cream->d + i) * 2 + 0] = word2;
+                    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+1] = word2;
+                    cpu->ExtReg[(inst_cream->d + i) * 2 + 0] = word1;
+                    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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vldr_inst));
-    vldr_inst *inst_cream = (vldr_inst *)inst_base->component;
+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));
+    vldr_inst* inst_cream = (vldr_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     inst_cream->single = BIT(inst, 8) == 0;
-    inst_cream->add    = BIT(inst, 23);
-    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->n      = BITS(inst, 16, 19);
+    inst_cream->add = BIT(inst, 23);
+    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->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+1] = word1;
+                cpu->ExtReg[inst_cream->d * 2 + 0] = word2;
+                cpu->ExtReg[inst_cream->d * 2 + 1] = word1;
             } else {
-                cpu->ExtReg[inst_cream->d*2+0] = word1;
-                cpu->ExtReg[inst_cream->d*2+1] = word2;
+                cpu->ExtReg[inst_cream->d * 2 + 0] = word1;
+                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)
-{
-    arm_inst *inst_base = (arm_inst *)AllocBuffer(sizeof(arm_inst) + sizeof(vldm_inst));
-    vldm_inst *inst_cream = (vldm_inst *)inst_base->component;
+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));
+    vldm_inst* inst_cream = (vldm_inst*)inst_base->component;
 
     inst_base->cond = BITS(inst, 28, 31);
-    inst_base->idx  = index;
-    inst_base->br   = TransExtData::NON_BRANCH;
+    inst_base->idx = index;
+    inst_base->br = TransExtData::NON_BRANCH;
 
     inst_cream->single = BIT(inst, 8) == 0;
-    inst_cream->add    = BIT(inst, 23);
-    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->n      = BITS(inst, 16, 19);
-    inst_cream->imm32  = BITS(inst, 0, 7)<<2;
-    inst_cream->regs   = (inst_cream->single ? BITS(inst, 0, 7) : BITS(inst, 1, 7));
+    inst_cream->add = BIT(inst, 23);
+    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->n = BITS(inst, 16, 19);
+    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++)
-        {
-            if (inst_cream->single)
-            {
-                cpu->ExtReg[inst_cream->d+i] = cpu->ReadMemory32(address);
+        for (unsigned int i = 0; i < inst_cream->regs; i++) {
+            if (inst_cream->single) {
+                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+1] = word1;
+                    cpu->ExtReg[(inst_cream->d + i) * 2 + 0] = word2;
+                    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+1] = word2;
+                    cpu->ExtReg[(inst_cream->d + i) * 2 + 0] = word1;
+                    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] - inst_cream->imm32);
+            cpu->Reg[inst_cream->n] =
+                (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..1590d89a4 100644
--- a/src/core/arm/skyeye_common/vfp/vfpsingle.cpp
+++ b/src/core/arm/skyeye_common/vfp/vfpsingle.cpp
@@ -53,29 +53,23 @@
 
 #include <algorithm>
 #include <cinttypes>
-
 #include "common/common_funcs.h"
 #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,
-    0,
-    VFP_SINGLE_SIGNIFICAND_QNAN,
+    255, 0, VFP_SINGLE_SIGNIFICAND_QNAN,
 };
 
-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, s->exponent, s->significand);
+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,
+              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 +82,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, const char *func)
-{
+u32 vfp_single_normaliseround(ARMul_State* state, int sd, struct vfp_single* vs, u32 fpscr,
+                              const char* func) {
     u32 significand, incr, rmode;
     int exponent, shift, underflow;
     u32 exceptions = 0;
@@ -199,7 +192,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 +210,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,
-                  sd, d, exceptions);
+        LOG_TRACE(Core_ARM11, "%s: d(s%d)=%08x exceptions=%08x", func, sd, d, exceptions);
         vfp_put_float(state, d, sd);
     }
 
@@ -229,11 +221,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
-vfp_propagate_nan(struct vfp_single *vsd, struct vfp_single *vsn,
-                  struct vfp_single *vsm, u32 fpscr)
-{
-    struct vfp_single *nan;
+static u32 vfp_propagate_nan(struct vfp_single* vsd, struct vfp_single* vsn, struct vfp_single* vsm,
+                             u32 fpscr) {
+    struct vfp_single* nan;
     int tn, tm = 0;
 
     tn = vfp_single_type(vsn);
@@ -270,40 +260,35 @@ 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[] = {
     0x0004, 0x0022, 0x005d, 0x00b1, 0x011d, 0x019f, 0x0236, 0x02e0,
-    0x039c, 0x0468, 0x0545, 0x0631, 0x072b, 0x0832, 0x0946, 0x0a67
+    0x039c, 0x0468, 0x0545, 0x0631, 0x072b, 0x0832, 0x0946, 0x0a67,
 };
 
 static const u16 sqrt_evenadjust[] = {
     0x0a2d, 0x08af, 0x075a, 0x0629, 0x051a, 0x0429, 0x0356, 0x029e,
-    0x0200, 0x0179, 0x0109, 0x00af, 0x0068, 0x0034, 0x0012, 0x0002
+    0x0200, 0x0179, 0x0109, 0x00af, 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_fabs,   0 },                 //0x00000001 - FEXT_FABS
-    { vfp_single_fneg,   0 },                 //0x00000002 - FEXT_FNEG
-    { vfp_single_fsqrt,  0 },                 //0x00000003 - FEXT_FSQRT
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { vfp_single_fcmp,   OP_SCALAR },         //0x00000008 - FEXT_FCMP
-    { vfp_single_fcmpe,  OP_SCALAR },         //0x00000009 - FEXT_FCMPE
-    { vfp_single_fcmpz,  OP_SCALAR },         //0x0000000A - FEXT_FCMPZ
-    { vfp_single_fcmpez, OP_SCALAR },         //0x0000000B - FEXT_FCMPEZ
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { vfp_single_fcvtd,  OP_SCALAR|OP_DD },   //0x0000000F - FEXT_FCVT
-    { vfp_single_fuito,  OP_SCALAR },         //0x00000010 - FEXT_FUITO
-    { vfp_single_fsito,  OP_SCALAR },         //0x00000011 - FEXT_FSITO
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { nullptr, 0 },
-    { vfp_single_ftoui,  OP_SCALAR },         //0x00000018 - FEXT_FTOUI
-    { vfp_single_ftouiz, OP_SCALAR },         //0x00000019 - FEXT_FTOUIZ
-    { vfp_single_ftosi,  OP_SCALAR },         //0x0000001A - FEXT_FTOSI
-    { vfp_single_ftosiz, OP_SCALAR },         //0x0000001B - FEXT_FTOSIZ
+    {vfp_single_fcpy, 0},  // 0x00000000 - FEXT_FCPY
+    {vfp_single_fabs, 0},  // 0x00000001 - FEXT_FABS
+    {vfp_single_fneg, 0},  // 0x00000002 - FEXT_FNEG
+    {vfp_single_fsqrt, 0}, // 0x00000003 - FEXT_FSQRT
+    {nullptr, 0},
+    {nullptr, 0},
+    {nullptr, 0},
+    {nullptr, 0},
+    {vfp_single_fcmp, OP_SCALAR},   // 0x00000008 - FEXT_FCMP
+    {vfp_single_fcmpe, OP_SCALAR},  // 0x00000009 - FEXT_FCMPE
+    {vfp_single_fcmpz, OP_SCALAR},  // 0x0000000A - FEXT_FCMPZ
+    {vfp_single_fcmpez, OP_SCALAR}, // 0x0000000B - FEXT_FCMPEZ
+    {nullptr, 0},
+    {nullptr, 0},
+    {nullptr, 0},
+    {vfp_single_fcvtd, OP_SCALAR | OP_DD}, // 0x0000000F - FEXT_FCVT
+    {vfp_single_fuito, OP_SCALAR},         // 0x00000010 - FEXT_FUITO
+    {vfp_single_fsito, OP_SCALAR},         // 0x00000011 - FEXT_FSITO
+    {nullptr, 0},
+    {nullptr, 0},
+    {nullptr, 0},
+    {nullptr, 0},
+    {nullptr, 0},
+    {nullptr, 0},
+    {vfp_single_ftoui, OP_SCALAR},  // 0x00000018 - FEXT_FTOUI
+    {vfp_single_ftouiz, OP_SCALAR}, // 0x00000019 - FEXT_FTOUIZ
+    {vfp_single_ftosi, OP_SCALAR},  // 0x0000001A - FEXT_FTOSI
+    {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
-vfp_single_add(struct vfp_single *vsd, struct vfp_single *vsn,
-               struct vfp_single *vsm, u32 fpscr)
-{
+static u32 vfp_single_add(struct vfp_single* vsd, struct vfp_single* vsn, struct vfp_single* vsm,
+                          u32 fpscr) {
     u32 exp_diff, m_sig;
 
-    if (vsn->significand & 0x80000000 ||
-            vsm->significand & 0x80000000) {
+    if (vsn->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) ==
-                        FPSCR_ROUND_MINUSINF ? 0x8000 : 0;
+            vsd->sign = (fpscr & FPSCR_RMODE_MASK) == 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
-vfp_single_multiply(struct vfp_single *vsd, struct vfp_single *vsn, struct vfp_single *vsm, u32 fpscr)
-{
+static u32 vfp_single_multiply(struct vfp_single* vsd, struct vfp_single* vsn,
+                               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_SUBTRACT    (1 << 1)
+#define NEG_MULTIPLY (1 << 0)
+#define NEG_SUBTRACT (1 << 1)
 
-static u32
-vfp_single_multiply_accumulate(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr, u32 negate, const char *func)
-{
+static u32 vfp_single_multiply_accumulate(ARMul_State* state, int sd, int sn, s32 m, u32 fpscr,
+                                          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_fmsc,  0 },
-        { vfp_single_fmul,  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 },
+    {vfp_single_fmac, 0},  {vfp_single_fmsc, 0},  {vfp_single_fmul, 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_IDX(x)     ((x) & 7)
+#define FREG_BANK(x) ((x)&0x18)
+#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,
-              (veclen >> FPSCR_LENGTH_BIT) + 1);
+    LOG_TRACE(Core_ARM11, "vecstride=%u veclen=%u", vecstride, (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)",
-                      vecitr >> FPSCR_LENGTH_BIT, type, dest, sn,
-                      sm, m);
+            LOG_TRACE(Core_ARM11, "itr%d (%c%u) = op[%u] (s%u=%08x)", vecitr >> FPSCR_LENGTH_BIT,
+                      type, dest, sn, 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,
-                      FOP_TO_IDX(op), sm, m);
+                      vecitr >> FPSCR_LENGTH_BIT, type, dest, sn, FOP_TO_IDX(op), sm, m);
 
         except = fop->fn(state, dest, sn, m, fpscr);
-        LOG_TRACE(Core_ARM11, "itr%d: exceptions=%08x",
-                  vecitr >> FPSCR_LENGTH_BIT, except);
+        LOG_TRACE(Core_ARM11, "itr%d: exceptions=%08x", vecitr >> FPSCR_LENGTH_BIT, except);
 
         exceptions |= except;
 
diff --git a/src/core/core.cpp b/src/core/core.cpp
index a3834adae..49ac8be6e 100644
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -3,9 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <memory>
-
 #include "common/logging/log.h"
-
 #include "core/arm/arm_interface.h"
 #include "core/arm/dynarmic/arm_dynarmic.h"
 #include "core/arm/dyncom/arm_dyncom.h"
@@ -27,8 +25,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.
-        // Otherwise get out of the loop function.
+        // 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()) {
                 GDBStub::SetCpuStepFlag(false);
@@ -62,7 +60,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..5220b55ea 100644
--- a/src/core/core_timing.cpp
+++ b/src/core/core_timing.cpp
@@ -6,11 +6,9 @@
 #include <cinttypes>
 #include <mutex>
 #include <vector>
-
 #include "common/chunk_file.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
-
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
 #include "core/core_timing.h"
@@ -21,14 +19,11 @@ int g_clock_rate_arm11 = 268123480;
 #define INITIAL_SLICE_LENGTH 20000
 #define MAX_SLICE_LENGTH 100000000
 
-namespace CoreTiming
-{
-struct EventType
-{
+namespace CoreTiming {
+struct EventType {
     EventType() {}
 
-    EventType(TimedCallback cb, const char* n)
-        : callback(cb), name(n) {}
+    EventType(TimedCallback cb, const char* n) : callback(cb), name(n) {}
 
     TimedCallback callback;
     const char* name;
@@ -36,8 +31,7 @@ struct EventType
 
 static std::vector<EventType> event_types;
 
-struct BaseEvent
-{
+struct BaseEvent {
     s64 time;
     u64 userdata;
     int type;
@@ -200,7 +194,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 +215,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 +309,7 @@ s64 UnscheduleThreadsafeEvent(int event_type, u64 userdata) {
         }
     }
 
-    if (!ts_first)
-    {
+    if (!ts_first) {
         ts_last = nullptr;
         return result;
     }
@@ -369,7 +360,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 +500,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 +523,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 +544,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..b72a1b500 100644
--- a/src/core/core_timing.h
+++ b/src/core/core_timing.h
@@ -4,7 +4,9 @@
 
 #pragma once
 
+#include <functional>
 #include <string>
+#include "common/common_types.h"
 
 // This is a system to schedule events into the emulated machine's future. Time is measured
 // in main CPU clock cycles.
@@ -19,10 +21,6 @@
 // inside callback:
 //   ScheduleEvent(periodInCycles - cycles_late, callback, "whatever")
 
-#include <functional>
-
-#include "common/common_types.h"
-
 extern int g_clock_rate_arm11;
 
 inline s64 msToCycles(int ms) {
@@ -61,12 +59,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 +78,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 +125,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..1fae0ede0 100644
--- a/src/core/file_sys/archive_backend.cpp
+++ b/src/core/file_sys/archive_backend.cpp
@@ -5,34 +5,28 @@
 #include <cstddef>
 #include <iomanip>
 #include <sstream>
-
 #include "common/logging/log.h"
 #include "common/string_util.h"
-
 #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 +44,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 +66,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 +83,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 +98,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 + 1] = (tmp_char & 0x00FF);
+            to_return[i * 2] = (tmp_char & 0xFF00) >> 8;
+            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..d69c3c785 100644
--- a/src/core/file_sys/archive_backend.h
+++ b/src/core/file_sys/archive_backend.h
@@ -8,14 +8,11 @@
 #include <string>
 #include <utility>
 #include <vector>
-
 #include "common/bit_field.h"
 #include "common/common_types.h"
 #include "common/swap.h"
-
 #include "core/hle/result.h"
 
-
 namespace FileSys {
 
 class FileBackend;
@@ -24,10 +21,10 @@ class DirectoryBackend;
 // Path string type
 enum LowPathType : u32 {
     Invalid = 0,
-    Empty   = 1,
-    Binary  = 2,
-    Char    = 3,
-    Wchar   = 4
+    Empty = 1,
+    Binary = 2,
+    Char = 3,
+    Wchar = 4,
 };
 
 union Mode {
@@ -44,7 +41,9 @@ public:
     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
@@ -63,18 +62,18 @@ private:
     std::u16string u16str;
 };
 
+/// Parameters of the archive, as specified in the Create or Format call.
 struct ArchiveFormatInfo {
-    u32_le total_size; ///< The pre-defined size of the archive, as specified in the Create or Format call
-    u32_le number_directories; ///< The pre-defined number of directories in the archive, as 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
+    u32_le total_size;         ///< The pre-defined size of the archive.
+    u32_le number_directories; ///< The pre-defined number of directories in the archive.
+    u32_le number_files;       ///< The pre-defined number of files in the archive.
+    u8 duplicate_data;         ///< Whether the archive should duplicate the data.
 };
 static_assert(std::is_pod<ArchiveFormatInfo>::value, "ArchiveFormatInfo is not POD");
 
 class ArchiveBackend : NonCopyable {
 public:
-    virtual ~ArchiveBackend() {
-    }
+    virtual ~ArchiveBackend() {}
 
     /**
      * Get a descriptive name for the archive (e.g. "RomFS", "SaveData", etc.)
@@ -87,7 +86,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
@@ -150,8 +150,7 @@ public:
 
 class ArchiveFactory : NonCopyable {
 public:
-    virtual ~ArchiveFactory() {
-    }
+    virtual ~ArchiveFactory() {}
 
     /**
      * Get a descriptive name for the archive (e.g. "RomFS", "SaveData", etc.)
diff --git a/src/core/file_sys/archive_extsavedata.cpp b/src/core/file_sys/archive_extsavedata.cpp
index 1d9eaefcb..e1d29efd3 100644
--- a/src/core/file_sys/archive_extsavedata.cpp
+++ b/src/core/file_sys/archive_extsavedata.cpp
@@ -5,12 +5,10 @@
 #include <algorithm>
 #include <memory>
 #include <vector>
-
 #include "common/common_types.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
-
 #include "core/file_sys/archive_extsavedata.h"
 #include "core/file_sys/disk_archive.h"
 #include "core/hle/service/fs/archive.h"
@@ -30,10 +28,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 +53,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)
-        : shared(shared), mount_point(GetExtDataContainerPath(mount_location, shared)) {
+ArchiveFactory_ExtSaveData::ArchiveFactory_ExtSaveData(const std::string& mount_location,
+                                                       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 +88,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 +116,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 +125,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..6a3431e94 100644
--- a/src/core/file_sys/archive_extsavedata.h
+++ b/src/core/file_sys/archive_extsavedata.h
@@ -6,9 +6,7 @@
 
 #include <memory>
 #include <string>
-
 #include "common/common_types.h"
-
 #include "core/file_sys/archive_backend.h"
 #include "core/hle/result.h"
 
@@ -28,13 +26,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 +47,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 +68,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..6c99ca5b4 100644
--- a/src/core/file_sys/archive_romfs.cpp
+++ b/src/core/file_sys/archive_romfs.cpp
@@ -4,10 +4,8 @@
 
 #include <algorithm>
 #include <memory>
-
 #include "common/common_types.h"
 #include "common/logging/log.h"
-
 #include "core/file_sys/archive_romfs.h"
 #include "core/file_sys/ivfc_archive.h"
 
@@ -28,11 +26,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,
-            ErrorSummary::NotSupported, ErrorLevel::Permanent);
+    return ResultCode(ErrorDescription::NotAuthorized, ErrorModule::FS, ErrorSummary::NotSupported,
+                      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..8a8082a05 100644
--- a/src/core/file_sys/archive_romfs.h
+++ b/src/core/file_sys/archive_romfs.h
@@ -7,9 +7,7 @@
 #include <memory>
 #include <string>
 #include <vector>
-
 #include "common/common_types.h"
-
 #include "core/file_sys/archive_backend.h"
 #include "core/hle/result.h"
 #include "core/loader/loader.h"
@@ -24,7 +22,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..6711035ec 100644
--- a/src/core/file_sys/archive_savedata.cpp
+++ b/src/core/file_sys/archive_savedata.cpp
@@ -4,12 +4,10 @@
 
 #include <algorithm>
 #include <memory>
-
 #include "common/common_types.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
-
 #include "core/file_sys/archive_savedata.h"
 #include "core/file_sys/disk_archive.h"
 #include "core/hle/kernel/process.h"
@@ -22,48 +20,54 @@ 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
-        // with the files and folders that it expects.
+        // 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 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) {
-    std::string concrete_mount_point = GetSaveDataPath(mount_point, Kernel::g_current_process->codeset->program_id);
+ResultCode ArchiveFactory_SaveData::Format(const Path& path,
+                                           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 +78,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..6a372865a 100644
--- a/src/core/file_sys/archive_savedata.h
+++ b/src/core/file_sys/archive_savedata.h
@@ -6,7 +6,6 @@
 
 #include <memory>
 #include <string>
-
 #include "core/file_sys/archive_backend.h"
 #include "core/hle/result.h"
 
@@ -20,7 +19,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..6c4542b7d 100644
--- a/src/core/file_sys/archive_savedatacheck.cpp
+++ b/src/core/file_sys/archive_savedatacheck.cpp
@@ -5,12 +5,10 @@
 #include <algorithm>
 #include <memory>
 #include <vector>
-
 #include "common/common_types.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
-
 #include "core/file_sys/archive_savedatacheck.h"
 #include "core/file_sys/ivfc_archive.h"
 #include "core/hle/service/fs/archive.h"
@@ -25,13 +23,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",
-            mount_point.c_str(), high, low);
+    return Common::StringFromFormat("%s%08x/%08x/content/00000000.app.romfs", mount_point.c_str(),
+                                    high, low);
 }
 
-ArchiveFactory_SaveDataCheck::ArchiveFactory_SaveDataCheck(const std::string& nand_directory) :
-        mount_point(GetSaveDataCheckContainerPath(nand_directory)) {
-}
+ArchiveFactory_SaveDataCheck::ArchiveFactory_SaveDataCheck(const std::string& nand_directory)
+    : mount_point(GetSaveDataCheckContainerPath(nand_directory)) {}
 
 ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_SaveDataCheck::Open(const Path& path) {
     auto vec = path.AsBinary();
@@ -48,11 +45,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,
-        ErrorSummary::NotSupported, ErrorLevel::Permanent);
+    return ResultCode(ErrorDescription::NotAuthorized, ErrorModule::FS, ErrorSummary::NotSupported,
+                      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..e9cafbed9 100644
--- a/src/core/file_sys/archive_savedatacheck.h
+++ b/src/core/file_sys/archive_savedatacheck.h
@@ -6,7 +6,6 @@
 
 #include <memory>
 #include <string>
-
 #include "core/file_sys/archive_backend.h"
 #include "core/hle/result.h"
 
@@ -20,7 +19,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..bcb03ed36 100644
--- a/src/core/file_sys/archive_sdmc.cpp
+++ b/src/core/file_sys/archive_sdmc.cpp
@@ -4,10 +4,8 @@
 
 #include <algorithm>
 #include <memory>
-
 #include "common/file_util.h"
 #include "common/logging/log.h"
-
 #include "core/file_sys/archive_sdmc.h"
 #include "core/file_sys/disk_archive.h"
 #include "core/settings.h"
@@ -17,7 +15,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 +39,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..88e855351 100644
--- a/src/core/file_sys/archive_sdmc.h
+++ b/src/core/file_sys/archive_sdmc.h
@@ -6,7 +6,6 @@
 
 #include <memory>
 #include <string>
-
 #include "core/file_sys/archive_backend.h"
 #include "core/hle/result.h"
 
@@ -26,7 +25,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..48ebc0ed4 100644
--- a/src/core/file_sys/archive_systemsavedata.cpp
+++ b/src/core/file_sys/archive_systemsavedata.cpp
@@ -5,11 +5,9 @@
 #include <algorithm>
 #include <memory>
 #include <vector>
-
 #include "common/common_types.h"
 #include "common/file_util.h"
 #include "common/string_util.h"
-
 #include "core/file_sys/archive_systemsavedata.h"
 #include "core/file_sys/disk_archive.h"
 #include "core/hle/service/fs/archive.h"
@@ -45,25 +43,25 @@ 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) {
     std::string fullpath = GetSystemSaveDataPath(base_path, path);
     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..a24b89f2b 100644
--- a/src/core/file_sys/archive_systemsavedata.h
+++ b/src/core/file_sys/archive_systemsavedata.h
@@ -6,9 +6,7 @@
 
 #include <memory>
 #include <string>
-
 #include "common/common_types.h"
-
 #include "core/file_sys/archive_backend.h"
 #include "core/hle/result.h"
 
@@ -26,7 +24,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 +42,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..b55e382ef 100644
--- a/src/core/file_sys/directory_backend.h
+++ b/src/core/file_sys/directory_backend.h
@@ -6,7 +6,6 @@
 
 #include <array>
 #include <cstddef>
-
 #include "common/common_types.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -19,15 +18,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)
-    std::array<char, 4> extension; // 8.3 file extension (set to spaces for directories, null-terminated)
-    char unknown2; // unknown (always 0x01)
-    char unknown3; // unknown (0x00 or 0x08)
+    char unknown1;                  // unknown (observed values: 0x0A, 0x70, 0xFD)
+    std::array<char, 4>
+        extension;     // 8.3 file extension (set to spaces for directories, null-terminated)
+    char unknown2;     // unknown (always 0x01)
+    char unknown3;     // unknown (0x00 or 0x08)
     char is_directory; // directory flag
-    char is_hidden; // hidden flag
-    char is_archive; // archive flag
+    char is_hidden;    // hidden 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 +37,8 @@ static_assert(offsetof(Entry, file_size) == 0x220, "Wrong offset for file_size i
 
 class DirectoryBackend : NonCopyable {
 public:
-    DirectoryBackend() { }
-    virtual ~DirectoryBackend() { }
+    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..0f66998e1 100644
--- a/src/core/file_sys/disk_archive.cpp
+++ b/src/core/file_sys/disk_archive.cpp
@@ -5,11 +5,9 @@
 #include <algorithm>
 #include <cstdio>
 #include <memory>
-
 #include "common/common_types.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
-
 #include "core/file_sys/disk_archive.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -17,7 +15,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 +29,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 +55,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 +73,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 +110,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());
-            return ResultCode(ErrorDescription::FS_NotFound, ErrorModule::FS, ErrorSummary::NotFound, ErrorLevel::Status);
+            LOG_ERROR(Service_FS, "Non-existing file %s can't be open without mode create.",
+                      path.c_str());
+            return ResultCode(ErrorDescription::FS_NotFound, ErrorModule::FS,
+                              ErrorSummary::NotFound, ErrorLevel::Status);
         } else {
             // Create the file
             FileUtil::CreateEmptyFile(path);
@@ -135,20 +143,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 +210,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..2165f27f9 100644
--- a/src/core/file_sys/disk_archive.h
+++ b/src/core/file_sys/disk_archive.h
@@ -8,10 +8,8 @@
 #include <memory>
 #include <string>
 #include <vector>
-
 #include "common/common_types.h"
 #include "common/file_util.h"
-
 #include "core/file_sys/archive_backend.h"
 #include "core/file_sys/directory_backend.h"
 #include "core/file_sys/file_backend.h"
@@ -31,9 +29,12 @@ class DiskArchive : public ArchiveBackend {
 public:
     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..ed997537f 100644
--- a/src/core/file_sys/file_backend.h
+++ b/src/core/file_sys/file_backend.h
@@ -5,7 +5,6 @@
 #pragma once
 
 #include <cstddef>
-
 #include "common/common_types.h"
 #include "core/hle/result.h"
 
@@ -16,8 +15,8 @@ namespace FileSys {
 
 class FileBackend : NonCopyable {
 public:
-    FileBackend() { }
-    virtual ~FileBackend() { }
+    FileBackend() {}
+    virtual ~FileBackend() {}
 
     /**
      * Open the file
@@ -42,7 +41,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..49cc1de10 100644
--- a/src/core/file_sys/ivfc_archive.cpp
+++ b/src/core/file_sys/ivfc_archive.cpp
@@ -4,10 +4,8 @@
 
 #include <cstring>
 #include <memory>
-
 #include "common/common_types.h"
 #include "common/logging/log.h"
-
 #include "core/file_sys/ivfc_archive.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -19,40 +17,49 @@ std::string IVFCArchive::GetName() const {
     return "IVFC";
 }
 
-ResultVal<std::unique_ptr<FileBackend>> IVFCArchive::OpenFile(const Path& path, const Mode mode) const {
-    return MakeResult<std::unique_ptr<FileBackend>>(std::make_unique<IVFCFile>(romfs_file, data_offset, data_size));
+ResultVal<std::unique_ptr<FileBackend>> IVFCArchive::OpenFile(const Path& path,
+                                                              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,
-                      ErrorSummary::Canceled, ErrorLevel::Status);
+    return ResultCode(ErrorDescription::NoData, ErrorModule::FS, ErrorSummary::Canceled,
+                      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 +82,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..0df6cf83a 100644
--- a/src/core/file_sys/ivfc_archive.h
+++ b/src/core/file_sys/ivfc_archive.h
@@ -8,10 +8,8 @@
 #include <memory>
 #include <string>
 #include <vector>
-
 #include "common/common_types.h"
 #include "common/file_util.h"
-
 #include "core/file_sys/archive_backend.h"
 #include "core/file_sys/directory_backend.h"
 #include "core/file_sys/file_backend.h"
@@ -34,7 +32,8 @@ public:
 
     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;
@@ -55,13 +54,17 @@ public:
     IVFCFile(std::shared_ptr<FileUtil::IOFile> file, u64 offset, u64 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; }
-    void Flush() const override { }
+    bool Close() const override {
+        return false;
+    }
+    void Flush() const override {}
 
 private:
     std::shared_ptr<FileUtil::IOFile> romfs_file;
@@ -71,9 +74,15 @@ private:
 
 class IVFCDirectory : public DirectoryBackend {
 public:
-    bool Open() override { return false; }
-    u32 Read(const u32 count, Entry* entries) override { return 0; }
-    bool Close() const override { return false; }
+    bool Open() 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..7fc72d801 100644
--- a/src/core/gdbstub/gdbstub.cpp
+++ b/src/core/gdbstub/gdbstub.cpp
@@ -10,31 +10,31 @@
 #include <cstdarg>
 #include <cstdio>
 #include <cstring>
-#include <fcntl.h>
 #include <map>
 #include <numeric>
+#include <fcntl.h>
 
 #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 ||
-        memcmp(command_buffer, "Hc-1", 4) == 0 ||
-        memcmp(command_buffer, "Hc0", 4) == 0 ||
-        memcmp(command_buffer, "Hc1", 4) == 0) {
+    if (memcmp(command_buffer, "Hg0", 3) == 0 || memcmp(command_buffer, "Hc-1", 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",
-            checksum_calculated, checksum_received, command_buffer, command_length);
+        LOG_ERROR(Debug_GDBStub,
+                  "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 addr_pos = std::find(start_offset, command_buffer+command_length, ',');
+    auto start_offset = command_buffer + 1;
+    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;
-    u32 len = HexToInt(start_offset, static_cast<u32>((command_buffer + command_length) - start_offset));
+    start_offset = addr_pos + 1;
+    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 addr_pos = std::find(start_offset, command_buffer+command_length, ',');
+    auto start_offset = command_buffer + 1;
+    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;
-    auto len_pos = std::find(start_offset, command_buffer+command_length, ':');
+    start_offset = addr_pos + 1;
+    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 addr_pos = std::find(start_offset, command_buffer+command_length, ',');
+    auto start_offset = command_buffer + 3;
+    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;
-    u32 len = HexToInt(start_offset, static_cast<u32>((command_buffer + command_length) - start_offset));
+    start_offset = addr_pos + 1;
+    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 addr_pos = std::find(start_offset, command_buffer+command_length, ',');
+    auto start_offset = command_buffer + 3;
+    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;
-    u32 len = HexToInt(start_offset, static_cast<u32>((command_buffer + command_length) - start_offset));
+    start_offset = addr_pos + 1;
+    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..a7483bb10 100644
--- a/src/core/gdbstub/gdbstub.h
+++ b/src/core/gdbstub/gdbstub.h
@@ -6,18 +6,17 @@
 
 #pragma once
 #include <atomic>
-
 #include "common/common_types.h"
 
 namespace GDBStub {
 
 /// Breakpoint Method
 enum class BreakpointType {
-    None,     ///< None
-    Execute,  ///< Execution Breakpoint
-    Read,     ///< Read Breakpoint
-    Write,    ///< Write Breakpoint
-    Access    ///< Access (R/W) Breakpoint
+    None,    ///< None
+    Execute, ///< Execution Breakpoint
+    Read,    ///< Read Breakpoint
+    Write,   ///< Write Breakpoint
+    Access   ///< Access (R/W) Breakpoint
 };
 
 struct BreakpointAddress {
@@ -25,7 +24,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 +92,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..4311d9897 100644
--- a/src/core/hle/applets/applet.cpp
+++ b/src/core/hle/applets/applet.cpp
@@ -6,10 +6,8 @@
 #include <memory>
 #include <type_traits>
 #include <unordered_map>
-
 #include "common/assert.h"
 #include "common/common_types.h"
-
 #include "core/core_timing.h"
 #include "core/hle/applets/applet.h"
 #include "core/hle/applets/erreula.h"
@@ -23,23 +21,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 <>
-    struct hash<Service::APT::AppletId> {
-        typedef Service::APT::AppletId argument_type;
-        typedef std::size_t result_type;
-
-        result_type operator()(const argument_type& id_code) const {
-            typedef std::underlying_type<argument_type>::type Type;
-            return std::hash<Type>()(static_cast<Type>(id_code));
-        }
-    };
+template <>
+struct hash<Service::APT::AppletId> {
+    typedef Service::APT::AppletId argument_type;
+    typedef std::size_t result_type;
+
+    result_type operator()(const argument_type& id_code) const {
+        typedef std::underlying_type<argument_type>::type Type;
+        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 +59,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 +84,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 +96,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 +117,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..bfdcad126 100644
--- a/src/core/hle/applets/applet.h
+++ b/src/core/hle/applets/applet.h
@@ -5,7 +5,6 @@
 #pragma once
 
 #include <memory>
-
 #include "core/hle/result.h"
 #include "core/hle/service/apt/apt.h"
 
@@ -14,8 +13,8 @@ namespace Applets {
 
 class Applet {
 public:
-    virtual ~Applet() { }
-    Applet(Service::APT::AppletId id) : id(id) { }
+    virtual ~Applet() {}
+    Applet(Service::APT::AppletId id) : id(id) {}
 
     /**
      * Creates an instance of the Applet subclass identified by the parameter.
@@ -64,7 +63,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 +75,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..14964427b 100644
--- a/src/core/hle/applets/erreula.cpp
+++ b/src/core/hle/applets/erreula.cpp
@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include "common/string_util.h"
-
 #include "core/hle/applets/erreula.h"
 #include "core/hle/service/apt/apt.h"
 
@@ -18,7 +17,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 +30,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(),
-                                                               MemoryPermission::ReadWrite, MemoryPermission::ReadWrite,
-                                                               "ErrEula Memory");
+    framebuffer_memory = Kernel::SharedMemory::CreateForApplet(
+        heap_memory, 0, heap_memory->size(), MemoryPermission::ReadWrite,
+        MemoryPermission::ReadWrite, "ErrEula Memory");
 
     // Send the response message with the newly created SharedMemory
     Service::APT::MessageParameter result;
@@ -49,7 +49,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
@@ -65,8 +66,7 @@ ResultCode ErrEula::StartImpl(const Service::APT::AppletStartupParameter& parame
     return RESULT_SUCCESS;
 }
 
-void ErrEula::Update() {
-}
+void ErrEula::Update() {}
 
 } // namespace Applets
 } // namespace HLE
diff --git a/src/core/hle/applets/erreula.h b/src/core/hle/applets/erreula.h
index 9fe72ae07..a7ec7ec01 100644
--- a/src/core/hle/applets/erreula.h
+++ b/src/core/hle/applets/erreula.h
@@ -12,16 +12,20 @@ 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..53a8683a4 100644
--- a/src/core/hle/applets/mii_selector.cpp
+++ b/src/core/hle/applets/mii_selector.cpp
@@ -4,16 +4,13 @@
 
 #include <cstring>
 #include <string>
-
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
-
 #include "core/hle/applets/mii_selector.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/shared_memory.h"
 #include "core/hle/result.h"
-
 #include "video_core/video_core.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -29,7 +26,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 +38,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(),
-                                                               MemoryPermission::ReadWrite, MemoryPermission::ReadWrite,
-                                                               "MiiSelector Memory");
+    framebuffer_memory = Kernel::SharedMemory::CreateForApplet(
+        heap_memory, 0, heap_memory->size(), MemoryPermission::ReadWrite,
+        MemoryPermission::ReadWrite, "MiiSelector Memory");
 
     // Send the response message with the newly created SharedMemory
     Service::APT::MessageParameter result;
@@ -59,12 +57,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;
@@ -82,8 +82,6 @@ ResultCode MiiSelector::StartImpl(const Service::APT::AppletStartupParameter& pa
     return RESULT_SUCCESS;
 }
 
-void MiiSelector::Update() {
-}
-
+void MiiSelector::Update() {}
 }
 } // namespace
diff --git a/src/core/hle/applets/mii_selector.h b/src/core/hle/applets/mii_selector.h
index 24e8e721d..e3ab9f0cd 100644
--- a/src/core/hle/applets/mii_selector.h
+++ b/src/core/hle/applets/mii_selector.h
@@ -4,9 +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"
 #include "core/hle/kernel/shared_memory.h"
@@ -17,28 +16,30 @@ namespace HLE {
 namespace Applets {
 
 struct MiiConfig {
-    u8  unk_000;
-    u8  unk_001;
-    u8  unk_002;
-    u8  unk_003;
-    u8  unk_004;
+    u8 unk_000;
+    u8 unk_001;
+    u8 unk_002;
+    u8 unk_003;
+    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_0FE;
-    u8  unk_0FF;
+    u8 unk_09A[0x64];
+    u8 unk_0FE;
+    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 +56,27 @@ 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 +84,5 @@ public:
 
     MiiConfig config;
 };
-
 }
 } // namespace
diff --git a/src/core/hle/applets/swkbd.cpp b/src/core/hle/applets/swkbd.cpp
index d87bf3d57..06ddf538b 100644
--- a/src/core/hle/applets/swkbd.cpp
+++ b/src/core/hle/applets/swkbd.cpp
@@ -4,19 +4,16 @@
 
 #include <cstring>
 #include <string>
-
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
-
 #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 +29,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 +41,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(),
-                                                               MemoryPermission::ReadWrite, MemoryPermission::ReadWrite,
-                                                               "SoftwareKeyboard Memory");
+    framebuffer_memory = Kernel::SharedMemory::CreateForApplet(
+        heap_memory, 0, heap_memory->size(), MemoryPermission::ReadWrite,
+        MemoryPermission::ReadWrite, "SoftwareKeyboard Memory");
 
     // Send the response message with the newly created SharedMemory
     Service::APT::MessageParameter result;
@@ -60,10 +58,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 +115,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..ea0b1fba9 100644
--- a/src/core/hle/applets/swkbd.h
+++ b/src/core/hle/applets/swkbd.h
@@ -4,9 +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"
 #include "core/hle/kernel/shared_memory.h"
@@ -53,12 +52,14 @@ 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 +73,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 +86,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.h b/src/core/hle/config_mem.h
index 24a1254f2..42fa6d789 100644
--- a/src/core/hle/config_mem.h
+++ b/src/core/hle/config_mem.h
@@ -12,7 +12,6 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
-
 #include "core/memory.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -20,16 +19,16 @@
 namespace ConfigMem {
 
 struct ConfigMemDef {
-    u8     kernel_unk;                   // 0
-    u8     kernel_version_rev;           // 1
-    u8     kernel_version_min;           // 2
-    u8     kernel_version_maj;           // 3
+    u8 kernel_unk;                       // 0
+    u8 kernel_version_rev;               // 1
+    u8 kernel_version_min;               // 2
+    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     boot_firm;                    // 15
-    u8     prev_firm;                    // 16
+    u8 unit_info;                        // 14
+    u8 boot_firm;                        // 15
+    u8 prev_firm;                        // 16
     INSERT_PADDING_BYTES(0x1);           // 17
     u32_le ctr_sdk_ver;                  // 18
     INSERT_PADDING_BYTES(0x30 - 0x1C);   // 1C
@@ -39,15 +38,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_version_rev;             // 61
-    u8     firm_version_min;             // 62
-    u8     firm_version_maj;             // 63
+    u8 firm_unk;                         // 60
+    u8 firm_version_rev;                 // 61
+    u8 firm_version_min;                 // 62
+    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..8ce0f6d2b 100644
--- a/src/core/hle/function_wrappers.h
+++ b/src/core/hle/function_wrappers.h
@@ -5,16 +5,16 @@
 #pragma once
 
 #include "common/common_types.h"
-
 #include "core/arm/arm_interface.h"
-#include "core/memory.h"
+#include "core/core.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() {
-    FuncReturn(func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), (((s64)PARAM(5) << 32) | PARAM(4))).raw);
+template <ResultCode func(u32, u32, u32, u32, s64)>
+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(){
-    FuncReturn(func((s64*)Memory::GetPointer(PARAM(0)), PARAM(1), (u32*)Memory::GetPointer(PARAM(2)),
-        (s32)PARAM(3)).raw);
+template <ResultCode func(s64*, u32, u32*, u32)>
+void Wrap() {
+    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..41b772163 100644
--- a/src/core/hle/hle.cpp
+++ b/src/core/hle/hle.cpp
@@ -4,7 +4,6 @@
 
 #include "common/assert.h"
 #include "common/logging/log.h"
-
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
 #include "core/hle/hle.h"
@@ -15,13 +14,13 @@
 namespace {
 
 bool reschedule; ///< If true, immediately reschedules the CPU to a new thread
-
 }
 
 namespace HLE {
 
-void Reschedule(const char *reason) {
-    DEBUG_ASSERT_MSG(reason != nullptr && strlen(reason) < 256, "Reschedule: Invalid or too long reason.");
+void Reschedule(const char* 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..37eec4c84 100644
--- a/src/core/hle/kernel/address_arbiter.cpp
+++ b/src/core/hle/kernel/address_arbiter.cpp
@@ -4,12 +4,10 @@
 
 #include "common/common_types.h"
 #include "common/logging/log.h"
-
-#include "core/memory.h"
-
 #include "core/hle/hle.h"
 #include "core/hle/kernel/address_arbiter.h"
 #include "core/hle/kernel/thread.h"
+#include "core/memory.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Kernel namespace
@@ -28,7 +26,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 +36,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 +53,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 +62,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 +75,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,
-                          ErrorSummary::StatusChanged, ErrorLevel::Info);
+        return ResultCode(ErrorDescription::Timeout, ErrorModule::OS, ErrorSummary::StatusChanged,
+                          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..6a7af93a9 100644
--- a/src/core/hle/kernel/address_arbiter.h
+++ b/src/core/hle/kernel/address_arbiter.h
@@ -5,7 +5,6 @@
 #pragma once
 
 #include "common/common_types.h"
-
 #include "core/hle/kernel/kernel.h"
 
 // Address arbiters are an underlying kernel synchronization object that can be created/used via
@@ -36,13 +35,19 @@ public:
      */
     static SharedPtr<AddressArbiter> Create(std::string name = "Unknown");
 
-    std::string GetTypeName() const override { return "Arbiter"; }
-    std::string GetName() const override { return name; }
+    std::string GetTypeName() const override {
+        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..aedc6f989 100644
--- a/src/core/hle/kernel/client_port.cpp
+++ b/src/core/hle/kernel/client_port.cpp
@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include "common/assert.h"
-
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/server_port.h"
diff --git a/src/core/hle/kernel/client_port.h b/src/core/hle/kernel/client_port.h
index 480b6ddae..d28147718 100644
--- a/src/core/hle/kernel/client_port.h
+++ b/src/core/hle/kernel/client_port.h
@@ -5,9 +5,7 @@
 #pragma once
 
 #include <string>
-
 #include "common/common_types.h"
-
 #include "core/hle/kernel/kernel.h"
 
 namespace Kernel {
@@ -17,16 +15,22 @@ class ServerPort;
 class ClientPort : public Object {
 public:
     friend class ServerPort;
-    std::string GetTypeName() const override { return "ClientPort"; }
-    std::string GetName() const override { return name; }
+    std::string GetTypeName() const override {
+        return "ClientPort";
+    }
+    std::string GetName() const override {
+        return name;
+    }
 
     static const HandleType HANDLE_TYPE = HandleType::ClientPort;
-    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
-    std::string name;                           ///< Name of client port (optional)
+    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
+    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..1489c7002 100644
--- a/src/core/hle/kernel/event.cpp
+++ b/src/core/hle/kernel/event.cpp
@@ -2,14 +2,12 @@
 // 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 {
diff --git a/src/core/hle/kernel/event.h b/src/core/hle/kernel/event.h
index 73d0da419..6fe74065d 100644
--- a/src/core/hle/kernel/event.h
+++ b/src/core/hle/kernel/event.h
@@ -5,7 +5,6 @@
 #pragma once
 
 #include "common/common_types.h"
-
 #include "core/hle/kernel/kernel.h"
 
 namespace Kernel {
@@ -16,7 +15,6 @@ enum class ResetType {
     Pulse,
 };
 
-
 class Event final : public WaitObject {
 public:
     /**
@@ -26,16 +24,22 @@ public:
      */
     static SharedPtr<Event> Create(ResetType reset_type, std::string name = "Unknown");
 
-    std::string GetTypeName() const override { return "Event"; }
-    std::string GetName() const override { return name; }
+    std::string GetTypeName() const override {
+        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
-    std::string name;                       ///< Name of event (optional)
+    bool signaled;    ///< Whether the event has already been signaled
+    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..9a2c8ce05 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -3,10 +3,8 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-
 #include "common/assert.h"
 #include "common/logging/log.h"
-
 #include "core/hle/config_mem.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/memory.h"
@@ -61,7 +59,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..0e95f7ff0 100644
--- a/src/core/hle/kernel/kernel.h
+++ b/src/core/hle/kernel/kernel.h
@@ -4,16 +4,13 @@
 
 #pragma once
 
-#include <boost/smart_ptr/intrusive_ptr.hpp>
-
 #include <algorithm>
 #include <array>
 #include <cstddef>
 #include <string>
 #include <vector>
-
+#include <boost/smart_ptr/intrusive_ptr.hpp>
 #include "common/common_types.h"
-
 #include "core/hle/hle.h"
 #include "core/hle/result.h"
 
@@ -23,37 +20,37 @@ 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,
-    CurrentProcess  = 0xFFFF8001,
+    CurrentThread = 0xFFFF8000,
+    CurrentProcess = 0xFFFF8001,
 };
 
 enum class HandleType : u32 {
-    Unknown         = 0,
-
-    Session         = 2,
-    Event           = 3,
-    Mutex           = 4,
-    SharedMemory    = 5,
-    Redirection     = 6,
-    Thread          = 7,
-    Process         = 8,
-    AddressArbiter  = 9,
-    Semaphore       = 10,
-    Timer           = 11,
-    ResourceLimit   = 12,
-    CodeSet         = 13,
-    ClientPort      = 14,
-    ServerPort      = 15,
+    Unknown = 0,
+
+    Session = 2,
+    Event = 3,
+    Mutex = 4,
+    SharedMemory = 5,
+    Redirection = 6,
+    Thread = 7,
+    Process = 8,
+    AddressArbiter = 9,
+    Semaphore = 10,
+    Timer = 11,
+    ResourceLimit = 12,
+    CodeSet = 13,
+    ClientPort = 14,
+    ServerPort = 15,
 };
 
 enum {
-    DEFAULT_STACK_SIZE  = 0x4000,
+    DEFAULT_STACK_SIZE = 0x4000,
 };
 
 class Object : NonCopyable {
@@ -61,10 +58,16 @@ public:
     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 GetName() const { return "[UNKNOWN KERNEL OBJECT]"; }
+    virtual std::string GetTypeName() const {
+        return "[BAD KERNEL OBJECT TYPE]";
+    }
+    virtual std::string GetName() const {
+        return "[UNKNOWN KERNEL OBJECT]";
+    }
     virtual Kernel::HandleType GetHandleType() const = 0;
 
     /**
@@ -122,7 +125,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 +249,12 @@ private:
      */
     static const size_t MAX_COUNT = 4096;
 
-    static u16 GetSlot(Handle handle)    { return handle >> 15; }
-    static u16 GetGeneration(Handle handle) { return handle & 0x7FFF; }
+    static u16 GetSlot(Handle handle) {
+        return handle >> 15;
+    }
+    static u16 GetGeneration(Handle handle) {
+        return handle & 0x7FFF;
+    }
 
     /// Stores the Object referenced by the handle or null if the slot is empty.
     std::array<SharedPtr<Object>, MAX_COUNT> objects;
diff --git a/src/core/hle/kernel/memory.cpp b/src/core/hle/kernel/memory.cpp
index 17ae87aef..e65fd5c41 100644
--- a/src/core/hle/kernel/memory.cpp
+++ b/src/core/hle/kernel/memory.cpp
@@ -6,12 +6,9 @@
 #include <memory>
 #include <utility>
 #include <vector>
-
 #include "audio_core/audio_core.h"
-
 #include "common/common_types.h"
 #include "common/logging/log.h"
-
 #include "core/hle/config_mem.h"
 #include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/vm_manager.h"
@@ -31,7 +28,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 +92,6 @@ MemoryRegionInfo* GetMemoryRegion(MemoryRegion region) {
         UNREACHABLE();
     }
 }
-
 }
 
 namespace Memory {
@@ -110,9 +106,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 +120,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,
-            (u8*)&ConfigMem::config_mem, CONFIG_MEMORY_SIZE, MemoryState::Shared).MoveFrom();
+    auto cfg_mem_vma = address_space
+                           .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,
-            (u8*)&SharedPage::shared_page, SHARED_PAGE_SIZE, MemoryState::Shared).MoveFrom();
+    auto shared_page_vma = address_space
+                               .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..4e1856a41 100644
--- a/src/core/hle/kernel/memory.h
+++ b/src/core/hle/kernel/memory.h
@@ -5,9 +5,7 @@
 #pragma once
 
 #include <memory>
-
 #include "common/common_types.h"
-
 #include "core/hle/kernel/process.h"
 
 namespace Kernel {
@@ -25,7 +23,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..736944bae 100644
--- a/src/core/hle/kernel/mutex.cpp
+++ b/src/core/hle/kernel/mutex.cpp
@@ -4,11 +4,8 @@
 
 #include <map>
 #include <vector>
-
 #include <boost/range/algorithm_ext/erase.hpp>
-
 #include "common/assert.h"
-
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/mutex.h"
 #include "core/hle/kernel/thread.h"
diff --git a/src/core/hle/kernel/mutex.h b/src/core/hle/kernel/mutex.h
index 1746360e4..53c3dc1f1 100644
--- a/src/core/hle/kernel/mutex.h
+++ b/src/core/hle/kernel/mutex.h
@@ -5,9 +5,7 @@
 #pragma once
 
 #include <string>
-
 #include "common/common_types.h"
-
 #include "core/hle/kernel/kernel.h"
 
 namespace Kernel {
@@ -24,15 +22,21 @@ public:
      */
     static SharedPtr<Mutex> Create(bool initial_locked, std::string name = "Unknown");
 
-    std::string GetTypeName() const override { return "Mutex"; }
-    std::string GetName() const override { return name; }
+    std::string GetTypeName() const override {
+        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
-    std::string name;                           ///< Name of mutex (optional)
-    SharedPtr<Thread> holding_thread;           ///< Thread that has acquired the mutex
+    int lock_count;                   ///< Number of times the mutex has been acquired
+    std::string name;                 ///< Name of mutex (optional)
+    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..ba80fe7f8 100644
--- a/src/core/hle/kernel/process.cpp
+++ b/src/core/hle/kernel/process.cpp
@@ -3,11 +3,9 @@
 // Refer to the license.txt file included.
 
 #include <memory>
-
 #include "common/assert.h"
 #include "common/common_funcs.h"
 #include "common/logging/log.h"
-
 #include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
@@ -60,7 +58,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 +69,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 +106,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 vma = vm_manager.MapMemoryBlock(segment.addr, codeset->memory,
-                segment.offset, segment.size, memory_state).Unwrap();
+    auto MapSegment = [&](CodeSet::Segment& segment, VMAPermission permissions,
+                          MemoryState memory_state) {
+        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->rodata, VMAPermission::Read,        MemoryState::Code);
-    MapSegment(codeset->data,   VMAPermission::ReadWrite,   MemoryState::Private);
+    MapSegment(codeset->code, VMAPermission::ReadExecute, MemoryState::Code);
+    MapSegment(codeset->rodata, VMAPermission::Read, MemoryState::Code);
+    MapSegment(codeset->data, VMAPermission::ReadWrite, MemoryState::Private);
 
     // Allocate and map stack
-    vm_manager.MapMemoryBlock(Memory::HEAP_VADDR_END - stack_size,
-            std::make_shared<std::vector<u8>>(stack_size, 0), 0, stack_size, MemoryState::Locked
-            ).Unwrap();
+    vm_manager
+        .MapMemoryBlock(Memory::HEAP_VADDR_END - stack_size,
+                        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 +147,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 +171,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 +182,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 +192,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 +211,8 @@ ResultVal<VAddr> Process::LinearAllocate(VAddr target, u32 size, VMAPermission p
         target = heap_end;
     }
 
-    if (target < GetLinearHeapBase() || target + size > GetLinearHeapLimit() ||
-        target > heap_end || target + size < target) {
+    if (target < GetLinearHeapBase() || target + size > GetLinearHeapLimit() || target > heap_end ||
+        target + size < target) {
 
         return ERR_INVALID_ADDRESS;
     }
@@ -220,7 +228,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 +257,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;
@@ -272,5 +282,4 @@ 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..b566950b0 100644
--- a/src/core/hle/kernel/process.h
+++ b/src/core/hle/kernel/process.h
@@ -8,12 +8,9 @@
 #include <cstddef>
 #include <memory>
 #include <string>
-
 #include <boost/container/static_vector.hpp>
-
 #include "common/bit_field.h"
 #include "common/common_types.h"
-
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/vm_manager.h"
 
@@ -36,15 +33,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< 1, 1, u16> force_debug; ///< Allows this process to attach to processes even if they don't have allow_debug set.
-    BitField< 2, 1, u16> allow_nonalphanum;
-    BitField< 3, 1, u16> shared_page_writable; ///< Shared page is mapped with write permissions.
-    BitField< 4, 1, u16> privileged_priority; ///< Can use priority levels higher than 24.
-    BitField< 5, 1, u16> allow_main_args;
-    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<0, 1, u16>
+        allow_debug; ///< Allows other processes to attach to and debug this process.
+    BitField<1, 1, u16> force_debug; ///< Allows this process to attach to processes even if they
+                                     /// don't have allow_debug set.
+    BitField<2, 1, u16> allow_nonalphanum;
+    BitField<3, 1, u16> shared_page_writable; ///< Shared page is mapped with write permissions.
+    BitField<4, 1, u16> privileged_priority;  ///< Can use priority levels higher than 24.
+    BitField<5, 1, u16> allow_main_args;
+    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 +54,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 GetName() const override { return name; }
+    std::string GetTypeName() const override {
+        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 +91,17 @@ class Process final : public Object {
 public:
     static SharedPtr<Process> Create(SharedPtr<CodeSet> code_set);
 
-    std::string GetTypeName() const override { return "Process"; }
-    std::string GetName() const override { return codeset->name; }
+    std::string GetTypeName() const override {
+        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 +136,6 @@ public:
      */
     void Run(s32 main_thread_priority, u32 stack_size);
 
-
     ///////////////////////////////////////////////////////////////////////////////////////////////
     // Memory Management
 
@@ -144,7 +155,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 +176,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..253ab7045 100644
--- a/src/core/hle/kernel/resource_limit.cpp
+++ b/src/core/hle/kernel/resource_limit.cpp
@@ -3,9 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <cstring>
-
 #include "common/logging/log.h"
-
 #include "core/hle/kernel/resource_limit.h"
 
 namespace Kernel {
@@ -23,70 +21,69 @@ SharedPtr<ResourceLimit> ResourceLimit::Create(std::string name) {
 }
 
 SharedPtr<ResourceLimit> ResourceLimit::GetForCategory(ResourceLimitCategory category) {
-    switch (category)
-    {
-        case ResourceLimitCategory::APPLICATION:
-        case ResourceLimitCategory::SYS_APPLET:
-        case ResourceLimitCategory::LIB_APPLET:
-        case ResourceLimitCategory::OTHER:
-            return resource_limits[static_cast<u8>(category)];
-        default:
-            LOG_CRITICAL(Kernel, "Unknown resource limit category");
-            UNREACHABLE();
+    switch (category) {
+    case ResourceLimitCategory::APPLICATION:
+    case ResourceLimitCategory::SYS_APPLET:
+    case ResourceLimitCategory::LIB_APPLET:
+    case ResourceLimitCategory::OTHER:
+        return resource_limits[static_cast<u8>(category)];
+    default:
+        LOG_CRITICAL(Kernel, "Unknown resource limit category");
+        UNREACHABLE();
     }
 }
 
 s32 ResourceLimit::GetCurrentResourceValue(u32 resource) const {
     switch (resource) {
-        case COMMIT:
-            return current_commit;
-        case THREAD:
-            return current_threads;
-        case EVENT:
-            return current_events;
-        case MUTEX:
-            return current_mutexes;
-        case SEMAPHORE:
-            return current_semaphores;
-        case TIMER:
-            return current_timers;
-        case SHARED_MEMORY:
-            return current_shared_mems;
-        case ADDRESS_ARBITER:
-            return current_address_arbiters;
-        case CPU_TIME:
-            return current_cpu_time;
-        default:
-            LOG_ERROR(Kernel, "Unknown resource type=%08X", resource);
-            UNIMPLEMENTED();
-            return 0;
+    case COMMIT:
+        return current_commit;
+    case THREAD:
+        return current_threads;
+    case EVENT:
+        return current_events;
+    case MUTEX:
+        return current_mutexes;
+    case SEMAPHORE:
+        return current_semaphores;
+    case TIMER:
+        return current_timers;
+    case SHARED_MEMORY:
+        return current_shared_mems;
+    case ADDRESS_ARBITER:
+        return current_address_arbiters;
+    case CPU_TIME:
+        return current_cpu_time;
+    default:
+        LOG_ERROR(Kernel, "Unknown resource type=%08X", resource);
+        UNIMPLEMENTED();
+        return 0;
     }
 }
 
 s32 ResourceLimit::GetMaxResourceValue(u32 resource) const {
     switch (resource) {
-        case COMMIT:
-            return max_commit;
-        case THREAD:
-            return max_threads;
-        case EVENT:
-            return max_events;
-        case MUTEX:
-            return max_mutexes;
-        case SEMAPHORE:
-            return max_semaphores;
-        case TIMER:
-            return max_timers;
-        case SHARED_MEMORY:
-            return max_shared_mems;
-        case ADDRESS_ARBITER:
-            return max_address_arbiters;
-        case CPU_TIME:
-            return max_cpu_time;
-        default:
-            LOG_ERROR(Kernel, "Unknown resource type=%08X", resource);
-            UNIMPLEMENTED();
-            return 0;
+    case COMMIT:
+        return max_commit;
+    case THREAD:
+        return max_threads;
+    case EVENT:
+        return max_events;
+    case MUTEX:
+        return max_mutexes;
+    case SEMAPHORE:
+        return max_semaphores;
+    case TIMER:
+        return max_timers;
+    case SHARED_MEMORY:
+        return max_shared_mems;
+    case ADDRESS_ARBITER:
+        return max_address_arbiters;
+    case CPU_TIME:
+        return max_cpu_time;
+    default:
+        LOG_ERROR(Kernel, "Unknown resource type=%08X", resource);
+        UNIMPLEMENTED();
+        return 0;
     }
 }
 
@@ -149,8 +146,6 @@ void ResourceLimitsInit() {
     resource_limits[static_cast<u8>(ResourceLimitCategory::OTHER)] = resource_limit;
 }
 
-void ResourceLimitsShutdown() {
-
-}
+void ResourceLimitsShutdown() {}
 
 } // namespace
diff --git a/src/core/hle/kernel/resource_limit.h b/src/core/hle/kernel/resource_limit.h
index 1b8249c74..6cdfbcf8d 100644
--- a/src/core/hle/kernel/resource_limit.h
+++ b/src/core/hle/kernel/resource_limit.h
@@ -5,29 +5,28 @@
 #pragma once
 
 #include "common/common_types.h"
-
 #include "core/hle/kernel/kernel.h"
 
 namespace Kernel {
 
 enum class ResourceLimitCategory : u8 {
     APPLICATION = 0,
-    SYS_APPLET  = 1,
-    LIB_APPLET  = 2,
-    OTHER       = 3
+    SYS_APPLET = 1,
+    LIB_APPLET = 2,
+    OTHER = 3
 };
 
 enum ResourceTypes {
-    PRIORITY            = 0,
-    COMMIT              = 1,
-    THREAD              = 2,
-    EVENT               = 3,
-    MUTEX               = 4,
-    SEMAPHORE           = 5,
-    TIMER               = 6,
-    SHARED_MEMORY       = 7,
-    ADDRESS_ARBITER     = 8,
-    CPU_TIME            = 9,
+    PRIORITY = 0,
+    COMMIT = 1,
+    THREAD = 2,
+    EVENT = 3,
+    MUTEX = 4,
+    SEMAPHORE = 5,
+    TIMER = 6,
+    SHARED_MEMORY = 7,
+    ADDRESS_ARBITER = 8,
+    CPU_TIME = 9,
 };
 
 class ResourceLimit final : public Object {
@@ -44,11 +43,17 @@ public:
      */
     static SharedPtr<ResourceLimit> GetForCategory(ResourceLimitCategory category);
 
-    std::string GetTypeName() const override { return "ResourceLimit"; }
-    std::string GetName() const override { return name; }
+    std::string GetTypeName() const override {
+        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 +90,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
-    // APPLICATION resource limits should not be affected by the objects created by service modules.
+    // 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..bf7600780 100644
--- a/src/core/hle/kernel/semaphore.cpp
+++ b/src/core/hle/kernel/semaphore.cpp
@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include "common/assert.h"
-
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/semaphore.h"
 #include "core/hle/kernel/thread.h"
@@ -14,7 +13,7 @@ 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..e01908a25 100644
--- a/src/core/hle/kernel/semaphore.h
+++ b/src/core/hle/kernel/semaphore.h
@@ -6,9 +6,7 @@
 
 #include <queue>
 #include <string>
-
 #include "common/common_types.h"
-
 #include "core/hle/kernel/kernel.h"
 
 namespace Kernel {
@@ -23,17 +21,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 GetName() const override { return name; }
+    std::string GetTypeName() const override {
+        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 available_count;                        ///< Number of free slots left in the semaphore
-    std::string name;                           ///< Name of semaphore (optional)
+    s32 max_count;       ///< Maximum number of simultaneous holders the semaphore can have
+    s32 available_count; ///< Number of free slots left in the semaphore
+    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..8e3ec8a14 100644
--- a/src/core/hle/kernel/server_port.cpp
+++ b/src/core/hle/kernel/server_port.cpp
@@ -3,9 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <tuple>
-
 #include "common/assert.h"
-
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/server_port.h"
@@ -25,7 +23,9 @@ 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..fa9448ca0 100644
--- a/src/core/hle/kernel/server_port.h
+++ b/src/core/hle/kernel/server_port.h
@@ -6,9 +6,7 @@
 
 #include <string>
 #include <tuple>
-
 #include "common/common_types.h"
-
 #include "core/hle/kernel/kernel.h"
 
 namespace Kernel {
@@ -23,17 +21,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 GetName() const override { return name; }
+    std::string GetTypeName() const override {
+        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..8a2a7e3fd 100644
--- a/src/core/hle/kernel/session.cpp
+++ b/src/core/hle/kernel/session.cpp
@@ -9,5 +9,4 @@ namespace Kernel {
 
 Session::Session() {}
 Session::~Session() {}
-
 }
diff --git a/src/core/hle/kernel/session.h b/src/core/hle/kernel/session.h
index 8ec889967..ec025f732 100644
--- a/src/core/hle/kernel/session.h
+++ b/src/core/hle/kernel/session.h
@@ -5,10 +5,8 @@
 #pragma once
 
 #include <string>
-
 #include "common/assert.h"
 #include "common/common_types.h"
-
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/result.h"
@@ -19,12 +17,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 )
-    CopyHandle   = 0x00,
-    MoveHandle   = 0x10,
-    CallingPid   = 0x20,
+    // Handle related descriptors types (mask : 0x30, but need to check for buffer related
+    // descriptors first )
+    CopyHandle = 0x00,
+    MoveHandle = 0x10,
+    CallingPid = 0x20,
 };
 
 /**
@@ -34,24 +33,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) {
-    return (u32(command_id) << 16) | ((u32(normal_params) & 0x3F) << 6) | (u32(translate_params_size) & 0x3F);
+constexpr u32 MakeHeader(u16 command_id, unsigned int normal_params,
+                         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< 6, 6, u32> normal_params;
+    BitField<0, 6, u32> translate_params_size;
+    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 +83,29 @@ constexpr u32 StaticBufferDesc(u32 size, u8 buffer_id) {
 
 union StaticBufferDescInfo {
     u32 raw;
-    BitField< 10, 4, u32> buffer_id;
-    BitField< 14, 18, u32> size;
+    BitField<10, 4, u32> buffer_id;
+    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;
-    return  type | (size << 8) | ((buffer_id & 0xF) << 4);
+    if (is_read_only)
+        type |= 0x2;
+    return type | (size << 8) | ((buffer_id & 0xF) << 4);
 }
 
 enum MappedBufferPermissions {
@@ -115,12 +120,12 @@ constexpr u32 MappedBufferDesc(u32 size, MappedBufferPermissions perms) {
 
 union MappedBufferDescInfo {
     u32 raw;
-    BitField< 4, 28, u32> size;
-    BitField< 1, 2, MappedBufferPermissions> perms;
+    BitField<4, 28, u32> size;
+    BitField<1, 2, MappedBufferPermissions> perms;
 };
 
 inline MappedBufferDescInfo ParseMappedBufferDesc(const u32 desc) {
-    return{ desc };
+    return {desc};
 }
 
 inline DescriptorType GetDescriptorType(u32 descriptor) {
@@ -153,7 +158,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 +189,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 +215,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..bc1560d12 100644
--- a/src/core/hle/kernel/shared_memory.cpp
+++ b/src/core/hle/kernel/shared_memory.cpp
@@ -3,20 +3,20 @@
 // Refer to the license.txt file included.
 
 #include <cstring>
-
 #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() {}
 
-SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u32 size, MemoryPermission permissions,
-        MemoryPermission other_permissions, VAddr address, MemoryRegion region, std::string name) {
+SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u32 size,
+                                             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 +31,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 +40,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 +53,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,
-                                                                         vma.backing_block->data() + vma.offset + size);
+        shared_memory->backing_block = std::make_shared<std::vector<u8>>(
+            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 +75,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,
-                                                      MemoryPermission permissions, MemoryPermission other_permissions, std::string name) {
+SharedPtr<SharedMemory> SharedMemory::CreateForApplet(std::shared_ptr<std::vector<u8>> heap_block,
+                                                      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 +95,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 +127,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 +157,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",
-                  GetObjectId(), target_address, name.c_str());
+        LOG_ERROR(
+            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..94b335ed1 100644
--- a/src/core/hle/kernel/shared_memory.h
+++ b/src/core/hle/kernel/shared_memory.h
@@ -5,9 +5,7 @@
 #pragma once
 
 #include <string>
-
 #include "common/common_types.h"
-
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/result.h"
@@ -16,15 +14,15 @@ namespace Kernel {
 
 /// Permissions for mapped shared memory blocks
 enum class MemoryPermission : u32 {
-    None             = 0,
-    Read             = (1u <<  0),
-    Write            = (1u <<  1),
-    ReadWrite        = (Read | Write),
-    Execute          = (1u <<  2),
-    ReadExecute      = (Read | Execute),
-    WriteExecute     = (Write | Execute),
+    None = 0,
+    Read = (1u << 0),
+    Write = (1u << 1),
+    ReadWrite = (Read | Write),
+    Execute = (1u << 2),
+    ReadExecute = (Read | Execute),
+    WriteExecute = (Write | Execute),
     ReadWriteExecute = (Read | Write | Execute),
-    DontCare         = (1u << 28)
+    DontCare = (1u << 28)
 };
 
 class SharedMemory final : public Object {
@@ -34,13 +32,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,
-            MemoryPermission other_permissions, VAddr address = 0, MemoryRegion region = MemoryRegion::BASE, std::string name = "Unknown");
+    static SharedPtr<SharedMemory> Create(SharedPtr<Process> owner_process, u32 size,
+                                          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 +51,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,
-                                                   MemoryPermission permissions, MemoryPermission other_permissions, std::string name = "Unknown Applet");
-
-    std::string GetTypeName() const override { return "SharedMemory"; }
-    std::string GetName() const override { return name; }
+    static SharedPtr<SharedMemory> CreateForApplet(std::shared_ptr<std::vector<u8>> heap_block,
+                                                   u32 offset, u32 size,
+                                                   MemoryPermission permissions,
+                                                   MemoryPermission other_permissions,
+                                                   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 +86,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 +108,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..4486a812c 100644
--- a/src/core/hle/kernel/thread.cpp
+++ b/src/core/hle/kernel/thread.cpp
@@ -5,23 +5,21 @@
 #include <algorithm>
 #include <list>
 #include <vector>
-
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "common/math_util.h"
 #include "common/thread_queue_list.h"
-
 #include "core/arm/arm_interface.h"
 #include "core/arm/skyeye_common/armstate.h"
 #include "core/core.h"
 #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 +44,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;
 
@@ -103,7 +101,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 +117,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 +136,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 +169,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 +192,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 +246,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 +265,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 +309,7 @@ static Thread* PopNextReadyThread() {
             // Otherwise just keep going with the current thread
             next = thread;
         }
-    } else  {
+    } else {
         next = ready_queue.pop_first();
     }
 
@@ -321,7 +323,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 +355,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 +376,25 @@ void Thread::WakeAfterDelay(s64 nanoseconds) {
 
 void Thread::ResumeFromWait() {
     switch (status) {
-        case THREADSTATUS_WAIT_SYNCH:
-        case THREADSTATUS_WAIT_ARB:
-        case THREADSTATUS_WAIT_SLEEP:
-            break;
-
-        case THREADSTATUS_READY:
-            // 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
-            // already been set to THREADSTATUS_READY.
-            return;
-
-        case THREADSTATUS_RUNNING:
-            DEBUG_ASSERT_MSG(false, "Thread with object id %u has already resumed.", GetObjectId());
-            return;
-        case THREADSTATUS_DEAD:
-            // 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.",
-                GetObjectId());
-            return;
+    case THREADSTATUS_WAIT_SYNCH:
+    case THREADSTATUS_WAIT_ARB:
+    case THREADSTATUS_WAIT_SLEEP:
+        break;
+
+    case THREADSTATUS_READY:
+        // 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
+        // already been set to THREADSTATUS_READY.
+        return;
+
+    case THREADSTATUS_RUNNING:
+        DEBUG_ASSERT_MSG(false, "Thread with object id %u has already resumed.", GetObjectId());
+        return;
+    case THREADSTATUS_DEAD:
+        // 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.",
+                         GetObjectId());
+        return;
     }
 
     ready_queue.push_back(current_priority, this);
@@ -405,7 +409,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 +453,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 +464,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",
-            name.c_str(), priority, new_priority);
+        LOG_WARNING(Kernel_SVC, "(name=%s): invalid priority=%d, clamping to %d", name.c_str(),
+                    priority, new_priority);
         // TODO(bunnei): Clamping to a valid priority is not necessarily correct behavior... Confirm
         // validity of this
         priority = new_priority;
@@ -472,7 +478,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 +517,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");
-            return ResultCode(ErrorDescription::OutOfMemory, ErrorModule::Kernel, ErrorSummary::OutOfResource, ErrorLevel::Permanent);
+            LOG_ERROR(Kernel_SVC,
+                      "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 +545,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 +560,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 +597,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,
-            THREADPROCESSORID_0, Memory::HEAP_VADDR_END);
+    auto thread_res = Thread::Create("main", entry_point, priority, 0, THREADPROCESSORID_0,
+                                     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..f63131716 100644
--- a/src/core/hle/kernel/thread.h
+++ b/src/core/hle/kernel/thread.h
@@ -6,40 +6,36 @@
 
 #include <string>
 #include <vector>
-
 #include <boost/container/flat_set.hpp>
-
 #include "common/common_types.h"
-
 #include "core/core.h"
-
 #include "core/hle/hle.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/result.h"
 
-enum ThreadPriority : s32{
-    THREADPRIO_HIGHEST          = 0,  ///< Highest thread priority
-    THREADPRIO_USERLAND_MAX     = 24, ///< Highest thread priority for userland apps
-    THREADPRIO_DEFAULT          = 48, ///< Default thread priority for userland apps
-    THREADPRIO_LOWEST           = 63, ///< Lowest thread priority
+enum ThreadPriority : s32 {
+    THREADPRIO_HIGHEST = 0,       ///< Highest thread priority
+    THREADPRIO_USERLAND_MAX = 24, ///< Highest thread priority for userland apps
+    THREADPRIO_DEFAULT = 48,      ///< Default thread priority for userland apps
+    THREADPRIO_LOWEST = 63,       ///< Lowest thread priority
 };
 
 enum ThreadProcessorId : s32 {
-    THREADPROCESSORID_DEFAULT   = -2, ///< Run thread on default core specified by exheader
-    THREADPROCESSORID_ALL       = -1, ///< Run thread on either core
-    THREADPROCESSORID_0         =  0, ///< Run thread on core 0 (AppCore)
-    THREADPROCESSORID_1         =  1, ///< Run thread on core 1 (SysCore)
-    THREADPROCESSORID_MAX       =  2, ///< Processor ID must be less than this
+    THREADPROCESSORID_DEFAULT = -2, ///< Run thread on default core specified by exheader
+    THREADPROCESSORID_ALL = -1,     ///< Run thread on either core
+    THREADPROCESSORID_0 = 0,        ///< Run thread on core 0 (AppCore)
+    THREADPROCESSORID_1 = 1,        ///< Run thread on core 1 (SysCore)
+    THREADPROCESSORID_MAX = 2,      ///< Processor ID must be less than this
 };
 
 enum ThreadStatus {
-    THREADSTATUS_RUNNING,       ///< Currently running
-    THREADSTATUS_READY,         ///< Ready to run
-    THREADSTATUS_WAIT_ARB,      ///< Waiting on an address arbiter
-    THREADSTATUS_WAIT_SLEEP,    ///< Waiting due to a SleepThread SVC
-    THREADSTATUS_WAIT_SYNCH,    ///< Waiting due to a WaitSynchronization SVC
-    THREADSTATUS_DORMANT,       ///< Created but not yet made ready
-    THREADSTATUS_DEAD           ///< Run to completion, or forcefully terminated
+    THREADSTATUS_RUNNING,    ///< Currently running
+    THREADSTATUS_READY,      ///< Ready to run
+    THREADSTATUS_WAIT_ARB,   ///< Waiting on an address arbiter
+    THREADSTATUS_WAIT_SLEEP, ///< Waiting due to a SleepThread SVC
+    THREADSTATUS_WAIT_SYNCH, ///< Waiting due to a WaitSynchronization SVC
+    THREADSTATUS_DORMANT,    ///< Created but not yet made ready
+    THREADSTATUS_DEAD        ///< Run to completion, or forcefully terminated
 };
 
 namespace Kernel {
@@ -60,13 +56,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 GetTypeName() const override { return "Thread"; }
+    std::string GetName() const override {
+        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 +77,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 +97,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 +133,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 +145,8 @@ public:
     u32 entry_point;
     u32 stack_top;
 
-    s32 nominal_priority;   ///< Nominal thread priority, as set by the emulated application
-    s32 current_priority;   ///< Current thread priority, can be temporarily changed
+    s32 nominal_priority; ///< Nominal thread priority, as set by the emulated application
+    s32 current_priority; ///< Current thread priority, can be temporarily changed
 
     u64 last_running_ticks; ///< CPU tick when thread was last running
 
@@ -151,11 +159,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
-    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
+    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_set_output; ///< True if the output parameter should be set on thread wakeup
 
     std::string name;
 
@@ -205,10 +213,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..a9f98223c 100644
--- a/src/core/hle/kernel/timer.cpp
+++ b/src/core/hle/kernel/timer.cpp
@@ -3,14 +3,12 @@
 // Refer to the license.txt file included.
 
 #include <cinttypes>
-
 #include "common/assert.h"
 #include "common/logging/log.h"
-
 #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 {
 
@@ -41,7 +39,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 +53,8 @@ void Timer::Set(s64 initial, s64 interval) {
     interval_delay = interval;
 
     u64 initial_microseconds = initial / 1000;
-    CoreTiming::ScheduleEvent(usToCycles(initial_microseconds),
-            timer_callback_event_type, callback_handle);
+    CoreTiming::ScheduleEvent(usToCycles(initial_microseconds), timer_callback_event_type,
+                              callback_handle);
 
     HLE::Reschedule(__func__);
 }
@@ -73,7 +71,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 +90,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);
     }
 }
 
@@ -100,7 +99,6 @@ void TimersInit() {
     timer_callback_event_type = CoreTiming::RegisterEvent("TimerCallback", TimerCallback);
 }
 
-void TimersShutdown() {
-}
+void TimersShutdown() {}
 
 } // namespace
diff --git a/src/core/hle/kernel/timer.h b/src/core/hle/kernel/timer.h
index b1db60e8f..59a77aad3 100644
--- a/src/core/hle/kernel/timer.h
+++ b/src/core/hle/kernel/timer.h
@@ -5,7 +5,6 @@
 #pragma once
 
 #include "common/common_types.h"
-
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/kernel.h"
 
@@ -21,19 +20,25 @@ public:
      */
     static SharedPtr<Timer> Create(ResetType reset_type, std::string name = "Unknown");
 
-    std::string GetTypeName() const override { return "Timer"; }
-    std::string GetName() const override { return name; }
+    std::string GetTypeName() const override {
+        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
-    std::string name;                       ///< Name of timer (optional)
+    bool signaled;    ///< Whether the timer has been signaled or not
+    std::string name; ///< Name of timer (optional)
 
-    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 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
 
     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..6dd24f846 100644
--- a/src/core/hle/kernel/vm_manager.cpp
+++ b/src/core/hle/kernel/vm_manager.cpp
@@ -3,9 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <iterator>
-
 #include "common/assert.h"
-
 #include "core/hle/kernel/vm_manager.h"
 #include "core/memory.h"
 #include "core/memory_setup.h"
@@ -15,8 +13,8 @@ namespace Kernel {
 
 static const char* GetMemoryStateName(MemoryState state) {
     static const char* names[] = {
-        "Free", "Reserved", "IO", "Static", "Code", "Private", "Shared", "Continuous", "Aliased",
-        "Alias", "AliasCode", "Locked",
+        "Free",   "Reserved",   "IO",      "Static", "Code",      "Private",
+        "Shared", "Continuous", "Aliased", "Alias",  "AliasCode", "Locked",
     };
 
     return names[(int)state];
@@ -24,13 +22,12 @@ static const char* GetMemoryStateName(MemoryState state) {
 
 bool VirtualMemoryArea::CanBeMergedWith(const VirtualMemoryArea& next) const {
     ASSERT(base + size == next.base);
-    if (permissions != next.permissions ||
-            meminfo_state != next.meminfo_state ||
-            type != next.type) {
+    if (permissions != next.permissions || meminfo_state != next.meminfo_state ||
+        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 +67,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 +88,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 +106,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 +193,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",
-            vma.base, vma.base + vma.size, vma.size,
-            (u8)vma.permissions & (u8)VMAPermission::Read    ? 'R' : '-',
-            (u8)vma.permissions & (u8)VMAPermission::Write   ? 'W' : '-',
-            (u8)vma.permissions & (u8)VMAPermission::Execute ? 'X' : '-', GetMemoryStateName(vma.meminfo_state));
+        LOG_GENERIC(Log::Class::Kernel, log_level, "%08X - %08X  size: %8X %c%c%c %s", vma.base,
+                    vma.base + vma.size, vma.size,
+                    (u8)vma.permissions & (u8)VMAPermission::Read ? 'R' : '-',
+                    (u8)vma.permissions & (u8)VMAPermission::Write ? 'W' : '-',
+                    (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 +340,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..9055664b2 100644
--- a/src/core/hle/kernel/vm_manager.h
+++ b/src/core/hle/kernel/vm_manager.h
@@ -7,21 +7,19 @@
 #include <map>
 #include <memory>
 #include <vector>
-
 #include "common/common_types.h"
-
 #include "core/hle/result.h"
 #include "core/mmio.h"
 
 namespace Kernel {
 
-const ResultCode ERR_INVALID_ADDRESS{ // 0xE0E01BF5
-        ErrorDescription::InvalidAddress, ErrorModule::OS,
-        ErrorSummary::InvalidArgument, ErrorLevel::Usage};
+const ResultCode ERR_INVALID_ADDRESS{// 0xE0E01BF5
+                                     ErrorDescription::InvalidAddress, ErrorModule::OS,
+                                     ErrorSummary::InvalidArgument, ErrorLevel::Usage};
 
-const ResultCode ERR_INVALID_ADDRESS_STATE{ // 0xE0A01BF5
-        ErrorDescription::InvalidAddress, ErrorModule::OS,
-        ErrorSummary::InvalidState, ErrorLevel::Usage};
+const ResultCode ERR_INVALID_ADDRESS_STATE{// 0xE0A01BF5
+                                           ErrorDescription::InvalidAddress, ErrorModule::OS,
+                                           ErrorSummary::InvalidState, ErrorLevel::Usage};
 
 enum class VMAType : u8 {
     /// VMA represents an unmapped region of the address space.
@@ -115,7 +113,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 +150,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 +171,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 +228,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..7f8d8e00d 100644
--- a/src/core/hle/result.h
+++ b/src/core/hle/result.h
@@ -6,7 +6,6 @@
 
 #include <new>
 #include <utility>
-
 #include "common/assert.h"
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
@@ -26,7 +25,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 +168,15 @@ enum class ErrorSummary : u32 {
     Success = 0,
     NothingHappened = 1,
     WouldBlock = 2,
-    OutOfResource = 3,      ///< There are no more kernel resources (memory, table slots) to
-                            ///< execute the operation.
-    NotFound = 4,           ///< A file or resource was not found.
+    OutOfResource = 3, ///< There are no more kernel resources (memory, table slots) to
+                       ///< execute the operation.
+    NotFound = 4,      ///< A file or resource was not found.
     InvalidState = 5,
-    NotSupported = 6,       ///< The operation is not supported or not implemented.
-    InvalidArgument = 7,    ///< Returned when a passed argument is invalid in the current runtime
-                            ///< context. (Invalid handle, out-of-bounds pointer or size, etc.)
-    WrongArgument = 8,      ///< Returned when a passed argument is in an incorrect format for use
-                            ///< with the function. (E.g. Invalid enum value)
+    NotSupported = 6,    ///< The operation is not supported or not implemented.
+    InvalidArgument = 7, ///< Returned when a passed argument is invalid in the current runtime
+                         ///< context. (Invalid handle, out-of-bounds pointer or size, etc.)
+    WrongArgument = 8,   ///< Returned when a passed argument is in an incorrect format for use
+                         ///< with the function. (E.g. Invalid enum value)
     Canceled = 9,
     StatusChanged = 10,
     Internal = 11,
@@ -208,19 +208,24 @@ 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) {}
-    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 +251,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,
-            ErrorSummary::NotSupported, ErrorLevel::Permanent);
+    return ResultCode(ErrorDescription::NotImplemented, module, ErrorSummary::NotSupported,
+                      ErrorLevel::Permanent);
 }
 
 /**
@@ -285,10 +290,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.
-    ResultVal(ResultCode error_code = ResultCode(-1))
-        : result_code(error_code)
-    {
+    /// Constructs an empty `ResultVal` with the given error code. The code must not be a success
+    /// code.
+    ResultVal(ResultCode error_code = ResultCode(-1)) : result_code(error_code) {
         ASSERT(error_code.IsError());
     }
 
@@ -303,17 +307,13 @@ public:
         return result;
     }
 
-    ResultVal(const ResultVal& o)
-        : result_code(o.result_code)
-    {
+    ResultVal(const ResultVal& o) : result_code(o.result_code) {
         if (!o.empty()) {
             new (&object) T(o.object);
         }
     }
 
-    ResultVal(ResultVal&& o)
-        : result_code(o.result_code)
-    {
+    ResultVal(ResultVal&& o) : result_code(o.result_code) {
         if (!o.empty()) {
             new (&object) T(std::move(o.object));
         }
@@ -357,19 +357,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; }
-          T& operator* ()       { return object; }
-    const T* operator->() const { return &object; }
-          T* operator->()       { return &object; }
+    const T& operator*() const {
+        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 +406,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 +427,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) \
-        auto CONCAT2(check_result_L, __LINE__) = source; \
-        if (CONCAT2(check_result_L, __LINE__).Failed()) \
-            return CONCAT2(check_result_L, __LINE__).Code(); \
-        target = std::move(*CONCAT2(check_result_L, __LINE__))
+#define CASCADE_RESULT(target, source)                                                             \
+    auto CONCAT2(check_result_L, __LINE__) = source;                                               \
+    if (CONCAT2(check_result_L, __LINE__).Failed())                                                \
+        return CONCAT2(check_result_L, __LINE__).Code();                                           \
+    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..12d94f37a 100644
--- a/src/core/hle/service/ac_u.cpp
+++ b/src/core/hle/service/ac_u.cpp
@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include "common/logging/log.h"
-
 #include "core/hle/kernel/event.h"
 #include "core/hle/service/ac_u.h"
 
@@ -47,7 +46,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 +61,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"},
-    {0x00040006, nullptr,               "ConnectAsync"},
-    {0x00050002, nullptr,               "GetConnectResult"},
-    {0x00080004, CloseAsync,            "CloseAsync"},
-    {0x00090002, nullptr,               "GetCloseResult"},
-    {0x000A0000, nullptr,               "GetLastErrorCode"},
-    {0x000D0000, GetWifiStatus,         "GetWifiStatus"},
-    {0x000E0042, nullptr,               "GetCurrentAPInfo"},
-    {0x00100042, nullptr,               "GetCurrentNZoneInfo"},
-    {0x00110042, nullptr,               "GetNZoneApNumService"},
-    {0x00240042, nullptr,               "AddDenyApType"},
-    {0x00270002, nullptr,               "GetInfraPriority"},
-    {0x002D0082, nullptr,               "SetRequestEulaVersion"},
-    {0x00300004, nullptr,               "RegisterDisconnectEvent"},
-    {0x003C0042, nullptr,               "GetAPSSIDList"},
-    {0x003E0042, IsConnected,           "IsConnected"},
-    {0x00400042, nullptr,               "SetClientVersion"},
+    {0x00010000, nullptr, "CreateDefaultConfig"},
+    {0x00040006, nullptr, "ConnectAsync"},
+    {0x00050002, nullptr, "GetConnectResult"},
+    {0x00080004, CloseAsync, "CloseAsync"},
+    {0x00090002, nullptr, "GetCloseResult"},
+    {0x000A0000, nullptr, "GetLastErrorCode"},
+    {0x000D0000, GetWifiStatus, "GetWifiStatus"},
+    {0x000E0042, nullptr, "GetCurrentAPInfo"},
+    {0x00100042, nullptr, "GetCurrentNZoneInfo"},
+    {0x00110042, nullptr, "GetNZoneApNumService"},
+    {0x00240042, nullptr, "AddDenyApType"},
+    {0x00270002, nullptr, "GetInfraPriority"},
+    {0x002D0082, nullptr, "SetRequestEulaVersion"},
+    {0x00300004, nullptr, "RegisterDisconnectEvent"},
+    {0x003C0042, nullptr, "GetAPSSIDList"},
+    {0x003E0042, IsConnected, "IsConnected"},
+    {0x00400042, nullptr, "SetClientVersion"},
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index 3f71e7f2b..f7a990d69 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -3,22 +3,20 @@
 // Refer to the license.txt file included.
 
 #include <cinttypes>
-
 #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_titles_count = { 0, 0, 0 };
-static std::array<u32, 3> am_titles_list_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_list_count = {0, 0, 0};
 static u32 am_ticket_count = 0;
 static u32 am_ticket_list_count = 0;
 
@@ -29,7 +27,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 +42,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",
-                media_type, title_id, am_content_count[media_type], content_ids_pointer, content_info_pointer);
+    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",
+                media_type, title_id, am_content_count[media_type], content_ids_pointer,
+                content_info_pointer);
 }
 
 void ListContentInfos(Service::Interface* self) {
@@ -59,8 +60,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",
-                media_type, am_content_count[media_type], title_id, start_index, content_info_pointer);
+    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",
+                media_type, am_content_count[media_type], title_id, start_index,
+                content_info_pointer);
 }
 
 void DeleteContents(Service::Interface* self) {
@@ -73,8 +76,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",
-        media_type, title_id, am_content_count[media_type], content_ids_pointer);
+    LOG_WARNING(Service_AM, "(STUBBED) media_type=%u, title_id=0x%016" PRIx64
+                            ", 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 +91,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",
-                media_type, am_titles_list_count[media_type], title_ids_output_pointer);
+    LOG_WARNING(
+        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 +107,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 +129,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",
-                 am_ticket_count, title_id, start_index, ticket_info_pointer);
+    LOG_WARNING(Service_AM, "(STUBBED) ticket_count=0x%08X, title_id=0x%016" PRIx64
+                            ", 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 +148,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 +156,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 +169,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",
-                am_ticket_list_count, num_of_skip, ticket_list_pointer);
+    LOG_WARNING(
+        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() {
@@ -174,9 +184,7 @@ void Init() {
     AddService(new AM_U_Interface);
 }
 
-void Shutdown() {
-
-}
+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"},
-    {0x10020104, FindContentInfos,          "FindContentInfos"},
-    {0x10030142, ListContentInfos,          "ListContentInfos"},
-    {0x10040102, DeleteContents,            "DeleteContents"},
-    {0x10050084, GetDataTitleInfos,         "GetDataTitleInfos"},
-    {0x10070102, ListDataTitleTicketInfos,  "ListDataTitleTicketInfos"},
-    {0x100900C0, nullptr,                   "IsDataTitleInUse"},
-    {0x100A0000, nullptr,                   "IsExternalTitleDatabaseInitialized"},
+    {0x100100C0, GetNumContentInfos, "GetNumContentInfos"},
+    {0x10020104, FindContentInfos, "FindContentInfos"},
+    {0x10030142, ListContentInfos, "ListContentInfos"},
+    {0x10040102, DeleteContents, "DeleteContents"},
+    {0x10050084, GetDataTitleInfos, "GetDataTitleInfos"},
+    {0x10070102, ListDataTitleTicketInfos, "ListDataTitleTicketInfos"},
+    {0x100900C0, nullptr, "IsDataTitleInUse"},
+    {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"},
-    {0x00020082, GetTitleList,          "GetTitleList"},
-    {0x00030084, GetTitleInfo,          "GetTitleInfo"},
-    {0x000400C0, nullptr,               "DeleteApplicationTitle"},
-    {0x000500C0, nullptr,               "GetTitleProductCode"},
-    {0x000600C0, nullptr,               "GetTitleExtDataId"},
-    {0x00070080, DeleteTicket,          "DeleteTicket"},
-    {0x00080000, GetTicketCount,        "GetTicketCount"},
-    {0x00090082, GetTicketList,         "GetTicketList"},
-    {0x000A0000, nullptr,               "GetDeviceID"},
-    {0x000D0084, nullptr,               "GetPendingTitleInfo"},
-    {0x000E00C0, nullptr,               "DeletePendingTitle"},
-    {0x00140040, nullptr,               "FinalizePendingTitles"},
-    {0x00150040, nullptr,               "DeleteAllPendingTitles"},
-    {0x00180080, nullptr,               "InitializeTitleDatabase"},
-    {0x00190040, nullptr,               "ReloadDBS"},
-    {0x001A00C0, nullptr,               "GetDSiWareExportSize"},
-    {0x001B0144, nullptr,               "ExportDSiWare"},
-    {0x001C0084, nullptr,               "ImportDSiWare"},
-    {0x00230080, nullptr,               "TitleIDListGetTotal2"},
-    {0x002400C2, nullptr,               "GetTitleIDList2"},
-    {0x04010080, nullptr,               "InstallFIRM"},
-    {0x04020040, nullptr,               "StartInstallCIADB0"},
-    {0x04030000, nullptr,               "StartInstallCIADB1"},
-    {0x04040002, nullptr,               "AbortCIAInstall"},
-    {0x04050002, nullptr,               "CloseCIAFinalizeInstall"},
-    {0x04060002, nullptr,               "CloseCIA"},
-    {0x040700C2, nullptr,               "FinalizeTitlesInstall"},
-    {0x04080042, nullptr,               "GetCiaFileInfo"},
-    {0x040E00C2, nullptr,               "InstallTitlesFinish"},
-    {0x040F0000, nullptr,               "InstallNATIVEFIRM"},
-    {0x041000C0, nullptr,               "DeleteTitle"},
-    {0x04120000, nullptr,               "Initialize"},
-    {0x041700C0, nullptr,               "MigrateAGBtoSAV"},
-    {0x08010000, nullptr,               "OpenTicket"},
-    {0x08020002, nullptr,               "TicketAbortInstall"},
-    {0x08030002, nullptr,               "TicketFinalizeInstall"},
-    {0x08040100, nullptr,               "InstallTitleBegin"},
-    {0x08050000, nullptr,               "InstallTitleAbort"},
-    {0x080600C0, nullptr,               "InstallTitleResume"},
-    {0x08070000, nullptr,               "InstallTitleAbortTMD"},
-    {0x08080000, nullptr,               "InstallTitleFinish"},
-    {0x080A0000, nullptr,               "OpenTMD"},
-    {0x080B0002, nullptr,               "TMDAbortInstall"},
-    {0x080C0042, nullptr,               "TMDFinalizeInstall"},
-    {0x080E0040, nullptr,               "OpenContentCreate"},
-    {0x080F0002, nullptr,               "ContentAbortInstall"},
-    {0x08100040, nullptr,               "OpenContentResume"},
-    {0x08120002, nullptr,               "ContentFinalizeInstall"},
-    {0x08130000, nullptr,               "GetTotalContents"},
-    {0x08140042, nullptr,               "GetContentIndexes"},
-    {0x08150044, nullptr,               "GetContentsInfo"},
-    {0x08180042, nullptr,               "GetCTCert"},
-    {0x08190108, nullptr,               "SetCertificates"},
-    {0x081B00C2, nullptr,               "InstallTitlesFinish"},
+    {0x00010040, GetTitleCount, "GetTitleCount"},
+    {0x00020082, GetTitleList, "GetTitleList"},
+    {0x00030084, GetTitleInfo, "GetTitleInfo"},
+    {0x000400C0, nullptr, "DeleteApplicationTitle"},
+    {0x000500C0, nullptr, "GetTitleProductCode"},
+    {0x000600C0, nullptr, "GetTitleExtDataId"},
+    {0x00070080, DeleteTicket, "DeleteTicket"},
+    {0x00080000, GetTicketCount, "GetTicketCount"},
+    {0x00090082, GetTicketList, "GetTicketList"},
+    {0x000A0000, nullptr, "GetDeviceID"},
+    {0x000D0084, nullptr, "GetPendingTitleInfo"},
+    {0x000E00C0, nullptr, "DeletePendingTitle"},
+    {0x00140040, nullptr, "FinalizePendingTitles"},
+    {0x00150040, nullptr, "DeleteAllPendingTitles"},
+    {0x00180080, nullptr, "InitializeTitleDatabase"},
+    {0x00190040, nullptr, "ReloadDBS"},
+    {0x001A00C0, nullptr, "GetDSiWareExportSize"},
+    {0x001B0144, nullptr, "ExportDSiWare"},
+    {0x001C0084, nullptr, "ImportDSiWare"},
+    {0x00230080, nullptr, "TitleIDListGetTotal2"},
+    {0x002400C2, nullptr, "GetTitleIDList2"},
+    {0x04010080, nullptr, "InstallFIRM"},
+    {0x04020040, nullptr, "StartInstallCIADB0"},
+    {0x04030000, nullptr, "StartInstallCIADB1"},
+    {0x04040002, nullptr, "AbortCIAInstall"},
+    {0x04050002, nullptr, "CloseCIAFinalizeInstall"},
+    {0x04060002, nullptr, "CloseCIA"},
+    {0x040700C2, nullptr, "FinalizeTitlesInstall"},
+    {0x04080042, nullptr, "GetCiaFileInfo"},
+    {0x040E00C2, nullptr, "InstallTitlesFinish"},
+    {0x040F0000, nullptr, "InstallNATIVEFIRM"},
+    {0x041000C0, nullptr, "DeleteTitle"},
+    {0x04120000, nullptr, "Initialize"},
+    {0x041700C0, nullptr, "MigrateAGBtoSAV"},
+    {0x08010000, nullptr, "OpenTicket"},
+    {0x08020002, nullptr, "TicketAbortInstall"},
+    {0x08030002, nullptr, "TicketFinalizeInstall"},
+    {0x08040100, nullptr, "InstallTitleBegin"},
+    {0x08050000, nullptr, "InstallTitleAbort"},
+    {0x080600C0, nullptr, "InstallTitleResume"},
+    {0x08070000, nullptr, "InstallTitleAbortTMD"},
+    {0x08080000, nullptr, "InstallTitleFinish"},
+    {0x080A0000, nullptr, "OpenTMD"},
+    {0x080B0002, nullptr, "TMDAbortInstall"},
+    {0x080C0042, nullptr, "TMDFinalizeInstall"},
+    {0x080E0040, nullptr, "OpenContentCreate"},
+    {0x080F0002, nullptr, "ContentAbortInstall"},
+    {0x08100040, nullptr, "OpenContentResume"},
+    {0x08120002, nullptr, "ContentFinalizeInstall"},
+    {0x08130000, nullptr, "GetTotalContents"},
+    {0x08140042, nullptr, "GetContentIndexes"},
+    {0x08150044, nullptr, "GetContentsInfo"},
+    {0x08180042, nullptr, "GetCTCert"},
+    {0x08190108, nullptr, "SetCertificates"},
+    {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..a2268303c 100644
--- a/src/core/hle/service/am/am_sys.cpp
+++ b/src/core/hle/service/am/am_sys.cpp
@@ -9,27 +9,27 @@ namespace Service {
 namespace AM {
 
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010040, GetTitleCount,               "GetTitleCount"},
-    {0x00020082, GetTitleList,                "GetTitleList"},
-    {0x00030084, GetTitleInfo,                "GetTitleInfo"},
-    {0x000400C0, nullptr,                     "DeleteApplicationTitle"},
-    {0x000500C0, nullptr,                     "GetTitleProductCode"},
-    {0x000600C0, nullptr,                     "GetTitleExtDataId"},
-    {0x00070080, DeleteTicket,                "DeleteTicket"},
-    {0x00080000, GetTicketCount,              "GetTicketCount"},
-    {0x00090082, GetTicketList,               "GetTicketList"},
-    {0x000A0000, nullptr,                     "GetDeviceID"},
-    {0x000D0084, nullptr,                     "GetPendingTitleInfo"},
-    {0x000E00C0, nullptr,                     "DeletePendingTitle"},
-    {0x00140040, nullptr,                     "FinalizePendingTitles"},
-    {0x00150040, nullptr,                     "DeleteAllPendingTitles"},
-    {0x00180080, nullptr,                     "InitializeTitleDatabase"},
-    {0x00190040, nullptr,                     "ReloadDBS"},
-    {0x001A00C0, nullptr,                     "GetDSiWareExportSize"},
-    {0x001B0144, nullptr,                     "ExportDSiWare"},
-    {0x001C0084, nullptr,                     "ImportDSiWare"},
-    {0x00230080, nullptr,                     "GetPendingTitleCount"},
-    {0x002400C2, nullptr,                     "GetPendingTitleList"}
+    {0x00010040, GetTitleCount, "GetTitleCount"},
+    {0x00020082, GetTitleList, "GetTitleList"},
+    {0x00030084, GetTitleInfo, "GetTitleInfo"},
+    {0x000400C0, nullptr, "DeleteApplicationTitle"},
+    {0x000500C0, nullptr, "GetTitleProductCode"},
+    {0x000600C0, nullptr, "GetTitleExtDataId"},
+    {0x00070080, DeleteTicket, "DeleteTicket"},
+    {0x00080000, GetTicketCount, "GetTicketCount"},
+    {0x00090082, GetTicketList, "GetTicketList"},
+    {0x000A0000, nullptr, "GetDeviceID"},
+    {0x000D0084, nullptr, "GetPendingTitleInfo"},
+    {0x000E00C0, nullptr, "DeletePendingTitle"},
+    {0x00140040, nullptr, "FinalizePendingTitles"},
+    {0x00150040, nullptr, "DeleteAllPendingTitles"},
+    {0x00180080, nullptr, "InitializeTitleDatabase"},
+    {0x00190040, nullptr, "ReloadDBS"},
+    {0x001A00C0, nullptr, "GetDSiWareExportSize"},
+    {0x001B0144, nullptr, "ExportDSiWare"},
+    {0x001C0084, nullptr, "ImportDSiWare"},
+    {0x00230080, nullptr, "GetPendingTitleCount"},
+    {0x002400C2, nullptr, "GetPendingTitleList"},
 };
 
 AM_SYS_Interface::AM_SYS_Interface() {
diff --git a/src/core/hle/service/am/am_u.cpp b/src/core/hle/service/am/am_u.cpp
index d583dd9e6..151b5e42b 100644
--- a/src/core/hle/service/am/am_u.cpp
+++ b/src/core/hle/service/am/am_u.cpp
@@ -9,40 +9,40 @@ namespace Service {
 namespace AM {
 
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010040, GetTitleCount,               "GetTitleCount"},
-    {0x00020082, GetTitleList,                "GetTitleList"},
-    {0x00030084, GetTitleInfo,                "GetTitleInfo"},
-    {0x000400C0, nullptr,                     "DeleteApplicationTitle"},
-    {0x000500C0, nullptr,                     "GetTitleProductCode"},
-    {0x000600C0, nullptr,                     "GetTitleExtDataId"},
-    {0x00070080, DeleteTicket,                "DeleteTicket"},
-    {0x00080000, GetTicketCount,              "GetTicketCount"},
-    {0x00090082, GetTicketList,               "GetTicketList"},
-    {0x000A0000, nullptr,                     "GetDeviceID"},
-    {0x000D0084, nullptr,                     "GetPendingTitleInfo"},
-    {0x000E00C0, nullptr,                     "DeletePendingTitle"},
-    {0x00140040, nullptr,                     "FinalizePendingTitles"},
-    {0x00150040, nullptr,                     "DeleteAllPendingTitles"},
-    {0x00180080, nullptr,                     "InitializeTitleDatabase"},
-    {0x00190040, nullptr,                     "ReloadDBS"},
-    {0x001A00C0, nullptr,                     "GetDSiWareExportSize"},
-    {0x001B0144, nullptr,                     "ExportDSiWare"},
-    {0x001C0084, nullptr,                     "ImportDSiWare"},
-    {0x00230080, nullptr,                     "TitleIDListGetTotal2"},
-    {0x002400C2, nullptr,                     "GetTitleIDList2"},
-    {0x04010080, nullptr,                     "InstallFIRM"},
-    {0x04020040, nullptr,                     "StartInstallCIADB0"},
-    {0x04030000, nullptr,                     "StartInstallCIADB1"},
-    {0x04040002, nullptr,                     "AbortCIAInstall"},
-    {0x04050002, nullptr,                     "CloseCIAFinalizeInstall"},
-    {0x04060002, nullptr,                     "CloseCIA"},
-    {0x040700C2, nullptr,                     "FinalizeTitlesInstall"},
-    {0x04080042, nullptr,                     "GetCiaFileInfo"},
-    {0x040E00C2, nullptr,                     "InstallTitlesFinish"},
-    {0x040F0000, nullptr,                     "InstallNATIVEFIRM"},
-    {0x041000C0, nullptr,                     "DeleteTitle"},
-    {0x04120000, nullptr,                     "Initialize"},
-    {0x041700C0, nullptr,                     "MigrateAGBtoSAV"}
+    {0x00010040, GetTitleCount, "GetTitleCount"},
+    {0x00020082, GetTitleList, "GetTitleList"},
+    {0x00030084, GetTitleInfo, "GetTitleInfo"},
+    {0x000400C0, nullptr, "DeleteApplicationTitle"},
+    {0x000500C0, nullptr, "GetTitleProductCode"},
+    {0x000600C0, nullptr, "GetTitleExtDataId"},
+    {0x00070080, DeleteTicket, "DeleteTicket"},
+    {0x00080000, GetTicketCount, "GetTicketCount"},
+    {0x00090082, GetTicketList, "GetTicketList"},
+    {0x000A0000, nullptr, "GetDeviceID"},
+    {0x000D0084, nullptr, "GetPendingTitleInfo"},
+    {0x000E00C0, nullptr, "DeletePendingTitle"},
+    {0x00140040, nullptr, "FinalizePendingTitles"},
+    {0x00150040, nullptr, "DeleteAllPendingTitles"},
+    {0x00180080, nullptr, "InitializeTitleDatabase"},
+    {0x00190040, nullptr, "ReloadDBS"},
+    {0x001A00C0, nullptr, "GetDSiWareExportSize"},
+    {0x001B0144, nullptr, "ExportDSiWare"},
+    {0x001C0084, nullptr, "ImportDSiWare"},
+    {0x00230080, nullptr, "TitleIDListGetTotal2"},
+    {0x002400C2, nullptr, "GetTitleIDList2"},
+    {0x04010080, nullptr, "InstallFIRM"},
+    {0x04020040, nullptr, "StartInstallCIADB0"},
+    {0x04030000, nullptr, "StartInstallCIADB1"},
+    {0x04040002, nullptr, "AbortCIAInstall"},
+    {0x04050002, nullptr, "CloseCIAFinalizeInstall"},
+    {0x04060002, nullptr, "CloseCIA"},
+    {0x040700C2, nullptr, "FinalizeTitlesInstall"},
+    {0x04080042, nullptr, "GetCiaFileInfo"},
+    {0x040E00C2, nullptr, "InstallTitlesFinish"},
+    {0x040F0000, nullptr, "InstallNATIVEFIRM"},
+    {0x041000C0, nullptr, "DeleteTitle"},
+    {0x04120000, nullptr, "Initialize"},
+    {0x041700C0, nullptr, "MigrateAGBtoSAV"},
 };
 
 AM_U_Interface::AM_U_Interface() {
diff --git a/src/core/hle/service/apt/apt.cpp b/src/core/hle/service/apt/apt.cpp
index 4d2956638..c4bd65986 100644
--- a/src/core/hle/service/apt/apt.cpp
+++ b/src/core/hle/service/apt/apt.cpp
@@ -5,9 +5,11 @@
 #include "common/common_paths.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
-
 #include "core/hle/applets/applet.h"
-#include "core/hle/service/service.h"
+#include "core/hle/kernel/event.h"
+#include "core/hle/kernel/mutex.h"
+#include "core/hle/kernel/process.h"
+#include "core/hle/kernel/shared_memory.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,11 +17,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/kernel/event.h"
-#include "core/hle/kernel/mutex.h"
-#include "core/hle/kernel/process.h"
-#include "core/hle/kernel/shared_memory.h"
+#include "core/hle/service/service.h"
 
 namespace Service {
 namespace APT {
@@ -30,7 +28,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 +49,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,21 +73,23 @@ 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.
-    VAddr target_address = Memory::PhysicalToVirtualAddress(shared_font_mem->linear_heap_phys_address);
+    // The shared font has to be relocated to the new address before being passed to the
+    // 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,
-    // 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.
+    // Since the SharedMemory interface doesn't provide the address at which the memory was
+    // 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();
     cmd_buff[4] = Kernel::g_handle_table.Create(shared_font_mem).MoveFrom();
@@ -112,18 +112,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 +134,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 +160,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 dst_app_id     = cmd_buff[2];
-    u32 signal_type    = cmd_buff[3];
-    u32 buffer_size    = cmd_buff[4];
-    u32 value          = cmd_buff[5];
-    u32 handle         = cmd_buff[6];
-    u32 size           = cmd_buff[7];
-    u32 buffer         = cmd_buff[8];
-
-    std::shared_ptr<HLE::Applets::Applet> dest_applet = HLE::Applets::Applet::Get(static_cast<AppletId>(dst_app_id));
+    u32 src_app_id = cmd_buff[1];
+    u32 dst_app_id = cmd_buff[2];
+    u32 signal_type = cmd_buff[3];
+    u32 buffer_size = cmd_buff[4];
+    u32 value = cmd_buff[5];
+    u32 handle = cmd_buff[6];
+    u32 size = cmd_buff[7];
+    u32 buffer = cmd_buff[8];
+
+    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 +195,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,"
-               "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);
+    LOG_WARNING(
+        Service_APT,
+        "(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 +210,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 +232,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 +241,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 unk    = cmd_buff[2];
-    u32 flag2  = cmd_buff[3];
+    u32 flag1 = cmd_buff[1];
+    u32 unk = cmd_buff[2];
+    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",
-                flag1, unk, flag2, app_id);
+    LOG_WARNING(Service_APT,
+                "(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_info2  = cmd_buff[2];
-    u32 title_info3  = cmd_buff[3];
-    u32 title_info4  = cmd_buff[4];
-    u32 flags        = cmd_buff[5];
+    u32 title_info1 = cmd_buff[1];
+    u32 title_info2 = cmd_buff[2];
+    u32 title_info3 = cmd_buff[3];
+    u32 title_info4 = cmd_buff[4];
+    u32 flags = cmd_buff[5];
 
     if (flags & 0x00000100) {
         unknown_ns_state_field = 1;
@@ -270,25 +276,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,"
-               "title_info4=0x%08X, flags=0x%08X", title_info1, title_info2, title_info3, title_info4, flags);
+    LOG_WARNING(Service_APT,
+                "(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 size1        = cmd_buff[4];
-    u32 buffer1_ptr  = cmd_buff[5];
-    u32 size2        = cmd_buff[6];
-    u32 buffer2_ptr  = cmd_buff[7];
+    u32 flag = cmd_buff[3];
+    u32 size1 = cmd_buff[4];
+    u32 buffer1_ptr = cmd_buff[5];
+    u32 size2 = cmd_buff[6];
+    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,"
-               "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);
+    LOG_WARNING(Service_APT,
+                "(STUBBED) called buffer1_size=0x%08X, buffer2_size=0x%08X, flag=0x%08X,"
+                "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 +312,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, "
-             "buffer1_addr=0x%08X, buffer2_addr=0x%08X", command, buffer1_size, buffer2_size,
-             buffer1_addr, buffer2_addr);
+    LOG_WARNING(Service_APT,
+                "(STUBBED) called command=0x%08X, buffer1_size=0x%08X, buffer2_size=0x%08X, "
+                "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 +403,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 +413,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 +430,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 +442,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 +501,10 @@ void Init() {
     if (file.IsOpen()) {
         // Create shared font memory object
         using Kernel::MemoryPermission;
-        shared_font_mem = Kernel::SharedMemory::Create(nullptr, 0x332000, // 3272 KB
-                MemoryPermission::ReadWrite, MemoryPermission::Read, 0, Kernel::MemoryRegion::SYSTEM, "APT:SharedFont");
+        shared_font_mem =
+            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 +516,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..a118cda1f 100644
--- a/src/core/hle/service/apt/apt.h
+++ b/src/core/hle/service/apt/apt.h
@@ -6,7 +6,6 @@
 
 #include "common/common_types.h"
 #include "common/swap.h"
-
 #include "core/hle/kernel/kernel.h"
 
 namespace Service {
@@ -46,58 +45,58 @@ static_assert(sizeof(CaptureBufferInfo) == 0x20, "CaptureBufferInfo struct has i
 
 /// Signals used by APT functions
 enum class SignalType : u32 {
-    None              = 0x0,
-    AppJustStarted    = 0x1,
+    None = 0x0,
+    AppJustStarted = 0x1,
     LibAppJustStarted = 0x2,
-    LibAppFinished    = 0x3,
-    LibAppClosed      = 0xA,
-    ReturningToApp    = 0xB,
-    ExitingApp        = 0xC,
+    LibAppFinished = 0x3,
+    LibAppClosed = 0xA,
+    ReturningToApp = 0xB,
+    ExitingApp = 0xC,
 };
 
 /// App Id's used by APT functions
 enum class AppletId : u32 {
-    HomeMenu           = 0x101,
-    AlternateMenu      = 0x103,
-    Camera             = 0x110,
-    FriendsList        = 0x112,
-    GameNotes          = 0x113,
-    InternetBrowser    = 0x114,
-    InstructionManual  = 0x115,
-    Notifications      = 0x116,
-    Miiverse           = 0x117,
-    MiiversePost       = 0x118,
-    AmiiboSettings     = 0x119,
-    SoftwareKeyboard1  = 0x201,
-    Ed1                = 0x202,
-    PnoteApp           = 0x204,
-    SnoteApp           = 0x205,
-    Error              = 0x206,
-    Mint               = 0x207,
-    Extrapad           = 0x208,
-    Memolib            = 0x209,
-    Application        = 0x300,
-    AnyLibraryApplet   = 0x400,
-    SoftwareKeyboard2  = 0x401,
-    Ed2                = 0x402,
-    PnoteApp2          = 0x404,
-    SnoteApp2          = 0x405,
-    Error2             = 0x406,
-    Mint2              = 0x407,
-    Extrapad2          = 0x408,
-    Memolib2           = 0x409,
+    HomeMenu = 0x101,
+    AlternateMenu = 0x103,
+    Camera = 0x110,
+    FriendsList = 0x112,
+    GameNotes = 0x113,
+    InternetBrowser = 0x114,
+    InstructionManual = 0x115,
+    Notifications = 0x116,
+    Miiverse = 0x117,
+    MiiversePost = 0x118,
+    AmiiboSettings = 0x119,
+    SoftwareKeyboard1 = 0x201,
+    Ed1 = 0x202,
+    PnoteApp = 0x204,
+    SnoteApp = 0x205,
+    Error = 0x206,
+    Mint = 0x207,
+    Extrapad = 0x208,
+    Memolib = 0x209,
+    Application = 0x300,
+    AnyLibraryApplet = 0x400,
+    SoftwareKeyboard2 = 0x401,
+    Ed2 = 0x402,
+    PnoteApp2 = 0x404,
+    SnoteApp2 = 0x405,
+    Error2 = 0x406,
+    Mint2 = 0x407,
+    Extrapad2 = 0x408,
+    Memolib2 = 0x409,
 };
 
 enum class StartupArgumentType : u32 {
-    OtherApp   = 0,
-    Restart    = 1,
+    OtherApp = 0,
+    Restart = 1,
     OtherMedia = 2,
 };
 
 enum class ScreencapPostPermission : u32 {
-    CleanThePermission                 = 0, //TODO(JamePeng): verify what "zero" means
-    NoExplicitSetting                  = 1,
-    EnableScreenshotPostingToMiiverse  = 2,
+    CleanThePermission = 0, // TODO(JamePeng): verify what "zero" means
+    NoExplicitSetting = 1,
+    EnableScreenshotPostingToMiiverse = 2,
     DisableScreenshotPostingToMiiverse = 3
 };
 
@@ -182,10 +181,11 @@ 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.
- * 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.
+ * APT::IsRegistered service function. This returns whether the specified AppID is registered with
+ * NS yet. 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
  *  Outputs:
@@ -260,9 +260,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..f27ad91b7 100644
--- a/src/core/hle/service/apt/apt_a.cpp
+++ b/src/core/hle/service/apt/apt_a.cpp
@@ -9,34 +9,34 @@ namespace Service {
 namespace APT {
 
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010040, GetLockHandle,                "GetLockHandle?"},
-    {0x00020080, Initialize,                   "Initialize?"},
-    {0x00030040, Enable,                       "Enable?"},
-    {0x00040040, nullptr,                      "Finalize?"},
-    {0x00050040, GetAppletManInfo,             "GetAppletManInfo"},
-    {0x00060040, GetAppletInfo,                "GetAppletInfo"},
-    {0x00090040, IsRegistered,                 "IsRegistered"},
-    {0x000B0040, InquireNotification,          "InquireNotification"},
-    {0x000C0104, SendParameter,                "SendParameter"},
-    {0x000D0080, ReceiveParameter,             "ReceiveParameter"},
-    {0x000E0080, GlanceParameter,              "GlanceParameter"},
-    {0x000F0100, CancelParameter,              "CancelParameter"},
-    {0x00150140, PrepareToStartApplication,    "PrepareToStartApplication"},
-    {0x00160040, PreloadLibraryApplet,         "PreloadLibraryApplet"},
-    {0x00180040, PrepareToStartLibraryApplet,  "PrepareToStartLibraryApplet"},
-    {0x001E0084, StartLibraryApplet,           "StartLibraryApplet"},
-    {0x003B0040, nullptr,                      "CancelLibraryApplet?"},
-    {0x003E0080, nullptr,                      "ReplySleepQuery"},
-    {0x00430040, NotifyToWait,                 "NotifyToWait?"},
-    {0x00440000, GetSharedFont,                "GetSharedFont?"},
-    {0x004B00C2, AppletUtility,                "AppletUtility?"},
-    {0x004F0080, SetAppCpuTimeLimit,           "SetAppCpuTimeLimit"},
-    {0x00500040, GetAppCpuTimeLimit,           "GetAppCpuTimeLimit"},
-    {0x00510080, GetStartupArgument,           "GetStartupArgument"},
-    {0x00550040, SetScreenCapPostPermission,   "SetScreenCapPostPermission"},
-    {0x00560000, GetScreenCapPostPermission,   "GetScreenCapPostPermission"},
-    {0x01010000, CheckNew3DSApp,               "CheckNew3DSApp"},
-    {0x01020000, CheckNew3DS,                  "CheckNew3DS"}
+    {0x00010040, GetLockHandle, "GetLockHandle?"},
+    {0x00020080, Initialize, "Initialize?"},
+    {0x00030040, Enable, "Enable?"},
+    {0x00040040, nullptr, "Finalize?"},
+    {0x00050040, GetAppletManInfo, "GetAppletManInfo"},
+    {0x00060040, GetAppletInfo, "GetAppletInfo"},
+    {0x00090040, IsRegistered, "IsRegistered"},
+    {0x000B0040, InquireNotification, "InquireNotification"},
+    {0x000C0104, SendParameter, "SendParameter"},
+    {0x000D0080, ReceiveParameter, "ReceiveParameter"},
+    {0x000E0080, GlanceParameter, "GlanceParameter"},
+    {0x000F0100, CancelParameter, "CancelParameter"},
+    {0x00150140, PrepareToStartApplication, "PrepareToStartApplication"},
+    {0x00160040, PreloadLibraryApplet, "PreloadLibraryApplet"},
+    {0x00180040, PrepareToStartLibraryApplet, "PrepareToStartLibraryApplet"},
+    {0x001E0084, StartLibraryApplet, "StartLibraryApplet"},
+    {0x003B0040, nullptr, "CancelLibraryApplet?"},
+    {0x003E0080, nullptr, "ReplySleepQuery"},
+    {0x00430040, NotifyToWait, "NotifyToWait?"},
+    {0x00440000, GetSharedFont, "GetSharedFont?"},
+    {0x004B00C2, AppletUtility, "AppletUtility?"},
+    {0x004F0080, SetAppCpuTimeLimit, "SetAppCpuTimeLimit"},
+    {0x00500040, GetAppCpuTimeLimit, "GetAppCpuTimeLimit"},
+    {0x00510080, GetStartupArgument, "GetStartupArgument"},
+    {0x00550040, SetScreenCapPostPermission, "SetScreenCapPostPermission"},
+    {0x00560000, GetScreenCapPostPermission, "GetScreenCapPostPermission"},
+    {0x01010000, CheckNew3DSApp, "CheckNew3DSApp"},
+    {0x01020000, CheckNew3DS, "CheckNew3DS"},
 };
 
 APT_A_Interface::APT_A_Interface() {
diff --git a/src/core/hle/service/apt/apt_s.cpp b/src/core/hle/service/apt/apt_s.cpp
index c70f2201f..c4556a5de 100644
--- a/src/core/hle/service/apt/apt_s.cpp
+++ b/src/core/hle/service/apt/apt_s.cpp
@@ -9,94 +9,94 @@ namespace Service {
 namespace APT {
 
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010040, GetLockHandle,         "GetLockHandle"},
-    {0x00020080, Initialize,            "Initialize"},
-    {0x00030040, Enable,                "Enable"},
-    {0x00040040, nullptr,               "Finalize"},
-    {0x00050040, GetAppletManInfo,      "GetAppletManInfo"},
-    {0x00060040, GetAppletInfo,         "GetAppletInfo"},
-    {0x00070000, nullptr,               "GetLastSignaledAppletId"},
-    {0x00080000, nullptr,               "CountRegisteredApplet"},
-    {0x00090040, nullptr,               "IsRegistered"},
-    {0x000A0040, nullptr,               "GetAttribute"},
-    {0x000B0040, InquireNotification,   "InquireNotification"},
-    {0x000C0104, nullptr,               "SendParameter"},
-    {0x000D0080, ReceiveParameter,      "ReceiveParameter"},
-    {0x000E0080, GlanceParameter,       "GlanceParameter"},
-    {0x000F0100, nullptr,               "CancelParameter"},
-    {0x001000C2, nullptr,               "DebugFunc"},
-    {0x001100C0, nullptr,               "MapProgramIdForDebug"},
-    {0x00120040, nullptr,               "SetHomeMenuAppletIdForDebug"},
-    {0x00130000, nullptr,               "GetPreparationState"},
-    {0x00140040, nullptr,               "SetPreparationState"},
+    {0x00010040, GetLockHandle, "GetLockHandle"},
+    {0x00020080, Initialize, "Initialize"},
+    {0x00030040, Enable, "Enable"},
+    {0x00040040, nullptr, "Finalize"},
+    {0x00050040, GetAppletManInfo, "GetAppletManInfo"},
+    {0x00060040, GetAppletInfo, "GetAppletInfo"},
+    {0x00070000, nullptr, "GetLastSignaledAppletId"},
+    {0x00080000, nullptr, "CountRegisteredApplet"},
+    {0x00090040, nullptr, "IsRegistered"},
+    {0x000A0040, nullptr, "GetAttribute"},
+    {0x000B0040, InquireNotification, "InquireNotification"},
+    {0x000C0104, nullptr, "SendParameter"},
+    {0x000D0080, ReceiveParameter, "ReceiveParameter"},
+    {0x000E0080, GlanceParameter, "GlanceParameter"},
+    {0x000F0100, nullptr, "CancelParameter"},
+    {0x001000C2, nullptr, "DebugFunc"},
+    {0x001100C0, nullptr, "MapProgramIdForDebug"},
+    {0x00120040, nullptr, "SetHomeMenuAppletIdForDebug"},
+    {0x00130000, nullptr, "GetPreparationState"},
+    {0x00140040, nullptr, "SetPreparationState"},
     {0x00150140, PrepareToStartApplication, "PrepareToStartApplication"},
-    {0x00160040, PreloadLibraryApplet,  "PreloadLibraryApplet"},
-    {0x00170040, nullptr,               "FinishPreloadingLibraryApplet"},
-    {0x00180040, PrepareToStartLibraryApplet,"PrepareToStartLibraryApplet"},
-    {0x00190040, nullptr,               "PrepareToStartSystemApplet"},
-    {0x001A0000, nullptr,               "PrepareToStartNewestHomeMenu"},
-    {0x001B00C4, nullptr,               "StartApplication"},
-    {0x001C0000, nullptr,               "WakeupApplication"},
-    {0x001D0000, nullptr,               "CancelApplication"},
-    {0x001E0084, nullptr,               "StartLibraryApplet"},
-    {0x001F0084, nullptr,               "StartSystemApplet"},
-    {0x00200044, nullptr,               "StartNewestHomeMenu"},
-    {0x00210000, nullptr,               "OrderToCloseApplication"},
-    {0x00220040, nullptr,               "PrepareToCloseApplication"},
-    {0x00230040, nullptr,               "PrepareToJumpToApplication"},
-    {0x00240044, nullptr,               "JumpToApplication"},
-    {0x002500C0, nullptr,               "PrepareToCloseLibraryApplet"},
-    {0x00260000, nullptr,               "PrepareToCloseSystemApplet"},
-    {0x00270044, nullptr,               "CloseApplication"},
-    {0x00280044, nullptr,               "CloseLibraryApplet"},
-    {0x00290044, nullptr,               "CloseSystemApplet"},
-    {0x002A0000, nullptr,               "OrderToCloseSystemApplet"},
-    {0x002B0000, nullptr,               "PrepareToJumpToHomeMenu"},
-    {0x002C0044, nullptr,               "JumpToHomeMenu"},
-    {0x002D0000, nullptr,               "PrepareToLeaveHomeMenu"},
-    {0x002E0044, nullptr,               "LeaveHomeMenu"},
-    {0x002F0040, nullptr,               "PrepareToLeaveResidentApplet"},
-    {0x00300044, nullptr,               "LeaveResidentApplet"},
-    {0x00310100, nullptr,               "PrepareToDoApplicationJump"},
-    {0x00320084, nullptr,               "DoApplicationJump"},
-    {0x00330000, nullptr,               "GetProgramIdOnApplicationJump"},
-    {0x00340084, nullptr,               "SendDeliverArg"},
-    {0x00350080, nullptr,               "ReceiveDeliverArg"},
-    {0x00360040, nullptr,               "LoadSysMenuArg"},
-    {0x00370042, nullptr,               "StoreSysMenuArg"},
-    {0x00380040, nullptr,               "PreloadResidentApplet"},
-    {0x00390040, nullptr,               "PrepareToStartResidentApplet"},
-    {0x003A0044, nullptr,               "StartResidentApplet"},
-    {0x003B0040, nullptr,               "CancelLibraryApplet"},
-    {0x003C0042, nullptr,               "SendDspSleep"},
-    {0x003D0042, nullptr,               "SendDspWakeUp"},
-    {0x003E0080, nullptr,               "ReplySleepQuery"},
-    {0x003F0040, nullptr,               "ReplySleepNotificationComplete"},
-    {0x00400042, nullptr,               "SendCaptureBufferInfo"},
-    {0x00410040, nullptr,               "ReceiveCaptureBufferInfo"},
-    {0x00420080, nullptr,               "SleepSystem"},
-    {0x00430040, NotifyToWait,          "NotifyToWait"},
-    {0x00440000, GetSharedFont,         "GetSharedFont"},
-    {0x00450040, nullptr,               "GetWirelessRebootInfo"},
-    {0x00460104, nullptr,               "Wrap"},
-    {0x00470104, nullptr,               "Unwrap"},
-    {0x00480100, nullptr,               "GetProgramInfo"},
-    {0x00490180, nullptr,               "Reboot"},
-    {0x004A0040, nullptr,               "GetCaptureInfo"},
-    {0x004B00C2, AppletUtility,         "AppletUtility"},
-    {0x004C0000, nullptr,               "SetFatalErrDispMode"},
-    {0x004D0080, nullptr,               "GetAppletProgramInfo"},
-    {0x004E0000, nullptr,               "HardwareResetAsync"},
-    {0x004F0080, SetAppCpuTimeLimit,    "SetAppCpuTimeLimit"},
-    {0x00500040, GetAppCpuTimeLimit,    "GetAppCpuTimeLimit"},
-    {0x00510080, GetStartupArgument,    "GetStartupArgument"},
-    {0x00520104, nullptr,               "Wrap1"},
-    {0x00530104, nullptr,               "Unwrap1"},
+    {0x00160040, PreloadLibraryApplet, "PreloadLibraryApplet"},
+    {0x00170040, nullptr, "FinishPreloadingLibraryApplet"},
+    {0x00180040, PrepareToStartLibraryApplet, "PrepareToStartLibraryApplet"},
+    {0x00190040, nullptr, "PrepareToStartSystemApplet"},
+    {0x001A0000, nullptr, "PrepareToStartNewestHomeMenu"},
+    {0x001B00C4, nullptr, "StartApplication"},
+    {0x001C0000, nullptr, "WakeupApplication"},
+    {0x001D0000, nullptr, "CancelApplication"},
+    {0x001E0084, nullptr, "StartLibraryApplet"},
+    {0x001F0084, nullptr, "StartSystemApplet"},
+    {0x00200044, nullptr, "StartNewestHomeMenu"},
+    {0x00210000, nullptr, "OrderToCloseApplication"},
+    {0x00220040, nullptr, "PrepareToCloseApplication"},
+    {0x00230040, nullptr, "PrepareToJumpToApplication"},
+    {0x00240044, nullptr, "JumpToApplication"},
+    {0x002500C0, nullptr, "PrepareToCloseLibraryApplet"},
+    {0x00260000, nullptr, "PrepareToCloseSystemApplet"},
+    {0x00270044, nullptr, "CloseApplication"},
+    {0x00280044, nullptr, "CloseLibraryApplet"},
+    {0x00290044, nullptr, "CloseSystemApplet"},
+    {0x002A0000, nullptr, "OrderToCloseSystemApplet"},
+    {0x002B0000, nullptr, "PrepareToJumpToHomeMenu"},
+    {0x002C0044, nullptr, "JumpToHomeMenu"},
+    {0x002D0000, nullptr, "PrepareToLeaveHomeMenu"},
+    {0x002E0044, nullptr, "LeaveHomeMenu"},
+    {0x002F0040, nullptr, "PrepareToLeaveResidentApplet"},
+    {0x00300044, nullptr, "LeaveResidentApplet"},
+    {0x00310100, nullptr, "PrepareToDoApplicationJump"},
+    {0x00320084, nullptr, "DoApplicationJump"},
+    {0x00330000, nullptr, "GetProgramIdOnApplicationJump"},
+    {0x00340084, nullptr, "SendDeliverArg"},
+    {0x00350080, nullptr, "ReceiveDeliverArg"},
+    {0x00360040, nullptr, "LoadSysMenuArg"},
+    {0x00370042, nullptr, "StoreSysMenuArg"},
+    {0x00380040, nullptr, "PreloadResidentApplet"},
+    {0x00390040, nullptr, "PrepareToStartResidentApplet"},
+    {0x003A0044, nullptr, "StartResidentApplet"},
+    {0x003B0040, nullptr, "CancelLibraryApplet"},
+    {0x003C0042, nullptr, "SendDspSleep"},
+    {0x003D0042, nullptr, "SendDspWakeUp"},
+    {0x003E0080, nullptr, "ReplySleepQuery"},
+    {0x003F0040, nullptr, "ReplySleepNotificationComplete"},
+    {0x00400042, nullptr, "SendCaptureBufferInfo"},
+    {0x00410040, nullptr, "ReceiveCaptureBufferInfo"},
+    {0x00420080, nullptr, "SleepSystem"},
+    {0x00430040, NotifyToWait, "NotifyToWait"},
+    {0x00440000, GetSharedFont, "GetSharedFont"},
+    {0x00450040, nullptr, "GetWirelessRebootInfo"},
+    {0x00460104, nullptr, "Wrap"},
+    {0x00470104, nullptr, "Unwrap"},
+    {0x00480100, nullptr, "GetProgramInfo"},
+    {0x00490180, nullptr, "Reboot"},
+    {0x004A0040, nullptr, "GetCaptureInfo"},
+    {0x004B00C2, AppletUtility, "AppletUtility"},
+    {0x004C0000, nullptr, "SetFatalErrDispMode"},
+    {0x004D0080, nullptr, "GetAppletProgramInfo"},
+    {0x004E0000, nullptr, "HardwareResetAsync"},
+    {0x004F0080, SetAppCpuTimeLimit, "SetAppCpuTimeLimit"},
+    {0x00500040, GetAppCpuTimeLimit, "GetAppCpuTimeLimit"},
+    {0x00510080, GetStartupArgument, "GetStartupArgument"},
+    {0x00520104, nullptr, "Wrap1"},
+    {0x00530104, nullptr, "Unwrap1"},
     {0x00550040, SetScreenCapPostPermission, "SetScreenCapPostPermission"},
     {0x00560000, GetScreenCapPostPermission, "GetScreenCapPostPermission"},
-    {0x00580002, nullptr,               "GetProgramID"},
-    {0x01010000, CheckNew3DSApp,        "CheckNew3DSApp"},
-    {0x01020000, CheckNew3DS,           "CheckNew3DS"}
+    {0x00580002, nullptr, "GetProgramID"},
+    {0x01010000, CheckNew3DSApp, "CheckNew3DSApp"},
+    {0x01020000, CheckNew3DS, "CheckNew3DS"},
 };
 
 APT_S_Interface::APT_S_Interface() {
diff --git a/src/core/hle/service/apt/apt_u.cpp b/src/core/hle/service/apt/apt_u.cpp
index 7bb804ffa..d6ad42e21 100644
--- a/src/core/hle/service/apt/apt_u.cpp
+++ b/src/core/hle/service/apt/apt_u.cpp
@@ -9,94 +9,94 @@ namespace Service {
 namespace APT {
 
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010040, GetLockHandle,                   "GetLockHandle"},
-    {0x00020080, Initialize,                      "Initialize"},
-    {0x00030040, Enable,                          "Enable"},
-    {0x00040040, nullptr,                         "Finalize"},
-    {0x00050040, GetAppletManInfo,                "GetAppletManInfo"},
-    {0x00060040, GetAppletInfo,                   "GetAppletInfo"},
-    {0x00070000, nullptr,                         "GetLastSignaledAppletId"},
-    {0x00080000, nullptr,                         "CountRegisteredApplet"},
-    {0x00090040, IsRegistered,                    "IsRegistered"},
-    {0x000A0040, nullptr,                         "GetAttribute"},
-    {0x000B0040, InquireNotification,             "InquireNotification"},
-    {0x000C0104, SendParameter,                   "SendParameter"},
-    {0x000D0080, ReceiveParameter,                "ReceiveParameter"},
-    {0x000E0080, GlanceParameter,                 "GlanceParameter"},
-    {0x000F0100, CancelParameter,                 "CancelParameter"},
-    {0x001000C2, nullptr,                         "DebugFunc"},
-    {0x001100C0, nullptr,                         "MapProgramIdForDebug"},
-    {0x00120040, nullptr,                         "SetHomeMenuAppletIdForDebug"},
-    {0x00130000, nullptr,                         "GetPreparationState"},
-    {0x00140040, nullptr,                         "SetPreparationState"},
-    {0x00150140, PrepareToStartApplication,       "PrepareToStartApplication"},
-    {0x00160040, PreloadLibraryApplet,            "PreloadLibraryApplet"},
-    {0x00170040, nullptr,                         "FinishPreloadingLibraryApplet"},
-    {0x00180040, PrepareToStartLibraryApplet,     "PrepareToStartLibraryApplet"},
-    {0x00190040, nullptr,                         "PrepareToStartSystemApplet"},
-    {0x001A0000, nullptr,                         "PrepareToStartNewestHomeMenu"},
-    {0x001B00C4, nullptr,                         "StartApplication"},
-    {0x001C0000, nullptr,                         "WakeupApplication"},
-    {0x001D0000, nullptr,                         "CancelApplication"},
-    {0x001E0084, StartLibraryApplet,              "StartLibraryApplet"},
-    {0x001F0084, nullptr,                         "StartSystemApplet"},
-    {0x00200044, nullptr,                         "StartNewestHomeMenu"},
-    {0x00210000, nullptr,                         "OrderToCloseApplication"},
-    {0x00220040, nullptr,                         "PrepareToCloseApplication"},
-    {0x00230040, nullptr,                         "PrepareToJumpToApplication"},
-    {0x00240044, nullptr,                         "JumpToApplication"},
-    {0x002500C0, nullptr,                         "PrepareToCloseLibraryApplet"},
-    {0x00260000, nullptr,                         "PrepareToCloseSystemApplet"},
-    {0x00270044, nullptr,                         "CloseApplication"},
-    {0x00280044, nullptr,                         "CloseLibraryApplet"},
-    {0x00290044, nullptr,                         "CloseSystemApplet"},
-    {0x002A0000, nullptr,                         "OrderToCloseSystemApplet"},
-    {0x002B0000, nullptr,                         "PrepareToJumpToHomeMenu"},
-    {0x002C0044, nullptr,                         "JumpToHomeMenu"},
-    {0x002D0000, nullptr,                         "PrepareToLeaveHomeMenu"},
-    {0x002E0044, nullptr,                         "LeaveHomeMenu"},
-    {0x002F0040, nullptr,                         "PrepareToLeaveResidentApplet"},
-    {0x00300044, nullptr,                         "LeaveResidentApplet"},
-    {0x00310100, nullptr,                         "PrepareToDoApplicationJump"},
-    {0x00320084, nullptr,                         "DoApplicationJump"},
-    {0x00330000, nullptr,                         "GetProgramIdOnApplicationJump"},
-    {0x00340084, nullptr,                         "SendDeliverArg"},
-    {0x00350080, nullptr,                         "ReceiveDeliverArg"},
-    {0x00360040, nullptr,                         "LoadSysMenuArg"},
-    {0x00370042, nullptr,                         "StoreSysMenuArg"},
-    {0x00380040, nullptr,                         "PreloadResidentApplet"},
-    {0x00390040, nullptr,                         "PrepareToStartResidentApplet"},
-    {0x003A0044, nullptr,                         "StartResidentApplet"},
-    {0x003B0040, nullptr,                         "CancelLibraryApplet"},
-    {0x003C0042, nullptr,                         "SendDspSleep"},
-    {0x003D0042, nullptr,                         "SendDspWakeUp"},
-    {0x003E0080, nullptr,                         "ReplySleepQuery"},
-    {0x003F0040, nullptr,                         "ReplySleepNotificationComplete"},
-    {0x00400042, nullptr,                         "SendCaptureBufferInfo"},
-    {0x00410040, nullptr,                         "ReceiveCaptureBufferInfo"},
-    {0x00420080, nullptr,                         "SleepSystem"},
-    {0x00430040, NotifyToWait,                    "NotifyToWait"},
-    {0x00440000, GetSharedFont,                   "GetSharedFont"},
-    {0x00450040, nullptr,                         "GetWirelessRebootInfo"},
-    {0x00460104, nullptr,                         "Wrap"},
-    {0x00470104, nullptr,                         "Unwrap"},
-    {0x00480100, nullptr,                         "GetProgramInfo"},
-    {0x00490180, nullptr,                         "Reboot"},
-    {0x004A0040, nullptr,                         "GetCaptureInfo"},
-    {0x004B00C2, AppletUtility,                   "AppletUtility"},
-    {0x004C0000, nullptr,                         "SetFatalErrDispMode"},
-    {0x004D0080, nullptr,                         "GetAppletProgramInfo"},
-    {0x004E0000, nullptr,                         "HardwareResetAsync"},
-    {0x004F0080, SetAppCpuTimeLimit,              "SetAppCpuTimeLimit"},
-    {0x00500040, GetAppCpuTimeLimit,              "GetAppCpuTimeLimit"},
-    {0x00510080, GetStartupArgument,              "GetStartupArgument"},
-    {0x00520104, nullptr,                         "Wrap1"},
-    {0x00530104, nullptr,                         "Unwrap1"},
-    {0x00550040, SetScreenCapPostPermission,      "SetScreenCapPostPermission"},
-    {0x00560000, GetScreenCapPostPermission,      "GetScreenCapPostPermission"},
-    {0x00580002, nullptr,                         "GetProgramID"},
-    {0x01010000, CheckNew3DSApp,                  "CheckNew3DSApp"},
-    {0x01020000, CheckNew3DS,                     "CheckNew3DS"}
+    {0x00010040, GetLockHandle, "GetLockHandle"},
+    {0x00020080, Initialize, "Initialize"},
+    {0x00030040, Enable, "Enable"},
+    {0x00040040, nullptr, "Finalize"},
+    {0x00050040, GetAppletManInfo, "GetAppletManInfo"},
+    {0x00060040, GetAppletInfo, "GetAppletInfo"},
+    {0x00070000, nullptr, "GetLastSignaledAppletId"},
+    {0x00080000, nullptr, "CountRegisteredApplet"},
+    {0x00090040, IsRegistered, "IsRegistered"},
+    {0x000A0040, nullptr, "GetAttribute"},
+    {0x000B0040, InquireNotification, "InquireNotification"},
+    {0x000C0104, SendParameter, "SendParameter"},
+    {0x000D0080, ReceiveParameter, "ReceiveParameter"},
+    {0x000E0080, GlanceParameter, "GlanceParameter"},
+    {0x000F0100, CancelParameter, "CancelParameter"},
+    {0x001000C2, nullptr, "DebugFunc"},
+    {0x001100C0, nullptr, "MapProgramIdForDebug"},
+    {0x00120040, nullptr, "SetHomeMenuAppletIdForDebug"},
+    {0x00130000, nullptr, "GetPreparationState"},
+    {0x00140040, nullptr, "SetPreparationState"},
+    {0x00150140, PrepareToStartApplication, "PrepareToStartApplication"},
+    {0x00160040, PreloadLibraryApplet, "PreloadLibraryApplet"},
+    {0x00170040, nullptr, "FinishPreloadingLibraryApplet"},
+    {0x00180040, PrepareToStartLibraryApplet, "PrepareToStartLibraryApplet"},
+    {0x00190040, nullptr, "PrepareToStartSystemApplet"},
+    {0x001A0000, nullptr, "PrepareToStartNewestHomeMenu"},
+    {0x001B00C4, nullptr, "StartApplication"},
+    {0x001C0000, nullptr, "WakeupApplication"},
+    {0x001D0000, nullptr, "CancelApplication"},
+    {0x001E0084, StartLibraryApplet, "StartLibraryApplet"},
+    {0x001F0084, nullptr, "StartSystemApplet"},
+    {0x00200044, nullptr, "StartNewestHomeMenu"},
+    {0x00210000, nullptr, "OrderToCloseApplication"},
+    {0x00220040, nullptr, "PrepareToCloseApplication"},
+    {0x00230040, nullptr, "PrepareToJumpToApplication"},
+    {0x00240044, nullptr, "JumpToApplication"},
+    {0x002500C0, nullptr, "PrepareToCloseLibraryApplet"},
+    {0x00260000, nullptr, "PrepareToCloseSystemApplet"},
+    {0x00270044, nullptr, "CloseApplication"},
+    {0x00280044, nullptr, "CloseLibraryApplet"},
+    {0x00290044, nullptr, "CloseSystemApplet"},
+    {0x002A0000, nullptr, "OrderToCloseSystemApplet"},
+    {0x002B0000, nullptr, "PrepareToJumpToHomeMenu"},
+    {0x002C0044, nullptr, "JumpToHomeMenu"},
+    {0x002D0000, nullptr, "PrepareToLeaveHomeMenu"},
+    {0x002E0044, nullptr, "LeaveHomeMenu"},
+    {0x002F0040, nullptr, "PrepareToLeaveResidentApplet"},
+    {0x00300044, nullptr, "LeaveResidentApplet"},
+    {0x00310100, nullptr, "PrepareToDoApplicationJump"},
+    {0x00320084, nullptr, "DoApplicationJump"},
+    {0x00330000, nullptr, "GetProgramIdOnApplicationJump"},
+    {0x00340084, nullptr, "SendDeliverArg"},
+    {0x00350080, nullptr, "ReceiveDeliverArg"},
+    {0x00360040, nullptr, "LoadSysMenuArg"},
+    {0x00370042, nullptr, "StoreSysMenuArg"},
+    {0x00380040, nullptr, "PreloadResidentApplet"},
+    {0x00390040, nullptr, "PrepareToStartResidentApplet"},
+    {0x003A0044, nullptr, "StartResidentApplet"},
+    {0x003B0040, nullptr, "CancelLibraryApplet"},
+    {0x003C0042, nullptr, "SendDspSleep"},
+    {0x003D0042, nullptr, "SendDspWakeUp"},
+    {0x003E0080, nullptr, "ReplySleepQuery"},
+    {0x003F0040, nullptr, "ReplySleepNotificationComplete"},
+    {0x00400042, nullptr, "SendCaptureBufferInfo"},
+    {0x00410040, nullptr, "ReceiveCaptureBufferInfo"},
+    {0x00420080, nullptr, "SleepSystem"},
+    {0x00430040, NotifyToWait, "NotifyToWait"},
+    {0x00440000, GetSharedFont, "GetSharedFont"},
+    {0x00450040, nullptr, "GetWirelessRebootInfo"},
+    {0x00460104, nullptr, "Wrap"},
+    {0x00470104, nullptr, "Unwrap"},
+    {0x00480100, nullptr, "GetProgramInfo"},
+    {0x00490180, nullptr, "Reboot"},
+    {0x004A0040, nullptr, "GetCaptureInfo"},
+    {0x004B00C2, AppletUtility, "AppletUtility"},
+    {0x004C0000, nullptr, "SetFatalErrDispMode"},
+    {0x004D0080, nullptr, "GetAppletProgramInfo"},
+    {0x004E0000, nullptr, "HardwareResetAsync"},
+    {0x004F0080, SetAppCpuTimeLimit, "SetAppCpuTimeLimit"},
+    {0x00500040, GetAppCpuTimeLimit, "GetAppCpuTimeLimit"},
+    {0x00510080, GetStartupArgument, "GetStartupArgument"},
+    {0x00520104, nullptr, "Wrap1"},
+    {0x00530104, nullptr, "Unwrap1"},
+    {0x00550040, SetScreenCapPostPermission, "SetScreenCapPostPermission"},
+    {0x00560000, GetScreenCapPostPermission, "GetScreenCapPostPermission"},
+    {0x00580002, nullptr, "GetProgramID"},
+    {0x01010000, CheckNew3DSApp, "CheckNew3DSApp"},
+    {0x01020000, CheckNew3DS, "CheckNew3DS"},
 };
 
 APT_U_Interface::APT_U_Interface() {
diff --git a/src/core/hle/service/apt/bcfnt/bcfnt.h b/src/core/hle/service/apt/bcfnt/bcfnt.h
index 8936dcf63..453bf7606 100644
--- a/src/core/hle/service/apt/bcfnt/bcfnt.h
+++ b/src/core/hle/service/apt/bcfnt/bcfnt.h
@@ -5,7 +5,6 @@
 #pragma once
 
 #include "common/swap.h"
-
 #include "core/hle/kernel/shared_memory.h"
 #include "core/hle/service/service.h"
 
diff --git a/src/core/hle/service/boss/boss.cpp b/src/core/hle/service/boss/boss.cpp
index 419ec976e..757a8c2c7 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 {
@@ -17,8 +17,7 @@ void Init() {
     AddService(new BOSS_U_Interface);
 }
 
-void Shutdown() {
-}
+void Shutdown() {}
 
 } // 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"},
-    {0x000C0082, nullptr,               "UnregisterTask"},
-    {0x001E0042, nullptr,               "CancelTask"},
-    {0x00330042, nullptr,               "StartBgImmediate"},
+    {0x00020100, nullptr, "GetStorageInfo"},
+    {0x000C0082, nullptr, "UnregisterTask"},
+    {0x001E0042, nullptr, "CancelTask"},
+    {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..5594aedab 100644
--- a/src/core/hle/service/cam/cam.cpp
+++ b/src/core/hle/service/cam/cam.cpp
@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include "common/logging/log.h"
-
 #include "core/hle/kernel/event.h"
 #include "core/hle/service/cam/cam.h"
 #include "core/hle/service/cam/cam_c.h"
@@ -71,15 +70,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];
-    u8 port        = cmd_buff[2] & 0xFF;
+    VAddr dest = cmd_buff[1];
+    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 ?
-            completion_event_cam2.get() : completion_event_cam1.get();
+    Kernel::Event* completion_event =
+        (Port)port == Port::Cam2 ? completion_event_cam2.get() : completion_event_cam1.get();
 
     completion_event->Signal();
 
@@ -89,36 +88,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 height         = cmd_buff[4] & 0xFFFF;
+    u16 width = cmd_buff[3] & 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",
-            port, transfer_lines, width, height);
+    LOG_WARNING(Service_CAM, "(STUBBED) called, port=%d, lines=%d, width=%d, height=%d", port,
+                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",
-            width, height, cmd_buff[2]);
+    LOG_WARNING(Service_CAM, "(STUBBED) called, width=%d, height=%d, lines = %d", width, height,
+                cmd_buff[2]);
 }
 
 void GetTransferBytes(Service::Interface* self) {
@@ -136,7 +135,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 +147,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 camH  = cmd_buff[5] & 0xFFFF;
+    s16 camW = cmd_buff[4] & 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 +168,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",
-            cam_select);
+    LOG_WARNING(Service_CAM, "(STUBBED) called, cam_select=%d", 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 context    = cmd_buff[3] & 0xFF;
+    u8 flip = cmd_buff[2] & 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",
-            cam_select, flip, context);
+    LOG_WARNING(Service_CAM, "(STUBBED) called, cam_select=%d, flip=%d, context=%d", cam_select,
+                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 context    = cmd_buff[3] & 0xFF;
+    u8 size = cmd_buff[2] & 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",
-            cam_select, size, context);
+    LOG_WARNING(Service_CAM, "(STUBBED) called, cam_select=%d, size=%d, context=%d", cam_select,
+                size, context);
 }
 
 void SetFrameRate(Service::Interface* self) {
@@ -210,8 +208,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",
-            cam_select, frame_rate);
+    LOG_WARNING(Service_CAM, "(STUBBED) called, cam_select=%d, frame_rate=%d", cam_select,
+                frame_rate);
 }
 
 void GetStereoCameraCalibrationData(Service::Interface* self) {
@@ -293,10 +291,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_cam2 = 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");
+    completion_event_cam1 =
+        Kernel::Event::Create(ResetType::OneShot, "CAM_U::completion_event_cam1");
+    completion_event_cam2 =
+        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..c9b6f8acf 100644
--- a/src/core/hle/service/cam/cam.h
+++ b/src/core/hle/service/cam/cam.h
@@ -7,19 +7,13 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
-
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/service/service.h"
 
 namespace Service {
 namespace CAM {
 
-enum class Port : u8 {
-    None = 0,
-    Cam1 = 1,
-    Cam2 = 2,
-    Both = Cam1 | Cam2
-};
+enum class Port : u8 { None = 0, Cam1 = 1, Cam2 = 2, Both = Cam1 | Cam2 };
 
 enum class CameraSelect : u8 {
     None = 0,
@@ -29,7 +23,7 @@ enum class CameraSelect : u8 {
     In1Out1 = Out1 | In1,
     Out1Out2 = Out1 | Out2,
     In1Out2 = In1 | Out2,
-    All = Out1 | In1 | Out2
+    All = Out1 | In1 | Out2,
 };
 
 enum class Effect : u8 {
@@ -38,21 +32,21 @@ enum class Effect : u8 {
     Sepia = 2,
     Negative = 3,
     Negafilm = 4,
-    Sepia01 = 5
+    Sepia01 = 5,
 };
 
 enum class Context : u8 {
     None = 0,
     A = 1,
     B = 2,
-    Both = A | B
+    Both = A | B,
 };
 
 enum class Flip : u8 {
     None = 0,
     Horizontal = 1,
     Vertical = 2,
-    Reverse = 3
+    Reverse = 3,
 };
 
 enum class Size : u8 {
@@ -64,7 +58,7 @@ enum class Size : u8 {
     DS_LCD = 5,
     DS_LCDx4 = 6,
     CTR_TOP_LCD = 7,
-    CTR_BOTTOM_LCD = QVGA
+    CTR_BOTTOM_LCD = QVGA,
 };
 
 enum class FrameRate : u8 {
@@ -80,13 +74,13 @@ enum class FrameRate : u8 {
     Rate_30_To_5 = 9,
     Rate_15_To_10 = 10,
     Rate_20_To_10 = 11,
-    Rate_30_To_10 = 12
+    Rate_30_To_10 = 12,
 };
 
 enum class ShutterSoundType : u8 {
     Normal = 0,
     Movie = 1,
-    MovieEnd = 2
+    MovieEnd = 2,
 };
 
 enum class WhiteBalance : u8 {
@@ -103,7 +97,7 @@ enum class WhiteBalance : u8 {
     BalanceDaylight = Balance5200K,
     BalanceCloudy = Balance6000K,
     BalanceHorizon = Balance6000K,
-    BalanceShade = Balance7000K
+    BalanceShade = Balance7000K,
 };
 
 enum class PhotoMode : u8 {
@@ -111,7 +105,7 @@ enum class PhotoMode : u8 {
     Portrait = 1,
     Landscape = 2,
     Nightview = 3,
-    Letter0 = 4
+    Letter0 = 4,
 };
 
 enum class LensCorrection : u8 {
@@ -120,7 +114,7 @@ enum class LensCorrection : u8 {
     On90 = 2,
     Dark = Off,
     Normal = On70,
-    Bright = On90
+    Bright = On90,
 };
 
 enum class Contrast : u8 {
@@ -137,24 +131,24 @@ enum class Contrast : u8 {
     Pattern11 = 11,
     Low = Pattern05,
     Normal = Pattern06,
-    High = Pattern07
+    High = Pattern07,
 };
 
 enum class OutputFormat : u8 {
     YUV422 = 0,
-    RGB565 = 1
+    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 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 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 rotationY;        ///< Y axis rotation 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 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 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 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 +157,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 +183,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"},
-    {0x00020040, StopCapture,                         "StopCapture"},
-    {0x00030040, nullptr,                             "IsBusy"},
-    {0x00040040, nullptr,                             "ClearBuffer"},
-    {0x00050040, GetVsyncInterruptEvent,              "GetVsyncInterruptEvent"},
-    {0x00060040, GetBufferErrorInterruptEvent,        "GetBufferErrorInterruptEvent"},
-    {0x00070102, SetReceiving,                        "SetReceiving"},
-    {0x00080040, nullptr,                             "IsFinishedReceiving"},
-    {0x00090100, SetTransferLines,                    "SetTransferLines"},
-    {0x000A0080, GetMaxLines,                         "GetMaxLines"},
-    {0x000B0100, nullptr,                             "SetTransferBytes"},
-    {0x000C0040, GetTransferBytes,                    "GetTransferBytes"},
-    {0x000D0080, nullptr,                             "GetMaxBytes"},
-    {0x000E0080, SetTrimming,                         "SetTrimming"},
-    {0x000F0040, nullptr,                             "IsTrimming"},
-    {0x00100140, nullptr,                             "SetTrimmingParams"},
-    {0x00110040, nullptr,                             "GetTrimmingParams"},
-    {0x00120140, SetTrimmingParamsCenter,             "SetTrimmingParamsCenter"},
-    {0x00130040, Activate,                            "Activate"},
-    {0x00140080, nullptr,                             "SwitchContext"},
-    {0x00150080, nullptr,                             "SetExposure"},
-    {0x00160080, nullptr,                             "SetWhiteBalance"},
-    {0x00170080, nullptr,                             "SetWhiteBalanceWithoutBaseUp"},
-    {0x00180080, nullptr,                             "SetSharpness"},
-    {0x00190080, nullptr,                             "SetAutoExposure"},
-    {0x001A0040, nullptr,                             "IsAutoExposure"},
-    {0x001B0080, nullptr,                             "SetAutoWhiteBalance"},
-    {0x001C0040, nullptr,                             "IsAutoWhiteBalance"},
-    {0x001D00C0, FlipImage,                           "FlipImage"},
-    {0x001E0200, nullptr,                             "SetDetailSize"},
-    {0x001F00C0, SetSize,                             "SetSize"},
-    {0x00200080, SetFrameRate,                        "SetFrameRate"},
-    {0x00210080, nullptr,                             "SetPhotoMode"},
-    {0x002200C0, nullptr,                             "SetEffect"},
-    {0x00230080, nullptr,                             "SetContrast"},
-    {0x00240080, nullptr,                             "SetLensCorrection"},
-    {0x002500C0, nullptr,                             "SetOutputFormat"},
-    {0x00260140, nullptr,                             "SetAutoExposureWindow"},
-    {0x00270140, nullptr,                             "SetAutoWhiteBalanceWindow"},
-    {0x00280080, nullptr,                             "SetNoiseFilter"},
-    {0x00290080, nullptr,                             "SynchronizeVsyncTiming"},
-    {0x002A0080, nullptr,                             "GetLatestVsyncTiming"},
-    {0x002B0000, GetStereoCameraCalibrationData,      "GetStereoCameraCalibrationData"},
-    {0x002C0400, nullptr,                             "SetStereoCameraCalibrationData"},
-    {0x002D00C0, nullptr,                             "WriteRegisterI2c"},
-    {0x002E00C0, nullptr,                             "WriteMcuVariableI2c"},
-    {0x002F0080, nullptr,                             "ReadRegisterI2cExclusive"},
-    {0x00300080, nullptr,                             "ReadMcuVariableI2cExclusive"},
-    {0x00310180, nullptr,                             "SetImageQualityCalibrationData"},
-    {0x00320000, nullptr,                             "GetImageQualityCalibrationData"},
-    {0x003302C0, nullptr,                             "SetPackageParameterWithoutContext"},
-    {0x00340140, nullptr,                             "SetPackageParameterWithContext"},
-    {0x003501C0, nullptr,                             "SetPackageParameterWithContextDetail"},
-    {0x00360000, GetSuitableY2rStandardCoefficient,   "GetSuitableY2rStandardCoefficient"},
-    {0x00370202, nullptr,                             "PlayShutterSoundWithWave"},
-    {0x00380040, PlayShutterSound,                    "PlayShutterSound"},
-    {0x00390000, DriverInitialize,                    "DriverInitialize"},
-    {0x003A0000, DriverFinalize,                      "DriverFinalize"},
-    {0x003B0000, nullptr,                             "GetActivatedCamera"},
-    {0x003C0000, nullptr,                             "GetSleepCamera"},
-    {0x003D0040, nullptr,                             "SetSleepCamera"},
-    {0x003E0040, nullptr,                             "SetBrightnessSynchronization"},
+    {0x00010040, StartCapture, "StartCapture"},
+    {0x00020040, StopCapture, "StopCapture"},
+    {0x00030040, nullptr, "IsBusy"},
+    {0x00040040, nullptr, "ClearBuffer"},
+    {0x00050040, GetVsyncInterruptEvent, "GetVsyncInterruptEvent"},
+    {0x00060040, GetBufferErrorInterruptEvent, "GetBufferErrorInterruptEvent"},
+    {0x00070102, SetReceiving, "SetReceiving"},
+    {0x00080040, nullptr, "IsFinishedReceiving"},
+    {0x00090100, SetTransferLines, "SetTransferLines"},
+    {0x000A0080, GetMaxLines, "GetMaxLines"},
+    {0x000B0100, nullptr, "SetTransferBytes"},
+    {0x000C0040, GetTransferBytes, "GetTransferBytes"},
+    {0x000D0080, nullptr, "GetMaxBytes"},
+    {0x000E0080, SetTrimming, "SetTrimming"},
+    {0x000F0040, nullptr, "IsTrimming"},
+    {0x00100140, nullptr, "SetTrimmingParams"},
+    {0x00110040, nullptr, "GetTrimmingParams"},
+    {0x00120140, SetTrimmingParamsCenter, "SetTrimmingParamsCenter"},
+    {0x00130040, Activate, "Activate"},
+    {0x00140080, nullptr, "SwitchContext"},
+    {0x00150080, nullptr, "SetExposure"},
+    {0x00160080, nullptr, "SetWhiteBalance"},
+    {0x00170080, nullptr, "SetWhiteBalanceWithoutBaseUp"},
+    {0x00180080, nullptr, "SetSharpness"},
+    {0x00190080, nullptr, "SetAutoExposure"},
+    {0x001A0040, nullptr, "IsAutoExposure"},
+    {0x001B0080, nullptr, "SetAutoWhiteBalance"},
+    {0x001C0040, nullptr, "IsAutoWhiteBalance"},
+    {0x001D00C0, FlipImage, "FlipImage"},
+    {0x001E0200, nullptr, "SetDetailSize"},
+    {0x001F00C0, SetSize, "SetSize"},
+    {0x00200080, SetFrameRate, "SetFrameRate"},
+    {0x00210080, nullptr, "SetPhotoMode"},
+    {0x002200C0, nullptr, "SetEffect"},
+    {0x00230080, nullptr, "SetContrast"},
+    {0x00240080, nullptr, "SetLensCorrection"},
+    {0x002500C0, nullptr, "SetOutputFormat"},
+    {0x00260140, nullptr, "SetAutoExposureWindow"},
+    {0x00270140, nullptr, "SetAutoWhiteBalanceWindow"},
+    {0x00280080, nullptr, "SetNoiseFilter"},
+    {0x00290080, nullptr, "SynchronizeVsyncTiming"},
+    {0x002A0080, nullptr, "GetLatestVsyncTiming"},
+    {0x002B0000, GetStereoCameraCalibrationData, "GetStereoCameraCalibrationData"},
+    {0x002C0400, nullptr, "SetStereoCameraCalibrationData"},
+    {0x002D00C0, nullptr, "WriteRegisterI2c"},
+    {0x002E00C0, nullptr, "WriteMcuVariableI2c"},
+    {0x002F0080, nullptr, "ReadRegisterI2cExclusive"},
+    {0x00300080, nullptr, "ReadMcuVariableI2cExclusive"},
+    {0x00310180, nullptr, "SetImageQualityCalibrationData"},
+    {0x00320000, nullptr, "GetImageQualityCalibrationData"},
+    {0x003302C0, nullptr, "SetPackageParameterWithoutContext"},
+    {0x00340140, nullptr, "SetPackageParameterWithContext"},
+    {0x003501C0, nullptr, "SetPackageParameterWithContextDetail"},
+    {0x00360000, GetSuitableY2rStandardCoefficient, "GetSuitableY2rStandardCoefficient"},
+    {0x00370202, nullptr, "PlayShutterSoundWithWave"},
+    {0x00380040, PlayShutterSound, "PlayShutterSound"},
+    {0x00390000, DriverInitialize, "DriverInitialize"},
+    {0x003A0000, DriverFinalize, "DriverFinalize"},
+    {0x003B0000, nullptr, "GetActivatedCamera"},
+    {0x003C0000, nullptr, "GetSleepCamera"},
+    {0x003D0040, nullptr, "SetSleepCamera"},
+    {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..515b344e6 100644
--- a/src/core/hle/service/cecd/cecd.cpp
+++ b/src/core/hle/service/cecd/cecd.cpp
@@ -3,12 +3,11 @@
 // Refer to the license.txt file included.
 
 #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 +27,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 +36,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 +47,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_WLREADY   = 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
+    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_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"},
-    {0x000F0000, GetCecInfoEventHandle,     "GetCecInfoEventHandle"},
+    {0x000E0000, GetCecStateAbbreviated, "GetCecStateAbbreviated"},
+    {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..24eee6903 100644
--- a/src/core/hle/service/cfg/cfg.cpp
+++ b/src/core/hle/service/cfg/cfg.cpp
@@ -3,15 +3,12 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
 #include "common/swap.h"
-
 #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 +16,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 +31,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 data_entries_offset;                  ///< The offset where the data for the blocks start, this is hardcoded to 0x455C as per 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
+    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
+    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,
-    ConsoleUniqueIDBlockID      = 0x00090001,
-    UsernameBlockID             = 0x000A0000,
-    BirthdayBlockID             = 0x000A0001,
-    LanguageBlockID             = 0x000A0002,
-    CountryInfoBlockID          = 0x000B0000,
-    CountryNameBlockID          = 0x000B0001,
-    StateNameBlockID            = 0x000B0002,
-    EULAVersionBlockID          = 0x000D0000,
-    ConsoleModelBlockID         = 0x000F0004,
+    SoundOutputModeBlockID = 0x00070001,
+    ConsoleUniqueIDBlockID = 0x00090001,
+    UsernameBlockID = 0x000A0000,
+    BirthdayBlockID = 0x000A0001,
+    LanguageBlockID = 0x000A0002,
+    CountryInfoBlockID = 0x000B0000,
+    CountryNameBlockID = 0x000B0001,
+    StateNameBlockID = 0x000B0002,
+    EULAVersionBlockID = 0x000D0000,
+    ConsoleModelBlockID = 0x000F0004,
 };
 
 struct UsernameBlock {
@@ -68,8 +70,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 unknown[3];  ///< Unknown data
+    u8 model;      ///< The console model (3DS, 2DS, etc)
+    u8 unknown[3]; ///< Unknown data
 };
 static_assert(sizeof(ConsoleModelInfo) == 4, "ConsoleModelInfo must be exactly 4 bytes");
 
@@ -78,36 +80,38 @@ 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 BirthdayBlock PROFILE_BIRTHDAY = { 3, 25 }; // March 25th, 2014
+static const UsernameBlock CONSOLE_USERNAME_BLOCK = {u"CITRA", 0, 0};
+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,
-    10.0f, 5.0f, 55.58000183105469f, 21.56999969482422f
-}};
-static_assert(sizeof(STEREO_CAMERA_SETTINGS) == 0x20, "STEREO_CAMERA_SETTINGS must be exactly 0x20 bytes");
+    10.0f, 5.0f,   55.58000183105469f, 21.56999969482422f,
+};
+static_assert(sizeof(STEREO_CAMERA_SETTINGS) == 0x20,
+              "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);
-        cmd_buff[1] = ResultCode(ErrorDescription::NotFound, ErrorModule::Config, ErrorSummary::WrongArgument, ErrorLevel::Permanent).raw;
+        LOG_ERROR(Service_CFG, "requested country code name=%c%c is invalid", country_code & 0xff,
+                  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,
-                                                   reinterpret_cast<u8*>(&data)).raw;
+    cmd_buff[1] =
+        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,
-                                                   reinterpret_cast<u8*>(&data)).raw;
+    cmd_buff[1] =
+        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),
-        [&](const SaveConfigBlockEntry& entry) {
-            return entry.block_id == block_id;
-        });
+    auto itr =
+        std::find_if(std::begin(config->block_entries), std::end(config->block_entries),
+                     [&](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);
-        return ResultCode(ErrorDescription::NotFound, ErrorModule::Config, ErrorSummary::WrongArgument, ErrorLevel::Permanent);
+        LOG_ERROR(Service_CFG, "Config block 0x%X with flags %u and size %u was not found",
+                  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);
-        return ResultCode(ErrorDescription::NotAuthorized, ErrorModule::Config, ErrorSummary::WrongArgument, ErrorLevel::Permanent);
+        LOG_ERROR(Service_CFG, "Invalid flag %u for config block 0x%X with size %u", flag, block_id,
+                  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);
-        return ResultCode(ErrorDescription::InvalidSize, ErrorModule::Config, ErrorSummary::WrongArgument, ErrorLevel::Permanent);
+        LOG_ERROR(Service_CFG, "Invalid size %u for config block 0x%X with flags %u", size,
+                  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 +
-                         config->block_entries[i].size;
+                offset = config->block_entries[i].offset_or_data + 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());
-    if (!res.IsSuccess()) return res;
+    res = CreateConfigInfoBlk(StereoCameraSettingsBlockID, sizeof(STEREO_CAMERA_SETTINGS), 0xE,
+                              STEREO_CAMERA_SETTINGS.data());
+    if (!res.IsSuccess())
+        return res;
 
-    res = CreateConfigInfoBlk(SoundOutputModeBlockID, sizeof(SOUND_OUTPUT_MODE), 0xE, &SOUND_OUTPUT_MODE);
-    if (!res.IsSuccess()) return res;
+    res = CreateConfigInfoBlk(SoundOutputModeBlockID, sizeof(SOUND_OUTPUT_MODE), 0xE,
+                              &SOUND_OUTPUT_MODE);
+    if (!res.IsSuccess())
+        return res;
 
-    res = CreateConfigInfoBlk(ConsoleUniqueIDBlockID, sizeof(CONSOLE_UNIQUE_ID), 0xE, &CONSOLE_UNIQUE_ID);
-    if (!res.IsSuccess()) return res;
+    res = CreateConfigInfoBlk(ConsoleUniqueIDBlockID, sizeof(CONSOLE_UNIQUE_ID), 0xE,
+                              &CONSOLE_UNIQUE_ID);
+    if (!res.IsSuccess())
+        return res;
 
-    res = CreateConfigInfoBlk(UsernameBlockID, sizeof(CONSOLE_USERNAME_BLOCK), 0xE, &CONSOLE_USERNAME_BLOCK);
-    if (!res.IsSuccess()) return res;
+    res = CreateConfigInfoBlk(UsernameBlockID, sizeof(CONSOLE_USERNAME_BLOCK), 0xE,
+                              &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);
-    if (!res.IsSuccess()) return res;
+    res = CreateConfigInfoBlk(CountryNameBlockID, sizeof(country_name_buffer), 0xE,
+                              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);
-    if (!res.IsSuccess()) return res;
+    res = CreateConfigInfoBlk(StateNameBlockID, sizeof(country_name_buffer), 0xE,
+                              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!");
@@ -491,8 +528,7 @@ void Init() {
     LoadConfigNANDSaveFile();
 }
 
-void Shutdown() {
-}
+void Shutdown() {}
 
 void SetUsername(const std::u16string& name) {
     ASSERT(name.size() <= 10);
@@ -515,7 +551,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..fb47c2aa5 100644
--- a/src/core/hle/service/cfg/cfg.h
+++ b/src/core/hle/service/cfg/cfg.h
@@ -6,7 +6,6 @@
 
 #include <array>
 #include <string>
-
 #include "common/common_types.h"
 
 union ResultCode;
@@ -40,16 +39,13 @@ enum SystemLanguage {
     LANGUAGE_TW = 11
 };
 
-enum SoundOutputMode {
-    SOUND_MONO = 0,
-    SOUND_STEREO = 1,
-    SOUND_SURROUND = 2
-};
+enum SoundOutputMode { 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
 };
@@ -82,7 +78,7 @@ static const std::array<u16, 187> country_codes = {{
     C("CN"), 0,       0,       0,       0,       0,       0,       0,       // 160-167
     C("AE"), C("IN"), C("EG"), C("OM"), C("QA"), C("KW"), C("SA"), C("SY"), // 168-175
     C("BH"), C("JO"), 0,       0,       0,       0,       0,       0,       // 176-183
-    C("SM"), C("VA"), C("BM")                                               // 184-186
+    C("SM"), C("VA"), C("BM"),                                              // 184-186
 }};
 
 /**
@@ -221,8 +217,9 @@ void FormatConfig(Service::Interface* self);
 
 /**
  * Reads a block with the specified id and flag from the Config savegame buffer
- * and writes the output to output.
- * The input size must match exactly the size of the requested block
+ * and writes the output to output. The input size must match exactly the size of the requested
+ * block.
+ *
  * @param block_id The id of the block we want to read
  * @param size The size of the block we want to read
  * @param flag The requested block must have this flag set
@@ -233,8 +230,8 @@ ResultCode GetConfigInfoBlock(u32 block_id, u32 size, u32 flag, void* output);
 
 /**
  * Reads data from input and writes to a block with the specified id and flag
- * in the Config savegame buffer.
- * The input size must match exactly the size of the target block
+ * in the Config savegame buffer. The input size must match exactly the size of the target block.
+ *
  * @param block_id The id of the block we want to write
  * @param size The size of the block we want to write
  * @param flag The target block must have this flag set
@@ -244,8 +241,9 @@ 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.
- * The config savegame file in the filesystem is not updated.
+ * 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
  * @param flags The flags of the new block
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"},
-    {0x00020000, SecureInfoGetRegion,                  "SecureInfoGetRegion"},
-    {0x00030040, GenHashConsoleUnique,                 "GenHashConsoleUnique"},
-    {0x00040000, GetRegionCanadaUSA,                   "GetRegionCanadaUSA"},
-    {0x00050000, GetSystemModel,                       "GetSystemModel"},
-    {0x00060000, GetModelNintendo2DS,                  "GetModelNintendo2DS"},
-    {0x00070040, nullptr,                              "WriteToFirstByteCfgSavegame"},
-    {0x00080080, nullptr,                              "GoThroughTable"},
-    {0x00090040, GetCountryCodeString,                 "GetCountryCodeString"},
-    {0x000A0040, GetCountryCodeID,                     "GetCountryCodeID"},
+    {0x00010082, GetConfigInfoBlk2, "GetConfigInfoBlk2"},
+    {0x00020000, SecureInfoGetRegion, "SecureInfoGetRegion"},
+    {0x00030040, GenHashConsoleUnique, "GenHashConsoleUnique"},
+    {0x00040000, GetRegionCanadaUSA, "GetRegionCanadaUSA"},
+    {0x00050000, GetSystemModel, "GetSystemModel"},
+    {0x00060000, GetModelNintendo2DS, "GetModelNintendo2DS"},
+    {0x00070040, nullptr, "WriteToFirstByteCfgSavegame"},
+    {0x00080080, nullptr, "GoThroughTable"},
+    {0x00090040, GetCountryCodeString, "GetCountryCodeString"},
+    {0x000A0040, GetCountryCodeID, "GetCountryCodeID"},
     // cfg:i
-    {0x04010082, GetConfigInfoBlk8,                    "GetConfigInfoBlk8"},
-    {0x04020082, SetConfigInfoBlk4,                    "SetConfigInfoBlk4"},
-    {0x04030000, UpdateConfigNANDSavegame,             "UpdateConfigNANDSavegame"},
-    {0x04040042, nullptr,                              "GetLocalFriendCodeSeedData"},
-    {0x04050000, nullptr,                              "GetLocalFriendCodeSeed"},
-    {0x04060000, SecureInfoGetRegion,                  "SecureInfoGetRegion"},
-    {0x04070000, nullptr,                              "SecureInfoGetByte101"},
-    {0x04080042, nullptr,                              "SecureInfoGetSerialNo"},
-    {0x04090000, nullptr,                              "UpdateConfigBlk00040003"},
-    {0x08010082, GetConfigInfoBlk8,                    "GetConfigInfoBlk8"},
-    {0x08020082, SetConfigInfoBlk4,                    "SetConfigInfoBlk4"},
-    {0x08030000, UpdateConfigNANDSavegame,             "UpdateConfigNANDSavegame"},
-    {0x080400C2, nullptr,                              "CreateConfigInfoBlk"},
-    {0x08050000, nullptr,                              "DeleteConfigNANDSavefile"},
-    {0x08060000, FormatConfig,                         "FormatConfig"},
-    {0x08080000, nullptr,                              "UpdateConfigBlk1"},
-    {0x08090000, nullptr,                              "UpdateConfigBlk2"},
-    {0x080A0000, nullptr,                              "UpdateConfigBlk3"},
-    {0x080B0082, nullptr,                              "SetGetLocalFriendCodeSeedData"},
-    {0x080C0042, nullptr,                              "SetLocalFriendCodeSeedSignature"},
-    {0x080D0000, nullptr,                              "DeleteCreateNANDLocalFriendCodeSeed"},
-    {0x080E0000, nullptr,                              "VerifySigLocalFriendCodeSeed"},
-    {0x080F0042, nullptr,                              "GetLocalFriendCodeSeedData"},
-    {0x08100000, nullptr,                              "GetLocalFriendCodeSeed"},
-    {0x08110084, nullptr,                              "SetSecureInfo"},
-    {0x08120000, nullptr,                              "DeleteCreateNANDSecureInfo"},
-    {0x08130000, nullptr,                              "VerifySigSecureInfo"},
-    {0x08140042, nullptr,                              "SecureInfoGetData"},
-    {0x08150042, nullptr,                              "SecureInfoGetSignature"},
-    {0x08160000, SecureInfoGetRegion,                  "SecureInfoGetRegion"},
-    {0x08170000, nullptr,                              "SecureInfoGetByte101"},
-    {0x08180042, nullptr,                              "SecureInfoGetSerialNo"},
+    {0x04010082, GetConfigInfoBlk8, "GetConfigInfoBlk8"},
+    {0x04020082, SetConfigInfoBlk4, "SetConfigInfoBlk4"},
+    {0x04030000, UpdateConfigNANDSavegame, "UpdateConfigNANDSavegame"},
+    {0x04040042, nullptr, "GetLocalFriendCodeSeedData"},
+    {0x04050000, nullptr, "GetLocalFriendCodeSeed"},
+    {0x04060000, SecureInfoGetRegion, "SecureInfoGetRegion"},
+    {0x04070000, nullptr, "SecureInfoGetByte101"},
+    {0x04080042, nullptr, "SecureInfoGetSerialNo"},
+    {0x04090000, nullptr, "UpdateConfigBlk00040003"},
+    {0x08010082, GetConfigInfoBlk8, "GetConfigInfoBlk8"},
+    {0x08020082, SetConfigInfoBlk4, "SetConfigInfoBlk4"},
+    {0x08030000, UpdateConfigNANDSavegame, "UpdateConfigNANDSavegame"},
+    {0x080400C2, nullptr, "CreateConfigInfoBlk"},
+    {0x08050000, nullptr, "DeleteConfigNANDSavefile"},
+    {0x08060000, FormatConfig, "FormatConfig"},
+    {0x08080000, nullptr, "UpdateConfigBlk1"},
+    {0x08090000, nullptr, "UpdateConfigBlk2"},
+    {0x080A0000, nullptr, "UpdateConfigBlk3"},
+    {0x080B0082, nullptr, "SetGetLocalFriendCodeSeedData"},
+    {0x080C0042, nullptr, "SetLocalFriendCodeSeedSignature"},
+    {0x080D0000, nullptr, "DeleteCreateNANDLocalFriendCodeSeed"},
+    {0x080E0000, nullptr, "VerifySigLocalFriendCodeSeed"},
+    {0x080F0042, nullptr, "GetLocalFriendCodeSeedData"},
+    {0x08100000, nullptr, "GetLocalFriendCodeSeed"},
+    {0x08110084, nullptr, "SetSecureInfo"},
+    {0x08120000, nullptr, "DeleteCreateNANDSecureInfo"},
+    {0x08130000, nullptr, "VerifySigSecureInfo"},
+    {0x08140042, nullptr, "SecureInfoGetData"},
+    {0x08150042, nullptr, "SecureInfoGetSignature"},
+    {0x08160000, SecureInfoGetRegion, "SecureInfoGetRegion"},
+    {0x08170000, nullptr, "SecureInfoGetByte101"},
+    {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"},
-    {0x00020000, SecureInfoGetRegion,                  "SecureInfoGetRegion"},
-    {0x00030040, GenHashConsoleUnique,                 "GenHashConsoleUnique"},
-    {0x00040000, GetRegionCanadaUSA,                   "GetRegionCanadaUSA"},
-    {0x00050000, GetSystemModel,                       "GetSystemModel"},
-    {0x00060000, GetModelNintendo2DS,                  "GetModelNintendo2DS"},
-    {0x00070040, nullptr,                              "WriteToFirstByteCfgSavegame"},
-    {0x00080080, nullptr,                              "GoThroughTable"},
-    {0x00090040, GetCountryCodeString,                 "GetCountryCodeString"},
-    {0x000A0040, GetCountryCodeID,                     "GetCountryCodeID"},
+    {0x00010082, GetConfigInfoBlk2, "GetConfigInfoBlk2"},
+    {0x00020000, SecureInfoGetRegion, "SecureInfoGetRegion"},
+    {0x00030040, GenHashConsoleUnique, "GenHashConsoleUnique"},
+    {0x00040000, GetRegionCanadaUSA, "GetRegionCanadaUSA"},
+    {0x00050000, GetSystemModel, "GetSystemModel"},
+    {0x00060000, GetModelNintendo2DS, "GetModelNintendo2DS"},
+    {0x00070040, nullptr, "WriteToFirstByteCfgSavegame"},
+    {0x00080080, nullptr, "GoThroughTable"},
+    {0x00090040, GetCountryCodeString, "GetCountryCodeString"},
+    {0x000A0040, GetCountryCodeID, "GetCountryCodeID"},
     // cfg:s
-    {0x04010082, GetConfigInfoBlk8,                    "GetConfigInfoBlk8"},
-    {0x04020082, SetConfigInfoBlk4,                    "SetConfigInfoBlk4"},
-    {0x04030000, UpdateConfigNANDSavegame,             "UpdateConfigNANDSavegame"},
-    {0x04040042, nullptr,                              "GetLocalFriendCodeSeedData"},
-    {0x04050000, nullptr,                              "GetLocalFriendCodeSeed"},
-    {0x04060000, nullptr,                              "SecureInfoGetRegion"},
-    {0x04070000, nullptr,                              "SecureInfoGetByte101"},
-    {0x04080042, nullptr,                              "SecureInfoGetSerialNo"},
-    {0x04090000, nullptr,                              "UpdateConfigBlk00040003"},
+    {0x04010082, GetConfigInfoBlk8, "GetConfigInfoBlk8"},
+    {0x04020082, SetConfigInfoBlk4, "SetConfigInfoBlk4"},
+    {0x04030000, UpdateConfigNANDSavegame, "UpdateConfigNANDSavegame"},
+    {0x04040042, nullptr, "GetLocalFriendCodeSeedData"},
+    {0x04050000, nullptr, "GetLocalFriendCodeSeed"},
+    {0x04060000, nullptr, "SecureInfoGetRegion"},
+    {0x04070000, nullptr, "SecureInfoGetByte101"},
+    {0x04080042, nullptr, "SecureInfoGetSerialNo"},
+    {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"},
-    {0x00020000, SecureInfoGetRegion,   "SecureInfoGetRegion"},
-    {0x00030040, GenHashConsoleUnique,  "GenHashConsoleUnique"},
-    {0x00040000, GetRegionCanadaUSA,    "GetRegionCanadaUSA"},
-    {0x00050000, GetSystemModel,        "GetSystemModel"},
-    {0x00060000, GetModelNintendo2DS,   "GetModelNintendo2DS"},
-    {0x00070040, nullptr,               "WriteToFirstByteCfgSavegame"},
-    {0x00080080, nullptr,               "GoThroughTable"},
-    {0x00090040, GetCountryCodeString,  "GetCountryCodeString"},
-    {0x000A0040, GetCountryCodeID,      "GetCountryCodeID"},
+    {0x00010082, GetConfigInfoBlk2, "GetConfigInfoBlk2"},
+    {0x00020000, SecureInfoGetRegion, "SecureInfoGetRegion"},
+    {0x00030040, GenHashConsoleUnique, "GenHashConsoleUnique"},
+    {0x00040000, GetRegionCanadaUSA, "GetRegionCanadaUSA"},
+    {0x00050000, GetSystemModel, "GetSystemModel"},
+    {0x00060000, GetModelNintendo2DS, "GetModelNintendo2DS"},
+    {0x00070040, nullptr, "WriteToFirstByteCfgSavegame"},
+    {0x00080080, nullptr, "GoThroughTable"},
+    {0x00090040, GetCountryCodeString, "GetCountryCodeString"},
+    {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..20c759ad7 100644
--- a/src/core/hle/service/csnd_snd.cpp
+++ b/src/core/hle/service/csnd_snd.cpp
@@ -15,18 +15,18 @@
 namespace CSND_SND {
 
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010140, Initialize,            "Initialize"},
-    {0x00020000, Shutdown,              "Shutdown"},
-    {0x00030040, ExecuteType0Commands,  "ExecuteType0Commands"},
-    {0x00040080, nullptr,               "ExecuteType1Commands"},
-    {0x00050000, AcquireSoundChannels,  "AcquireSoundChannels"},
-    {0x00060000, nullptr,               "ReleaseSoundChannels"},
-    {0x00070000, nullptr,               "AcquireCaptureDevice"},
-    {0x00080040, nullptr,               "ReleaseCaptureDevice"},
-    {0x00090082, nullptr,               "FlushDataCache"},
-    {0x000A0082, nullptr,               "StoreDataCache"},
-    {0x000B0082, nullptr,               "InvalidateDataCache"},
-    {0x000C0000, nullptr,               "Reset"},
+    {0x00010140, Initialize, "Initialize"},
+    {0x00020000, Shutdown, "Shutdown"},
+    {0x00030040, ExecuteType0Commands, "ExecuteType0Commands"},
+    {0x00040080, nullptr, "ExecuteType1Commands"},
+    {0x00050000, AcquireSoundChannels, "AcquireSoundChannels"},
+    {0x00060000, nullptr, "ReleaseSoundChannels"},
+    {0x00070000, nullptr, "AcquireCaptureDevice"},
+    {0x00080040, nullptr, "ReleaseCaptureDevice"},
+    {0x00090082, nullptr, "FlushDataCache"},
+    {0x000A0082, nullptr, "StoreDataCache"},
+    {0x000B0082, nullptr, "InvalidateDataCache"},
+    {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,
-                                                 MemoryPermission::ReadWrite, MemoryPermission::ReadWrite,
-                                                 0, Kernel::MemoryRegion::BASE, "CSND:SharedMemory");
+    shared_memory = Kernel::SharedMemory::Create(nullptr, size, MemoryPermission::ReadWrite,
+                                                 MemoryPermission::ReadWrite, 0,
+                                                 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..8f4b67a5d 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 {
@@ -17,8 +17,7 @@ void Init() {
     AddService(new DLP_SRVR_Interface);
 }
 
-void Shutdown() {
-}
+void Shutdown() {}
 
 } // namespace DLP
 } // namespace Service
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"},
-    {0x00110000, nullptr, "GetWirelessRebootPassphrase"},
+    {0x000100C3, nullptr, "Initialize"}, {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"},
-    {0x000F0000, nullptr, "GetWirelessRebootPassphrase"},
+    {0x00010083, nullptr, "Initialize"}, {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..49d5b8d1c 100644
--- a/src/core/hle/service/dlp/dlp_srvr.cpp
+++ b/src/core/hle/service/dlp/dlp_srvr.cpp
@@ -20,10 +20,10 @@ static void unk_0x000E0040(Interface* self) {
 }
 
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010183, nullptr,           "Initialize"},
-    {0x00020000, nullptr,           "Finalize"},
-    {0x000800C0, nullptr,           "SendWirelessRebootPassphrase"},
-    {0x000E0040, unk_0x000E0040,    "unk_0x000E0040"},
+    {0x00010183, nullptr, "Initialize"},
+    {0x00020000, nullptr, "Finalize"},
+    {0x000800C0, nullptr, "SendWirelessRebootPassphrase"},
+    {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..a15aa3696 100644
--- a/src/core/hle/service/dsp_dsp.cpp
+++ b/src/core/hle/service/dsp_dsp.cpp
@@ -4,12 +4,9 @@
 
 #include <algorithm>
 #include <cinttypes>
-
 #include "audio_core/hle/pipe.h"
-
 #include "common/hash.h"
 #include "common/logging/log.h"
-
 #include "core/hle/kernel/event.h"
 #include "core/hle/service/dsp_dsp.h"
 
@@ -23,9 +20,7 @@ namespace DSP_DSP {
 static Kernel::SharedPtr<Kernel::Event> semaphore_event;
 
 /// There are three types of interrupts
-enum class InterruptType {
-    Zero, One, Pipe
-};
+enum class InterruptType { Zero, One, Pipe };
 constexpr size_t NUM_INTERRUPT_TYPE = 3;
 
 class InterruptEvents final {
@@ -57,9 +52,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) {
-            return evt != nullptr;
-        });
+        size_t number =
+            std::count_if(pipe.begin(), pipe.end(), [](const auto& evt) { return evt != nullptr; });
 
         if (zero != nullptr)
             number++;
@@ -105,7 +99,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 +121,15 @@ static void ConvertProcessAddressFromDspDram(Service::Interface* self) {
 static void LoadComponent(Service::Interface* self) {
     u32* cmd_buff = Kernel::GetCommandBuffer();
 
-    u32 size       = cmd_buff[1];
-    u32 prog_mask  = cmd_buff[2];
-    u32 data_mask  = cmd_buff[3];
-    u32 desc       = cmd_buff[4];
-    u32 buffer     = cmd_buff[5];
+    u32 size = cmd_buff[1];
+    u32 prog_mask = cmd_buff[2];
+    u32 data_mask = cmd_buff[3];
+    u32 desc = cmd_buff[4];
+    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 +140,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 +185,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 +223,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 +287,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 +337,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 +355,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 +381,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 +400,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 +426,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 +462,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 +485,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 +532,39 @@ static void RecvDataIsReady(Service::Interface* self) {
 }
 
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010040, RecvData,                         "RecvData"},
-    {0x00020040, RecvDataIsReady,                  "RecvDataIsReady"},
-    {0x00030080, nullptr,                          "SendData"},
-    {0x00040040, nullptr,                          "SendDataIsEmpty"},
-    {0x000500C2, nullptr,                          "SendFifoEx"},
-    {0x000600C0, nullptr,                          "RecvFifoEx"},
-    {0x00070040, SetSemaphore,                     "SetSemaphore"},
-    {0x00080000, nullptr,                          "GetSemaphore"},
-    {0x00090040, nullptr,                          "ClearSemaphore"},
-    {0x000A0040, nullptr,                          "MaskSemaphore"},
-    {0x000B0000, nullptr,                          "CheckSemaphoreRequest"},
+    {0x00010040, RecvData, "RecvData"},
+    {0x00020040, RecvDataIsReady, "RecvDataIsReady"},
+    {0x00030080, nullptr, "SendData"},
+    {0x00040040, nullptr, "SendDataIsEmpty"},
+    {0x000500C2, nullptr, "SendFifoEx"},
+    {0x000600C0, nullptr, "RecvFifoEx"},
+    {0x00070040, SetSemaphore, "SetSemaphore"},
+    {0x00080000, nullptr, "GetSemaphore"},
+    {0x00090040, nullptr, "ClearSemaphore"},
+    {0x000A0040, nullptr, "MaskSemaphore"},
+    {0x000B0000, nullptr, "CheckSemaphoreRequest"},
     {0x000C0040, ConvertProcessAddressFromDspDram, "ConvertProcessAddressFromDspDram"},
-    {0x000D0082, WriteProcessPipe,                 "WriteProcessPipe"},
-    {0x000E00C0, ReadPipe,                         "ReadPipe"},
-    {0x000F0080, GetPipeReadableSize,              "GetPipeReadableSize"},
-    {0x001000C0, ReadPipeIfPossible,               "ReadPipeIfPossible"},
-    {0x001100C2, LoadComponent,                    "LoadComponent"},
-    {0x00120000, nullptr,                          "UnloadComponent"},
-    {0x00130082, FlushDataCache,                   "FlushDataCache"},
-    {0x00140082, nullptr,                          "InvalidateDCache"},
-    {0x00150082, RegisterInterruptEvents,          "RegisterInterruptEvents"},
-    {0x00160000, GetSemaphoreEventHandle,          "GetSemaphoreEventHandle"},
-    {0x00170040, SetSemaphoreMask,                 "SetSemaphoreMask"},
-    {0x00180040, nullptr,                          "GetPhysicalAddress"},
-    {0x00190040, nullptr,                          "GetVirtualAddress"},
-    {0x001A0042, nullptr,                          "SetIirFilterI2S1_cmd1"},
-    {0x001B0042, nullptr,                          "SetIirFilterI2S1_cmd2"},
-    {0x001C0082, nullptr,                          "SetIirFilterEQ"},
-    {0x001D00C0, nullptr,                          "ReadMultiEx_SPI2"},
-    {0x001E00C2, nullptr,                          "WriteMultiEx_SPI2"},
-    {0x001F0000, GetHeadphoneStatus,               "GetHeadphoneStatus"},
-    {0x00200040, nullptr,                          "ForceHeadphoneOut"},
-    {0x00210000, nullptr,                          "GetIsDspOccupied"},
+    {0x000D0082, WriteProcessPipe, "WriteProcessPipe"},
+    {0x000E00C0, ReadPipe, "ReadPipe"},
+    {0x000F0080, GetPipeReadableSize, "GetPipeReadableSize"},
+    {0x001000C0, ReadPipeIfPossible, "ReadPipeIfPossible"},
+    {0x001100C2, LoadComponent, "LoadComponent"},
+    {0x00120000, nullptr, "UnloadComponent"},
+    {0x00130082, FlushDataCache, "FlushDataCache"},
+    {0x00140082, nullptr, "InvalidateDCache"},
+    {0x00150082, RegisterInterruptEvents, "RegisterInterruptEvents"},
+    {0x00160000, GetSemaphoreEventHandle, "GetSemaphoreEventHandle"},
+    {0x00170040, SetSemaphoreMask, "SetSemaphoreMask"},
+    {0x00180040, nullptr, "GetPhysicalAddress"},
+    {0x00190040, nullptr, "GetVirtualAddress"},
+    {0x001A0042, nullptr, "SetIirFilterI2S1_cmd1"},
+    {0x001B0042, nullptr, "SetIirFilterI2S1_cmd2"},
+    {0x001C0082, nullptr, "SetIirFilterEQ"},
+    {0x001D00C0, nullptr, "ReadMultiEx_SPI2"},
+    {0x001E00C2, nullptr, "WriteMultiEx_SPI2"},
+    {0x001F0000, GetHeadphoneStatus, "GetHeadphoneStatus"},
+    {0x00200040, nullptr, "ForceHeadphoneOut"},
+    {0x00210000, nullptr, "GetIsDspOccupied"},
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/dsp_dsp.h b/src/core/hle/service/dsp_dsp.h
index 22f6687cc..3e97da6eb 100644
--- a/src/core/hle/service/dsp_dsp.h
+++ b/src/core/hle/service/dsp_dsp.h
@@ -5,7 +5,6 @@
 #pragma once
 
 #include <string>
-
 #include "core/hle/service/service.h"
 
 namespace DSP {
diff --git a/src/core/hle/service/err_f.cpp b/src/core/hle/service/err_f.cpp
index 5f9cf6e94..3ca4f98de 100644
--- a/src/core/hle/service/err_f.cpp
+++ b/src/core/hle/service/err_f.cpp
@@ -5,7 +5,6 @@
 #include "common/bit_field.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-
 #include "core/hle/service/err_f.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -35,70 +34,70 @@ union ErrInfo {
     u8 specifier;
 
     struct {
-        u8 specifier;                // 0x0
-        u8 rev_high;                 // 0x1
-        u16 rev_low;                 // 0x2
-        RSL result_code;             // 0x4
-        u32 address;                 // 0x8
-        INSERT_PADDING_BYTES(4);     // 0xC
-        u32 pid_low;                 // 0x10
-        u32 pid_high;                // 0x14
-        u32 aid_low;                 // 0x18
-        u32 aid_high;                // 0x1C
+        u8 specifier;            // 0x0
+        u8 rev_high;             // 0x1
+        u16 rev_low;             // 0x2
+        RSL result_code;         // 0x4
+        u32 address;             // 0x8
+        INSERT_PADDING_BYTES(4); // 0xC
+        u32 pid_low;             // 0x10
+        u32 pid_high;            // 0x14
+        u32 aid_low;             // 0x18
+        u32 aid_high;            // 0x1C
     } errtype1;
 
     struct {
-        u8 specifier;                // 0x0
-        u8 rev_high;                 // 0x1
-        u16 rev_low;                 // 0x2
-        INSERT_PADDING_BYTES(0xC);   // 0x4
-        u32 pid_low;                 // 0x10
-        u32 pid_high;                // 0x14
-        u32 aid_low;                 // 0x18
-        u32 aid_high;                // 0x1C
-        u8 error_type;               // 0x20
-        INSERT_PADDING_BYTES(3);     // 0x21
-        u32 fault_status_reg;        // 0x24
-        u32 fault_addr;              // 0x28
-        u32 fpexc;                   // 0x2C
-        u32 finst;                   // 0x30
-        u32 finst2;                  // 0x34
-        INSERT_PADDING_BYTES(0x34);  // 0x38
-        u32 sp;                      // 0x6C
-        u32 pc;                      // 0x70
-        u32 lr;                      // 0x74
-        u32 cpsr;                    // 0x78
+        u8 specifier;               // 0x0
+        u8 rev_high;                // 0x1
+        u16 rev_low;                // 0x2
+        INSERT_PADDING_BYTES(0xC);  // 0x4
+        u32 pid_low;                // 0x10
+        u32 pid_high;               // 0x14
+        u32 aid_low;                // 0x18
+        u32 aid_high;               // 0x1C
+        u8 error_type;              // 0x20
+        INSERT_PADDING_BYTES(3);    // 0x21
+        u32 fault_status_reg;       // 0x24
+        u32 fault_addr;             // 0x28
+        u32 fpexc;                  // 0x2C
+        u32 finst;                  // 0x30
+        u32 finst2;                 // 0x34
+        INSERT_PADDING_BYTES(0x34); // 0x38
+        u32 sp;                     // 0x6C
+        u32 pc;                     // 0x70
+        u32 lr;                     // 0x74
+        u32 cpsr;                   // 0x78
     } errtype3;
 
     struct {
-        u8 specifier;                // 0x0
-        u8 rev_high;                 // 0x1
-        u16 rev_low;                 // 0x2
-        RSL result_code;             // 0x4
-        INSERT_PADDING_BYTES(8);     // 0x8
-        u32 pid_low;                 // 0x10
-        u32 pid_high;                // 0x14
-        u32 aid_low;                 // 0x18
-        u32 aid_high;                // 0x1C
-        char debug_string1[0x2E];    // 0x20
-        char debug_string2[0x2E];    // 0x4E
+        u8 specifier;             // 0x0
+        u8 rev_high;              // 0x1
+        u16 rev_low;              // 0x2
+        RSL result_code;          // 0x4
+        INSERT_PADDING_BYTES(8);  // 0x8
+        u32 pid_low;              // 0x10
+        u32 pid_high;             // 0x14
+        u32 aid_low;              // 0x18
+        u32 aid_high;             // 0x1C
+        char debug_string1[0x2E]; // 0x20
+        char debug_string2[0x2E]; // 0x4E
     } errtype4;
 };
 
-enum {
-    PrefetchAbort = 0,
-    DataAbort     = 1,
-    UndefInstr    = 2,
-    VectorFP      = 3
-};
+enum { PrefetchAbort = 0, DataAbort = 1, UndefInstr = 2, VectorFP = 3 };
 
 static std::string GetErrInfo3Type(u8 type_code) {
     switch (type_code) {
-    case PrefetchAbort: return "Prefetch Abort";
-    case DataAbort:     return "Data Abort";
-    case UndefInstr:    return "Undefined Instruction";
-    case VectorFP:      return "Vector Floating Point";
-    default: return "unknown";
+    case PrefetchAbort:
+        return "Prefetch Abort";
+    case DataAbort:
+        return "Data Abort";
+    case UndefInstr:
+        return "Undefined Instruction";
+    case VectorFP:
+        return "Vector Floating Point";
+    default:
+        return "unknown";
     }
 }
 
@@ -110,8 +109,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 +117,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, "  Desc: %u",    errtype.result_code.description.Value());
+        LOG_CRITICAL(Service_ERR, "  Module: %u", errtype.result_code.module.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 +151,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, "  Desc: %u",    errtype.result_code.description.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, "%s", errtype.debug_string1);
         LOG_CRITICAL(Service_ERR, "%s", errtype.debug_string2);
@@ -177,7 +173,7 @@ static void ThrowFatalError(Service::Interface* self) {
 }
 
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010800, ThrowFatalError,           "ThrowFatalError"}
+    {0x00010800, ThrowFatalError, "ThrowFatalError"},
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/frd/frd.cpp b/src/core/hle/service/frd/frd.cpp
index 29d144365..fa5080535 100644
--- a/src/core/hle/service/frd/frd.cpp
+++ b/src/core/hle/service/frd/frd.cpp
@@ -3,11 +3,10 @@
 // Refer to the license.txt file included.
 
 #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 +42,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 +60,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",
-                count, frd_key_addr, profiles_addr);
+    LOG_WARNING(Service_FRD,
+                "(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 frd_key_addr    = cmd_buff[3];
+    u32 count = cmd_buff[1];
+    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",
-                count, frd_key_addr, attr_flags_addr);
+    LOG_WARNING(Service_FRD,
+                "(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) {
@@ -106,8 +107,7 @@ void Init() {
     AddService(new FRD_U_Interface);
 }
 
-void Shutdown() {
-}
+void Shutdown() {}
 
 } // namespace FRD
 
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"},
-    {0x00020000, nullptr,                 "IsOnline"},
-    {0x00030000, nullptr,                 "Login"},
-    {0x00040000, nullptr,                 "Logout"},
-    {0x00050000, GetMyFriendKey,          "GetMyFriendKey"},
-    {0x00060000, nullptr,                 "GetMyPreference"},
-    {0x00070000, nullptr,                 "GetMyProfile"},
-    {0x00080000, GetMyPresence,           "GetMyPresence"},
-    {0x00090000, GetMyScreenName,         "GetMyScreenName"},
-    {0x000A0000, nullptr,                 "GetMyMii"},
-    {0x000B0000, nullptr,                 "GetMyLocalAccountId"},
-    {0x000C0000, nullptr,                 "GetMyPlayingGame"},
-    {0x000D0000, nullptr,                 "GetMyFavoriteGame"},
-    {0x000E0000, nullptr,                 "GetMyNcPrincipalId"},
-    {0x000F0000, nullptr,                 "GetMyComment"},
-    {0x00100040, nullptr,                 "GetMyPassword"},
-    {0x00110080, GetFriendKeyList,        "GetFriendKeyList"},
-    {0x00120042, nullptr,                 "GetFriendPresence"},
-    {0x00130142, nullptr,                 "GetFriendScreenName"},
-    {0x00140044, nullptr,                 "GetFriendMii"},
-    {0x00150042, GetFriendProfile,        "GetFriendProfile"},
-    {0x00160042, nullptr,                 "GetFriendRelationship"},
+    {0x00010000, nullptr, "HasLoggedIn"},
+    {0x00020000, nullptr, "IsOnline"},
+    {0x00030000, nullptr, "Login"},
+    {0x00040000, nullptr, "Logout"},
+    {0x00050000, GetMyFriendKey, "GetMyFriendKey"},
+    {0x00060000, nullptr, "GetMyPreference"},
+    {0x00070000, nullptr, "GetMyProfile"},
+    {0x00080000, GetMyPresence, "GetMyPresence"},
+    {0x00090000, GetMyScreenName, "GetMyScreenName"},
+    {0x000A0000, nullptr, "GetMyMii"},
+    {0x000B0000, nullptr, "GetMyLocalAccountId"},
+    {0x000C0000, nullptr, "GetMyPlayingGame"},
+    {0x000D0000, nullptr, "GetMyFavoriteGame"},
+    {0x000E0000, nullptr, "GetMyNcPrincipalId"},
+    {0x000F0000, nullptr, "GetMyComment"},
+    {0x00100040, nullptr, "GetMyPassword"},
+    {0x00110080, GetFriendKeyList, "GetFriendKeyList"},
+    {0x00120042, nullptr, "GetFriendPresence"},
+    {0x00130142, nullptr, "GetFriendScreenName"},
+    {0x00140044, nullptr, "GetFriendMii"},
+    {0x00150042, GetFriendProfile, "GetFriendProfile"},
+    {0x00160042, nullptr, "GetFriendRelationship"},
     {0x00170042, GetFriendAttributeFlags, "GetFriendAttributeFlags"},
-    {0x00180044, nullptr,                 "GetFriendPlayingGame"},
-    {0x00190042, nullptr,                 "GetFriendFavoriteGame"},
-    {0x001A00C4, nullptr,                 "GetFriendInfo"},
-    {0x001B0080, nullptr,                 "IsIncludedInFriendList"},
-    {0x001C0042, nullptr,                 "UnscrambleLocalFriendCode"},
-    {0x001D0002, nullptr,                 "UpdateGameModeDescription"},
-    {0x001E02C2, nullptr,                 "UpdateGameMode"},
-    {0x001F0042, nullptr,                 "SendInvitation"},
-    {0x00200002, nullptr,                 "AttachToEventNotification"},
-    {0x00210040, nullptr,                 "SetNotificationMask"},
-    {0x00220040, nullptr,                 "GetEventNotification"},
-    {0x00230000, nullptr,                 "GetLastResponseResult"},
-    {0x00240040, nullptr,                 "PrincipalIdToFriendCode"},
-    {0x00250080, nullptr,                 "FriendCodeToPrincipalId"},
-    {0x00260080, nullptr,                 "IsValidFriendCode"},
-    {0x00270040, nullptr,                 "ResultToErrorCode"},
-    {0x00280244, nullptr,                 "RequestGameAuthentication"},
-    {0x00290000, nullptr,                 "GetGameAuthenticationData"},
-    {0x002A0204, nullptr,                 "RequestServiceLocator"},
-    {0x002B0000, nullptr,                 "GetServiceLocatorData"},
-    {0x002C0002, nullptr,                 "DetectNatProperties"},
-    {0x002D0000, nullptr,                 "GetNatProperties"},
-    {0x002E0000, nullptr,                 "GetServerTimeInterval"},
-    {0x002F0040, nullptr,                 "AllowHalfAwake"},
-    {0x00300000, nullptr,                 "GetServerTypes"},
-    {0x00310082, nullptr,                 "GetFriendComment"},
-    {0x00320042, nullptr,                 "SetClientSdkVersion"},
-    {0x00330000, nullptr,                 "GetMyApproachContext"},
-    {0x00340046, nullptr,                 "AddFriendWithApproach"},
-    {0x00350082, nullptr,                 "DecryptApproachContext"},
+    {0x00180044, nullptr, "GetFriendPlayingGame"},
+    {0x00190042, nullptr, "GetFriendFavoriteGame"},
+    {0x001A00C4, nullptr, "GetFriendInfo"},
+    {0x001B0080, nullptr, "IsIncludedInFriendList"},
+    {0x001C0042, nullptr, "UnscrambleLocalFriendCode"},
+    {0x001D0002, nullptr, "UpdateGameModeDescription"},
+    {0x001E02C2, nullptr, "UpdateGameMode"},
+    {0x001F0042, nullptr, "SendInvitation"},
+    {0x00200002, nullptr, "AttachToEventNotification"},
+    {0x00210040, nullptr, "SetNotificationMask"},
+    {0x00220040, nullptr, "GetEventNotification"},
+    {0x00230000, nullptr, "GetLastResponseResult"},
+    {0x00240040, nullptr, "PrincipalIdToFriendCode"},
+    {0x00250080, nullptr, "FriendCodeToPrincipalId"},
+    {0x00260080, nullptr, "IsValidFriendCode"},
+    {0x00270040, nullptr, "ResultToErrorCode"},
+    {0x00280244, nullptr, "RequestGameAuthentication"},
+    {0x00290000, nullptr, "GetGameAuthenticationData"},
+    {0x002A0204, nullptr, "RequestServiceLocator"},
+    {0x002B0000, nullptr, "GetServiceLocatorData"},
+    {0x002C0002, nullptr, "DetectNatProperties"},
+    {0x002D0000, nullptr, "GetNatProperties"},
+    {0x002E0000, nullptr, "GetServerTimeInterval"},
+    {0x002F0040, nullptr, "AllowHalfAwake"},
+    {0x00300000, nullptr, "GetServerTypes"},
+    {0x00310082, nullptr, "GetFriendComment"},
+    {0x00320042, nullptr, "SetClientSdkVersion"},
+    {0x00330000, nullptr, "GetMyApproachContext"},
+    {0x00340046, nullptr, "AddFriendWithApproach"},
+    {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..4dc7e1e3c 100644
--- a/src/core/hle/service/fs/archive.cpp
+++ b/src/core/hle/service/fs/archive.cpp
@@ -3,19 +3,16 @@
 // Refer to the license.txt file included.
 
 #include <cstddef>
+#include <memory>
 #include <system_error>
 #include <type_traits>
-#include <memory>
 #include <unordered_map>
 #include <utility>
-
 #include <boost/container/flat_map.hpp>
-
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
-
 #include "core/file_sys/archive_backend.h"
 #include "core/file_sys/archive_extsavedata.h"
 #include "core/file_sys/archive_savedata.h"
@@ -25,25 +22,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 <>
-    struct hash<Service::FS::ArchiveIdCode> {
-        typedef Service::FS::ArchiveIdCode argument_type;
-        typedef std::size_t result_type;
-
-        result_type operator()(const argument_type& id_code) const {
-            typedef std::underlying_type<argument_type>::type Type;
-            return std::hash<Type>()(static_cast<Type>(id_code));
-        }
-    };
+template <>
+struct hash<Service::FS::ArchiveIdCode> {
+    typedef Service::FS::ArchiveIdCode argument_type;
+    typedef std::size_t result_type;
+
+    result_type operator()(const argument_type& id_code) const {
+        typedef std::underlying_type<argument_type>::type Type;
+        return std::hash<Type>()(static_cast<Type>(id_code));
+    }
+};
 }
 
 /// TODO(Subv): Confirm length of these strings
@@ -56,39 +53,40 @@ 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,
-    Control         = 0x040100C4,
-    OpenSubFile     = 0x08010100,
-    Read            = 0x080200C2,
-    Write           = 0x08030102,
-    GetSize         = 0x08040000,
-    SetSize         = 0x08050080,
-    GetAttributes   = 0x08060000,
-    SetAttributes   = 0x08070040,
-    Close           = 0x08080000,
-    Flush           = 0x08090000,
-    SetPriority     = 0x080A0040,
-    GetPriority     = 0x080B0000,
-    OpenLinkFile    = 0x080C0000,
+    Dummy1 = 0x000100C6,
+    Control = 0x040100C4,
+    OpenSubFile = 0x08010100,
+    Read = 0x080200C2,
+    Write = 0x08030102,
+    GetSize = 0x08040000,
+    SetSize = 0x08050080,
+    GetAttributes = 0x08060000,
+    SetAttributes = 0x08070040,
+    Close = 0x08080000,
+    Flush = 0x08090000,
+    SetPriority = 0x080A0040,
+    GetPriority = 0x080B0000,
+    OpenLinkFile = 0x080C0000,
 };
 
 // Command to access directory
 enum class DirectoryCommand : u32 {
-    Dummy1          = 0x000100C6,
-    Control         = 0x040100C4,
-    Read            = 0x08010042,
-    Close           = 0x08020000,
+    Dummy1 = 0x000100C6,
+    Control = 0x040100C4,
+    Read = 0x08010042,
+    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)) {}
 
 File::~File() {}
@@ -98,117 +96,110 @@ ResultVal<bool> File::SyncRequest() {
     FileCommand cmd = static_cast<FileCommand>(cmd_buff[0]);
     switch (cmd) {
 
-        // Read from file...
-        case FileCommand::Read:
-        {
-            u64 offset = cmd_buff[1] | ((u64)cmd_buff[2]) << 32;
-            u32 length = cmd_buff[3];
-            u32 address = cmd_buff[5];
-            LOG_TRACE(Service_FS, "Read %s %s: offset=0x%llx length=%d address=0x%x",
-                      GetTypeName().c_str(), GetName().c_str(), offset, length, address);
-
-            if (offset + length > backend->GetSize()) {
-                LOG_ERROR(Service_FS, "Reading from out of bounds offset=0x%llX length=0x%08X file_size=0x%llX",
-                          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;
+    // Read from file...
+    case FileCommand::Read: {
+        u64 offset = cmd_buff[1] | ((u64)cmd_buff[2]) << 32;
+        u32 length = cmd_buff[3];
+        u32 address = cmd_buff[5];
+        LOG_TRACE(Service_FS, "Read %s %s: offset=0x%llx length=%d address=0x%x",
+                  GetTypeName().c_str(), GetName().c_str(), offset, length, address);
+
+        if (offset + length > backend->GetSize()) {
+            LOG_ERROR(Service_FS,
+                      "Reading from out of bounds offset=0x%llX length=0x%08X file_size=0x%llX",
+                      offset, length, backend->GetSize());
         }
 
-        // Write to file...
-        case FileCommand::Write:
-        {
-            u64 offset = cmd_buff[1] | ((u64)cmd_buff[2]) << 32;
-            u32 length = cmd_buff[3];
-            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;
+        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;
+    }
 
-        case FileCommand::GetSize:
-        {
-            LOG_TRACE(Service_FS, "GetSize %s %s", GetTypeName().c_str(), GetName().c_str());
-            u64 size = backend->GetSize();
-            cmd_buff[2] = (u32)size;
-            cmd_buff[3] = size >> 32;
-            break;
+    // Write to file...
+    case FileCommand::Write: {
+        u64 offset = cmd_buff[1] | ((u64)cmd_buff[2]) << 32;
+        u32 length = cmd_buff[3];
+        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;
+    }
 
-        case FileCommand::SetSize:
-        {
-            u64 size = cmd_buff[1] | ((u64)cmd_buff[2] << 32);
-            LOG_TRACE(Service_FS, "SetSize %s %s size=%llu",
-                GetTypeName().c_str(), GetName().c_str(), size);
-            backend->SetSize(size);
-            break;
-        }
+    case FileCommand::GetSize: {
+        LOG_TRACE(Service_FS, "GetSize %s %s", GetTypeName().c_str(), GetName().c_str());
+        u64 size = backend->GetSize();
+        cmd_buff[2] = (u32)size;
+        cmd_buff[3] = size >> 32;
+        break;
+    }
 
-        case FileCommand::Close:
-        {
-            LOG_TRACE(Service_FS, "Close %s %s", GetTypeName().c_str(), GetName().c_str());
-            backend->Close();
-            break;
-        }
+    case FileCommand::SetSize: {
+        u64 size = cmd_buff[1] | ((u64)cmd_buff[2] << 32);
+        LOG_TRACE(Service_FS, "SetSize %s %s size=%llu", GetTypeName().c_str(), GetName().c_str(),
+                  size);
+        backend->SetSize(size);
+        break;
+    }
 
-        case FileCommand::Flush:
-        {
-            LOG_TRACE(Service_FS, "Flush");
-            backend->Flush();
-            break;
-        }
+    case FileCommand::Close: {
+        LOG_TRACE(Service_FS, "Close %s %s", GetTypeName().c_str(), GetName().c_str());
+        backend->Close();
+        break;
+    }
 
-        case FileCommand::OpenLinkFile:
-        {
-            LOG_WARNING(Service_FS, "(STUBBED) File command OpenLinkFile %s", GetName().c_str());
-            cmd_buff[3] = Kernel::g_handle_table.Create(this).ValueOr(INVALID_HANDLE);
-            break;
-        }
+    case FileCommand::Flush: {
+        LOG_TRACE(Service_FS, "Flush");
+        backend->Flush();
+        break;
+    }
 
-        case FileCommand::SetPriority:
-        {
-            priority = cmd_buff[1];
-            LOG_TRACE(Service_FS, "SetPriority %u", priority);
-            break;
-        }
+    case FileCommand::OpenLinkFile: {
+        LOG_WARNING(Service_FS, "(STUBBED) File command OpenLinkFile %s", GetName().c_str());
+        cmd_buff[3] = Kernel::g_handle_table.Create(this).ValueOr(INVALID_HANDLE);
+        break;
+    }
 
-        case FileCommand::GetPriority:
-        {
-            cmd_buff[2] = priority;
-            LOG_TRACE(Service_FS, "GetPriority");
-            break;
-        }
+    case FileCommand::SetPriority: {
+        priority = cmd_buff[1];
+        LOG_TRACE(Service_FS, "SetPriority %u", priority);
+        break;
+    }
+
+    case FileCommand::GetPriority: {
+        cmd_buff[2] = priority;
+        LOG_TRACE(Service_FS, "GetPriority");
+        break;
+    }
 
-        // 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;
+    // 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,
+                     const FileSys::Path& path)
     : path(path), backend(std::move(backend)) {}
 
 Directory::~Directory() {}
@@ -218,35 +209,33 @@ ResultVal<bool> Directory::SyncRequest() {
     DirectoryCommand cmd = static_cast<DirectoryCommand>(cmd_buff[0]);
     switch (cmd) {
 
-        // Read from directory...
-        case DirectoryCommand::Read:
-        {
-            u32 count = cmd_buff[1];
-            u32 address = cmd_buff[3];
-            std::vector<FileSys::Entry> entries(count);
-            LOG_TRACE(Service_FS, "Read %s %s: count=%d",
-                GetTypeName().c_str(), GetName().c_str(), count);
-
-            // Number of entries actually read
-            u32 read = backend->Read(entries.size(), entries.data());
-            cmd_buff[2] = read;
-            Memory::WriteBlock(address, entries.data(), read * sizeof(FileSys::Entry));
-            break;
-        }
+    // Read from directory...
+    case DirectoryCommand::Read: {
+        u32 count = cmd_buff[1];
+        u32 address = cmd_buff[3];
+        std::vector<FileSys::Entry> entries(count);
+        LOG_TRACE(Service_FS, "Read %s %s: count=%d", GetTypeName().c_str(), GetName().c_str(),
+                  count);
+
+        // Number of entries actually read
+        u32 read = backend->Read(entries.size(), entries.data());
+        cmd_buff[2] = read;
+        Memory::WriteBlock(address, entries.data(), read * sizeof(FileSys::Entry));
+        break;
+    }
 
-        case DirectoryCommand::Close:
-        {
-            LOG_TRACE(Service_FS, "Close %s %s", GetTypeName().c_str(), GetName().c_str());
-            backend->Close();
-            break;
-        }
+    case DirectoryCommand::Close: {
+        LOG_TRACE(Service_FS, "Close %s %s", GetTypeName().c_str(), GetName().c_str());
+        backend->Close();
+        break;
+    }
 
-        // 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 MakeResult<bool>(false);
+    // 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 MakeResult<bool>(false);
     }
     cmd_buff[1] = RESULT_SUCCESS.raw; // No error
     return MakeResult<bool>(false);
@@ -280,8 +269,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,
-                          ErrorSummary::NotFound, ErrorLevel::Permanent);
+        return ResultCode(ErrorDescription::NotFound, ErrorModule::FS, ErrorSummary::NotFound,
+                          ErrorLevel::Permanent);
     }
 
     CASCADE_RESULT(std::unique_ptr<ArchiveBackend> res, itr->second->Open(archive_path));
@@ -303,19 +292,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 +328,10 @@ ResultCode DeleteFileFromArchive(ArchiveHandle archive_handle, const FileSys::Pa
     return archive->DeleteFile(path);
 }
 
-ResultCode RenameFileBetweenArchives(ArchiveHandle src_archive_handle, const FileSys::Path& src_path,
-                                     ArchiveHandle dest_archive_handle, const FileSys::Path& dest_path) {
+ResultCode RenameFileBetweenArchives(ArchiveHandle src_archive_handle,
+                                     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 +362,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 +382,10 @@ ResultCode CreateDirectoryFromArchive(ArchiveHandle archive_handle, const FileSy
                       ErrorSummary::Canceled, ErrorLevel::Status);
 }
 
-ResultCode RenameDirectoryBetweenArchives(ArchiveHandle src_archive_handle, const FileSys::Path& src_path,
-                                          ArchiveHandle dest_archive_handle, const FileSys::Path& dest_path) {
+ResultCode RenameDirectoryBetweenArchives(ArchiveHandle src_archive_handle,
+                                          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 +406,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,
-                          ErrorSummary::NotFound, ErrorLevel::Permanent);
+        return ResultCode(ErrorDescription::FS_NotFound, ErrorModule::FS, ErrorSummary::NotFound,
+                          ErrorLevel::Permanent);
     }
 
     auto directory = Kernel::SharedPtr<Directory>(new Directory(std::move(backend), path));
@@ -431,7 +428,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 +438,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 +448,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 +478,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 +492,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 +534,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..533be34a4 100644
--- a/src/core/hle/service/fs/archive.h
+++ b/src/core/hle/service/fs/archive.h
@@ -6,9 +6,7 @@
 
 #include <memory>
 #include <string>
-
 #include "common/common_types.h"
-
 #include "core/file_sys/archive_backend.h"
 #include "core/hle/kernel/session.h"
 #include "core/hle/result.h"
@@ -28,21 +26,18 @@ namespace FS {
 
 /// Supported archive types
 enum class ArchiveIdCode : u32 {
-    RomFS               = 0x00000003,
-    SaveData            = 0x00000004,
-    ExtSaveData         = 0x00000006,
-    SharedExtSaveData   = 0x00000007,
-    SystemSaveData      = 0x00000008,
-    SDMC                = 0x00000009,
-    SDMCWriteOnly       = 0x0000000A,
-    SaveDataCheck       = 0x2345678A,
+    RomFS = 0x00000003,
+    SaveData = 0x00000004,
+    ExtSaveData = 0x00000006,
+    SharedExtSaveData = 0x00000007,
+    SystemSaveData = 0x00000008,
+    SDMC = 0x00000009,
+    SDMCWriteOnly = 0x0000000A,
+    SaveDataCheck = 0x2345678A,
 };
 
 /// Media types for the archives
-enum class MediaType : u32 {
-    NAND     = 0,
-    SDMC     = 1
-};
+enum class MediaType : u32 { NAND = 0, SDMC = 1 };
 
 typedef u64 ArchiveHandle;
 
@@ -51,11 +46,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 +61,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 +89,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 +100,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 +119,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,
-                                     ArchiveHandle dest_archive_handle, const FileSys::Path& dest_path);
+ResultCode RenameFileBetweenArchives(ArchiveHandle src_archive_handle,
+                                     const FileSys::Path& src_path,
+                                     ArchiveHandle dest_archive_handle,
+                                     const FileSys::Path& dest_path);
 
 /**
  * Delete a Directory from an Archive
@@ -136,7 +139,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 +158,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,
-                                          ArchiveHandle dest_archive_handle, const FileSys::Path& dest_path);
+ResultCode RenameDirectoryBetweenArchives(ArchiveHandle src_archive_handle,
+                                          const FileSys::Path& src_path,
+                                          ArchiveHandle dest_archive_handle,
+                                          const FileSys::Path& dest_path);
 
 /**
  * Open a Directory from an Archive
@@ -164,7 +170,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 +187,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 +197,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 +210,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..94f053dc2 100644
--- a/src/core/hle/service/fs/fs_user.cpp
+++ b/src/core/hle/service/fs/fs_user.cpp
@@ -8,7 +8,6 @@
 #include "common/logging/log.h"
 #include "common/scope_exit.h"
 #include "common/string_util.h"
-
 #include "core/hle/result.h"
 #include "core/hle/service/fs/archive.h"
 #include "core/hle/service/fs/fs_user.h"
@@ -57,14 +56,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]);
-    u32 filename_size     = cmd_buff[5];
-    FileSys::Mode mode; mode.hex = cmd_buff[6];
-    u32 attributes        = cmd_buff[7]; // TODO(Link Mauve): do something with those attributes.
-    u32 filename_ptr      = cmd_buff[9];
+    auto filename_type = static_cast<FileSys::LowPathType>(cmd_buff[4]);
+    u32 filename_size = cmd_buff[5];
+    FileSys::Mode mode;
+    mode.hex = cmd_buff[6];
+    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 +99,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];
-    auto filename_type    = static_cast<FileSys::LowPathType>(cmd_buff[5]);
-    u32 filename_size     = cmd_buff[6];
-    FileSys::Mode mode; mode.hex = cmd_buff[7];
-    u32 attributes        = cmd_buff[8]; // TODO(Link Mauve): do something with those attributes.
-    u32 archivename_ptr   = cmd_buff[10];
-    u32 filename_ptr      = cmd_buff[12];
+    u32 archivename_size = cmd_buff[4];
+    auto filename_type = static_cast<FileSys::LowPathType>(cmd_buff[5]);
+    u32 filename_size = cmd_buff[6];
+    FileSys::Mode mode;
+    mode.hex = cmd_buff[7];
+    u32 attributes = cmd_buff[8]; // TODO(Link Mauve): do something with those attributes.
+    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 +153,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]);
-    u32 filename_size     = cmd_buff[5];
-    u32 filename_ptr      = cmd_buff[7];
+    auto filename_type = static_cast<FileSys::LowPathType>(cmd_buff[4]);
+    u32 filename_size = cmd_buff[5];
+    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",
-              filename_type, filename_size, file_path.DebugStr().c_str());
+    LOG_DEBUG(Service_FS, "type=%d size=%d data=%s", filename_type, filename_size,
+              file_path.DebugStr().c_str());
 
     cmd_buff[1] = DeleteFileFromArchive(archive_handle, file_path).raw;
 }
@@ -181,22 +185,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]);
-    u32 src_filename_size      = cmd_buff[5];
-    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];
-    u32 src_filename_ptr       = cmd_buff[11];
-    u32 dest_filename_ptr      = cmd_buff[13];
+    auto src_filename_type = static_cast<FileSys::LowPathType>(cmd_buff[4]);
+    u32 src_filename_size = cmd_buff[5];
+    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];
+    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 +222,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]);
-    u32 dirname_size      = cmd_buff[5];
-    u32 dirname_ptr       = cmd_buff[7];
+    auto dirname_type = static_cast<FileSys::LowPathType>(cmd_buff[4]);
+    u32 dirname_size = cmd_buff[5];
+    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",
-              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] = DeleteDirectoryFromArchive(archive_handle, dir_path).raw;
 }
@@ -243,14 +251,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]);
-    u32 filename_size     = cmd_buff[5];
-    u64 file_size         = ((u64)cmd_buff[8] << 32) | cmd_buff[7];
-    u32 filename_ptr      = cmd_buff[10];
+    auto filename_type = static_cast<FileSys::LowPathType>(cmd_buff[4]);
+    u32 filename_size = cmd_buff[5];
+    u64 file_size = ((u64)cmd_buff[8] << 32) | cmd_buff[7];
+    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 +285,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 +311,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]);
-    u32 src_dirname_size       = cmd_buff[5];
+    auto src_dirname_type = static_cast<FileSys::LowPathType>(cmd_buff[4]);
+    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]);
-    u32 dest_dirname_size      = cmd_buff[9];
-    u32 src_dirname_ptr        = cmd_buff[11];
-    u32 dest_dirname_ptr       = cmd_buff[13];
+    auto dest_dirname_type = static_cast<FileSys::LowPathType>(cmd_buff[8]);
+    u32 dest_dirname_size = cmd_buff[9];
+    u32 src_dirname_ptr = cmd_buff[11];
+    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 +355,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 +384,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_ptr   = cmd_buff[5];
+    u32 archivename_size = cmd_buff[3];
+    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 +400,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 +487,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 +588,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 "
-            "cmd_buff[4]=%08X cmd_buff[5]=%08X cmd_buff[6]=%08X cmd_buff[7]=%08X cmd_buff[8]=%08X "
-            "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);
+    LOG_WARNING(
+        Service_FS,
+        "(STUBBED) savedata_high=%08X savedata_low=%08X cmd_buff[3]=%08X "
+        "cmd_buff[4]=%08X cmd_buff[5]=%08X cmd_buff[6]=%08X cmd_buff[7]=%08X cmd_buff[8]=%08X "
+        "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 +624,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 +682,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 "
-            "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]);
+    LOG_WARNING(
+        Service_FS,
+        "(STUBBED) savedata_high=%08X savedata_low=%08X cmd_buff[3]=%08X "
+        "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 +715,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 "
-            "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]);
+    LOG_WARNING(
+        Service_FS,
+        "(STUBBED) savedata_id=%08X cmd_buff[3]=%08X "
+        "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 +747,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",
-                unk1, unk2, unk3);
+    LOG_WARNING(Service_FS, "(STUBBED) called unk1=0x%08X, unk2=0x%08X, unk3=0x%08X", unk1, unk2,
+                unk3);
 }
 
 /**
@@ -834,114 +860,114 @@ static void GetFormatInfo(Service::Interface* self) {
 }
 
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x000100C6, nullptr,                  "Dummy1"},
-    {0x040100C4, nullptr,                  "Control"},
-    {0x08010002, Initialize,               "Initialize"},
-    {0x080201C2, OpenFile,                 "OpenFile"},
-    {0x08030204, OpenFileDirectly,         "OpenFileDirectly"},
-    {0x08040142, DeleteFile,               "DeleteFile"},
-    {0x08050244, RenameFile,               "RenameFile"},
-    {0x08060142, DeleteDirectory,          "DeleteDirectory"},
-    {0x08070142, nullptr,                  "DeleteDirectoryRecursively"},
-    {0x08080202, CreateFile,               "CreateFile"},
-    {0x08090182, CreateDirectory,          "CreateDirectory"},
-    {0x080A0244, RenameDirectory,          "RenameDirectory"},
-    {0x080B0102, OpenDirectory,            "OpenDirectory"},
-    {0x080C00C2, OpenArchive,              "OpenArchive"},
-    {0x080D0144, nullptr,                  "ControlArchive"},
-    {0x080E0080, CloseArchive,             "CloseArchive"},
-    {0x080F0180, FormatThisUserSaveData,   "FormatThisUserSaveData"},
+    {0x000100C6, nullptr, "Dummy1"},
+    {0x040100C4, nullptr, "Control"},
+    {0x08010002, Initialize, "Initialize"},
+    {0x080201C2, OpenFile, "OpenFile"},
+    {0x08030204, OpenFileDirectly, "OpenFileDirectly"},
+    {0x08040142, DeleteFile, "DeleteFile"},
+    {0x08050244, RenameFile, "RenameFile"},
+    {0x08060142, DeleteDirectory, "DeleteDirectory"},
+    {0x08070142, nullptr, "DeleteDirectoryRecursively"},
+    {0x08080202, CreateFile, "CreateFile"},
+    {0x08090182, CreateDirectory, "CreateDirectory"},
+    {0x080A0244, RenameDirectory, "RenameDirectory"},
+    {0x080B0102, OpenDirectory, "OpenDirectory"},
+    {0x080C00C2, OpenArchive, "OpenArchive"},
+    {0x080D0144, nullptr, "ControlArchive"},
+    {0x080E0080, CloseArchive, "CloseArchive"},
+    {0x080F0180, FormatThisUserSaveData, "FormatThisUserSaveData"},
     {0x08100200, CreateLegacySystemSaveData, "CreateLegacySystemSaveData"},
-    {0x08110040, nullptr,                  "DeleteSystemSaveData"},
-    {0x08120080, GetFreeBytes,             "GetFreeBytes"},
-    {0x08130000, nullptr,                  "GetCardType"},
-    {0x08140000, nullptr,                  "GetSdmcArchiveResource"},
-    {0x08150000, nullptr,                  "GetNandArchiveResource"},
-    {0x08160000, nullptr,                  "GetSdmcFatfsError"},
-    {0x08170000, IsSdmcDetected,           "IsSdmcDetected"},
-    {0x08180000, IsSdmcWriteable,          "IsSdmcWritable"},
-    {0x08190042, nullptr,                  "GetSdmcCid"},
-    {0x081A0042, nullptr,                  "GetNandCid"},
-    {0x081B0000, nullptr,                  "GetSdmcSpeedInfo"},
-    {0x081C0000, nullptr,                  "GetNandSpeedInfo"},
-    {0x081D0042, nullptr,                  "GetSdmcLog"},
-    {0x081E0042, nullptr,                  "GetNandLog"},
-    {0x081F0000, nullptr,                  "ClearSdmcLog"},
-    {0x08200000, nullptr,                  "ClearNandLog"},
-    {0x08210000, CardSlotIsInserted,       "CardSlotIsInserted"},
-    {0x08220000, nullptr,                  "CardSlotPowerOn"},
-    {0x08230000, nullptr,                  "CardSlotPowerOff"},
-    {0x08240000, nullptr,                  "CardSlotGetCardIFPowerStatus"},
-    {0x08250040, nullptr,                  "CardNorDirectCommand"},
-    {0x08260080, nullptr,                  "CardNorDirectCommandWithAddress"},
-    {0x08270082, nullptr,                  "CardNorDirectRead"},
-    {0x082800C2, nullptr,                  "CardNorDirectReadWithAddress"},
-    {0x08290082, nullptr,                  "CardNorDirectWrite"},
-    {0x082A00C2, nullptr,                  "CardNorDirectWriteWithAddress"},
-    {0x082B00C2, nullptr,                  "CardNorDirectRead_4xIO"},
-    {0x082C0082, nullptr,                  "CardNorDirectCpuWriteWithoutVerify"},
-    {0x082D0040, nullptr,                  "CardNorDirectSectorEraseWithoutVerify"},
-    {0x082E0040, nullptr,                  "GetProductInfo"},
-    {0x082F0040, nullptr,                  "GetProgramLaunchInfo"},
-    {0x08300182, nullptr,                  "CreateExtSaveData"},
-    {0x08310180, nullptr,                  "CreateSharedExtSaveData"},
-    {0x08320102, nullptr,                  "ReadExtSaveDataIcon"},
-    {0x08330082, nullptr,                  "EnumerateExtSaveData"},
-    {0x08340082, nullptr,                  "EnumerateSharedExtSaveData"},
-    {0x08350080, nullptr,                  "DeleteExtSaveData"},
-    {0x08360080, nullptr,                  "DeleteSharedExtSaveData"},
-    {0x08370040, nullptr,                  "SetCardSpiBaudRate"},
-    {0x08380040, nullptr,                  "SetCardSpiBusMode"},
-    {0x08390000, nullptr,                  "SendInitializeInfoTo9"},
-    {0x083A0100, nullptr,                  "GetSpecialContentIndex"},
-    {0x083B00C2, nullptr,                  "GetLegacyRomHeader"},
-    {0x083C00C2, nullptr,                  "GetLegacyBannerData"},
-    {0x083D0100, nullptr,                  "CheckAuthorityToAccessExtSaveData"},
-    {0x083E00C2, nullptr,                  "QueryTotalQuotaSize"},
-    {0x083F00C0, nullptr,                  "GetExtDataBlockSize"},
-    {0x08400040, nullptr,                  "AbnegateAccessRight"},
-    {0x08410000, nullptr,                  "DeleteSdmcRoot"},
-    {0x08420040, nullptr,                  "DeleteAllExtSaveDataOnNand"},
-    {0x08430000, nullptr,                  "InitializeCtrFileSystem"},
-    {0x08440000, nullptr,                  "CreateSeed"},
-    {0x084500C2, GetFormatInfo,            "GetFormatInfo"},
-    {0x08460102, nullptr,                  "GetLegacyRomHeader2"},
-    {0x08470180, nullptr,                  "FormatCtrCardUserSaveData"},
-    {0x08480042, nullptr,                  "GetSdmcCtrRootPath"},
-    {0x08490040, GetArchiveResource,       "GetArchiveResource"},
-    {0x084A0002, nullptr,                  "ExportIntegrityVerificationSeed"},
-    {0x084B0002, nullptr,                  "ImportIntegrityVerificationSeed"},
-    {0x084C0242, FormatSaveData,           "FormatSaveData"},
-    {0x084D0102, nullptr,                  "GetLegacySubBannerData"},
-    {0x084E0342, nullptr,                  "UpdateSha256Context"},
-    {0x084F0102, nullptr,                  "ReadSpecialFile"},
-    {0x08500040, nullptr,                  "GetSpecialFileSize"},
-    {0x08510242, CreateExtSaveData,        "CreateExtSaveData"},
-    {0x08520100, DeleteExtSaveData,        "DeleteExtSaveData"},
-    {0x08530142, nullptr,                  "ReadExtSaveDataIcon"},
-    {0x085400C0, nullptr,                  "GetExtDataBlockSize"},
-    {0x08550102, nullptr,                  "EnumerateExtSaveData"},
-    {0x08560240, CreateSystemSaveData,     "CreateSystemSaveData"},
-    {0x08570080, DeleteSystemSaveData,     "DeleteSystemSaveData"},
-    {0x08580000, nullptr,                  "StartDeviceMoveAsSource"},
-    {0x08590200, nullptr,                  "StartDeviceMoveAsDestination"},
-    {0x085A00C0, nullptr,                  "SetArchivePriority"},
-    {0x085B0080, nullptr,                  "GetArchivePriority"},
-    {0x085C00C0, nullptr,                  "SetCtrCardLatencyParameter"},
-    {0x085D01C0, nullptr,                  "SetFsCompatibilityInfo"},
-    {0x085E0040, nullptr,                  "ResetCardCompatibilityParameter"},
-    {0x085F0040, nullptr,                  "SwitchCleanupInvalidSaveData"},
-    {0x08600042, nullptr,                  "EnumerateSystemSaveData"},
+    {0x08110040, nullptr, "DeleteSystemSaveData"},
+    {0x08120080, GetFreeBytes, "GetFreeBytes"},
+    {0x08130000, nullptr, "GetCardType"},
+    {0x08140000, nullptr, "GetSdmcArchiveResource"},
+    {0x08150000, nullptr, "GetNandArchiveResource"},
+    {0x08160000, nullptr, "GetSdmcFatfsError"},
+    {0x08170000, IsSdmcDetected, "IsSdmcDetected"},
+    {0x08180000, IsSdmcWriteable, "IsSdmcWritable"},
+    {0x08190042, nullptr, "GetSdmcCid"},
+    {0x081A0042, nullptr, "GetNandCid"},
+    {0x081B0000, nullptr, "GetSdmcSpeedInfo"},
+    {0x081C0000, nullptr, "GetNandSpeedInfo"},
+    {0x081D0042, nullptr, "GetSdmcLog"},
+    {0x081E0042, nullptr, "GetNandLog"},
+    {0x081F0000, nullptr, "ClearSdmcLog"},
+    {0x08200000, nullptr, "ClearNandLog"},
+    {0x08210000, CardSlotIsInserted, "CardSlotIsInserted"},
+    {0x08220000, nullptr, "CardSlotPowerOn"},
+    {0x08230000, nullptr, "CardSlotPowerOff"},
+    {0x08240000, nullptr, "CardSlotGetCardIFPowerStatus"},
+    {0x08250040, nullptr, "CardNorDirectCommand"},
+    {0x08260080, nullptr, "CardNorDirectCommandWithAddress"},
+    {0x08270082, nullptr, "CardNorDirectRead"},
+    {0x082800C2, nullptr, "CardNorDirectReadWithAddress"},
+    {0x08290082, nullptr, "CardNorDirectWrite"},
+    {0x082A00C2, nullptr, "CardNorDirectWriteWithAddress"},
+    {0x082B00C2, nullptr, "CardNorDirectRead_4xIO"},
+    {0x082C0082, nullptr, "CardNorDirectCpuWriteWithoutVerify"},
+    {0x082D0040, nullptr, "CardNorDirectSectorEraseWithoutVerify"},
+    {0x082E0040, nullptr, "GetProductInfo"},
+    {0x082F0040, nullptr, "GetProgramLaunchInfo"},
+    {0x08300182, nullptr, "CreateExtSaveData"},
+    {0x08310180, nullptr, "CreateSharedExtSaveData"},
+    {0x08320102, nullptr, "ReadExtSaveDataIcon"},
+    {0x08330082, nullptr, "EnumerateExtSaveData"},
+    {0x08340082, nullptr, "EnumerateSharedExtSaveData"},
+    {0x08350080, nullptr, "DeleteExtSaveData"},
+    {0x08360080, nullptr, "DeleteSharedExtSaveData"},
+    {0x08370040, nullptr, "SetCardSpiBaudRate"},
+    {0x08380040, nullptr, "SetCardSpiBusMode"},
+    {0x08390000, nullptr, "SendInitializeInfoTo9"},
+    {0x083A0100, nullptr, "GetSpecialContentIndex"},
+    {0x083B00C2, nullptr, "GetLegacyRomHeader"},
+    {0x083C00C2, nullptr, "GetLegacyBannerData"},
+    {0x083D0100, nullptr, "CheckAuthorityToAccessExtSaveData"},
+    {0x083E00C2, nullptr, "QueryTotalQuotaSize"},
+    {0x083F00C0, nullptr, "GetExtDataBlockSize"},
+    {0x08400040, nullptr, "AbnegateAccessRight"},
+    {0x08410000, nullptr, "DeleteSdmcRoot"},
+    {0x08420040, nullptr, "DeleteAllExtSaveDataOnNand"},
+    {0x08430000, nullptr, "InitializeCtrFileSystem"},
+    {0x08440000, nullptr, "CreateSeed"},
+    {0x084500C2, GetFormatInfo, "GetFormatInfo"},
+    {0x08460102, nullptr, "GetLegacyRomHeader2"},
+    {0x08470180, nullptr, "FormatCtrCardUserSaveData"},
+    {0x08480042, nullptr, "GetSdmcCtrRootPath"},
+    {0x08490040, GetArchiveResource, "GetArchiveResource"},
+    {0x084A0002, nullptr, "ExportIntegrityVerificationSeed"},
+    {0x084B0002, nullptr, "ImportIntegrityVerificationSeed"},
+    {0x084C0242, FormatSaveData, "FormatSaveData"},
+    {0x084D0102, nullptr, "GetLegacySubBannerData"},
+    {0x084E0342, nullptr, "UpdateSha256Context"},
+    {0x084F0102, nullptr, "ReadSpecialFile"},
+    {0x08500040, nullptr, "GetSpecialFileSize"},
+    {0x08510242, CreateExtSaveData, "CreateExtSaveData"},
+    {0x08520100, DeleteExtSaveData, "DeleteExtSaveData"},
+    {0x08530142, nullptr, "ReadExtSaveDataIcon"},
+    {0x085400C0, nullptr, "GetExtDataBlockSize"},
+    {0x08550102, nullptr, "EnumerateExtSaveData"},
+    {0x08560240, CreateSystemSaveData, "CreateSystemSaveData"},
+    {0x08570080, DeleteSystemSaveData, "DeleteSystemSaveData"},
+    {0x08580000, nullptr, "StartDeviceMoveAsSource"},
+    {0x08590200, nullptr, "StartDeviceMoveAsDestination"},
+    {0x085A00C0, nullptr, "SetArchivePriority"},
+    {0x085B0080, nullptr, "GetArchivePriority"},
+    {0x085C00C0, nullptr, "SetCtrCardLatencyParameter"},
+    {0x085D01C0, nullptr, "SetFsCompatibilityInfo"},
+    {0x085E0040, nullptr, "ResetCardCompatibilityParameter"},
+    {0x085F0040, nullptr, "SwitchCleanupInvalidSaveData"},
+    {0x08600042, nullptr, "EnumerateSystemSaveData"},
     {0x08610042, InitializeWithSdkVersion, "InitializeWithSdkVersion"},
-    {0x08620040, SetPriority,              "SetPriority"},
-    {0x08630000, GetPriority,              "GetPriority"},
-    {0x08640000, nullptr,                  "GetNandInfo"},
-    {0x08650140, nullptr,                  "SetSaveDataSecureValue"},
-    {0x086600C0, nullptr,                  "GetSaveDataSecureValue"},
-    {0x086700C4, nullptr,                  "ControlSecureSave"},
-    {0x08680000, nullptr,                  "GetMediaType"},
-    {0x08690000, nullptr,                  "GetNandEraseCount"},
-    {0x086A0082, nullptr,                  "ReadNandReport"}
+    {0x08620040, SetPriority, "SetPriority"},
+    {0x08630000, GetPriority, "GetPriority"},
+    {0x08640000, nullptr, "GetNandInfo"},
+    {0x08650140, nullptr, "SetSaveDataSecureValue"},
+    {0x086600C0, nullptr, "GetSaveDataSecureValue"},
+    {0x086700C4, nullptr, "ControlSecureSave"},
+    {0x08680000, nullptr, "GetMediaType"},
+    {0x08690000, nullptr, "GetNandEraseCount"},
+    {0x086A0082, nullptr, "ReadNandReport"},
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/gsp_gpu.cpp b/src/core/hle/service/gsp_gpu.cpp
index ec565f46d..710e0e485 100644
--- a/src/core/hle/service/gsp_gpu.cpp
+++ b/src/core/hle/service/gsp_gpu.cpp
@@ -4,19 +4,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 "video_core/gpu_debugger.h"
-#include "video_core/debug_utils/debug_utils.h"
-
+#include "core/memory.h"
 #include "gsp_gpu.h"
+#include "video_core/debug_utils/debug_utils.h"
+#include "video_core/gpu_debugger.h"
 
 // Main graphics debugger object - TODO: Here is probably not the best place for this
 GraphicsDebugger g_debugger;
@@ -29,12 +26,15 @@ const static u32 REGS_BEGIN = 0x1EB00000;
 
 namespace GSP_GPU {
 
-const ResultCode ERR_GSP_REGS_OUTOFRANGE_OR_MISALIGNED(ErrorDescription::OutofRangeOrMisalignedAddress, ErrorModule::GX,
-    ErrorSummary::InvalidArgument, ErrorLevel::Usage); // 0xE0E02A01
+const ResultCode 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 +73,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 +91,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 +126,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 +218,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 +248,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)),
-                         phys_address_left);
-        WriteSingleHWReg(base_address + 4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].address_right1)),
-                         phys_address_right);
+        WriteSingleHWReg(
+            base_address +
+                4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].address_left1)),
+            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)),
-                         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].address_left2)),
+            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)),
-                     info.format);
-    WriteSingleHWReg(base_address + 4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].active_fb)),
-                     info.shown_fb);
+    WriteSingleHWReg(
+        base_address +
+            4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].color_format)),
+        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 +322,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",
-              address, size, process);
+    LOG_DEBUG(Service_GSP, "(STUBBED) called address=0x%08X, size=0x%08X, process=0x%08X", address,
+              size, process);
 }
 
 /**
@@ -356,11 +373,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 +434,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 +459,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
-        Memory::RasterizerFlushRegion(Memory::VirtualToPhysicalAddress(command.dma_request.source_address),
-                            command.dma_request.size);
-        Memory::RasterizerFlushAndInvalidateRegion(Memory::VirtualToPhysicalAddress(command.dma_request.dest_address),
-                            command.dma_request.size);
+        // TODO: Consider attempting rasterizer-accelerated surface blit if that usage is ever
+        // possible/likely
+        Memory::RasterizerFlushRegion(
+            Memory::VirtualToPhysicalAddress(command.dma_request.source_address),
+            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 +489,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);
-        WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(command_processor_config.size)), params.size);
+                         Memory::VirtualToPhysicalAddress(params.address) >> 3);
+        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 +504,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);
-            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].control)), params.control1);
+                             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].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);
-            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].control)), params.control2);
+                             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].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);
-        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.output_size)), params.out_buffer_size);
-        WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(display_transfer_config.flags)), params.flags);
+                         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.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);
-        WriteGPURegister((u32)GPU_REG_INDEX(display_transfer_config.flags),
-                params.flags);
+                         params.out_width_gap);
+        WriteGPURegister((u32)GPU_REG_INDEX(display_transfer_config.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 +578,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 +602,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 +706,37 @@ static void ReleaseRight(Service::Interface* self) {
 }
 
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010082, WriteHWRegs,                   "WriteHWRegs"},
-    {0x00020084, WriteHWRegsWithMask,           "WriteHWRegsWithMask"},
-    {0x00030082, nullptr,                       "WriteHWRegRepeat"},
-    {0x00040080, ReadHWRegs,                    "ReadHWRegs"},
-    {0x00050200, SetBufferSwap,                 "SetBufferSwap"},
-    {0x00060082, nullptr,                       "SetCommandList"},
-    {0x000700C2, nullptr,                       "RequestDma"},
-    {0x00080082, FlushDataCache,                "FlushDataCache"},
-    {0x00090082, nullptr,                       "InvalidateDataCache"},
-    {0x000A0044, nullptr,                       "RegisterInterruptEvents"},
-    {0x000B0040, SetLcdForceBlack,              "SetLcdForceBlack"},
-    {0x000C0000, TriggerCmdReqQueue,            "TriggerCmdReqQueue"},
-    {0x000D0140, nullptr,                       "SetDisplayTransfer"},
-    {0x000E0180, nullptr,                       "SetTextureCopy"},
-    {0x000F0200, nullptr,                       "SetMemoryFill"},
-    {0x00100040, SetAxiConfigQoSMode,           "SetAxiConfigQoSMode"},
-    {0x00110040, nullptr,                       "SetPerfLogMode"},
-    {0x00120000, nullptr,                       "GetPerfLog"},
-    {0x00130042, RegisterInterruptRelayQueue,   "RegisterInterruptRelayQueue"},
+    {0x00010082, WriteHWRegs, "WriteHWRegs"},
+    {0x00020084, WriteHWRegsWithMask, "WriteHWRegsWithMask"},
+    {0x00030082, nullptr, "WriteHWRegRepeat"},
+    {0x00040080, ReadHWRegs, "ReadHWRegs"},
+    {0x00050200, SetBufferSwap, "SetBufferSwap"},
+    {0x00060082, nullptr, "SetCommandList"},
+    {0x000700C2, nullptr, "RequestDma"},
+    {0x00080082, FlushDataCache, "FlushDataCache"},
+    {0x00090082, nullptr, "InvalidateDataCache"},
+    {0x000A0044, nullptr, "RegisterInterruptEvents"},
+    {0x000B0040, SetLcdForceBlack, "SetLcdForceBlack"},
+    {0x000C0000, TriggerCmdReqQueue, "TriggerCmdReqQueue"},
+    {0x000D0140, nullptr, "SetDisplayTransfer"},
+    {0x000E0180, nullptr, "SetTextureCopy"},
+    {0x000F0200, nullptr, "SetMemoryFill"},
+    {0x00100040, SetAxiConfigQoSMode, "SetAxiConfigQoSMode"},
+    {0x00110040, nullptr, "SetPerfLogMode"},
+    {0x00120000, nullptr, "GetPerfLog"},
+    {0x00130042, RegisterInterruptRelayQueue, "RegisterInterruptRelayQueue"},
     {0x00140000, UnregisterInterruptRelayQueue, "UnregisterInterruptRelayQueue"},
-    {0x00150002, nullptr,                       "TryAcquireRight"},
-    {0x00160042, AcquireRight,                  "AcquireRight"},
-    {0x00170000, ReleaseRight,                  "ReleaseRight"},
-    {0x00180000, ImportDisplayCaptureInfo,      "ImportDisplayCaptureInfo"},
-    {0x00190000, nullptr,                       "SaveVramSysArea"},
-    {0x001A0000, nullptr,                       "RestoreVramSysArea"},
-    {0x001B0000, nullptr,                       "ResetGpuCore"},
-    {0x001C0040, nullptr,                       "SetLedForceOff"},
-    {0x001D0040, nullptr,                       "SetTestCommand"},
-    {0x001E0080, nullptr,                       "SetInternalPriorities"},
-    {0x001F0082, nullptr,                       "StoreDataCache"},
+    {0x00150002, nullptr, "TryAcquireRight"},
+    {0x00160042, AcquireRight, "AcquireRight"},
+    {0x00170000, ReleaseRight, "ReleaseRight"},
+    {0x00180000, ImportDisplayCaptureInfo, "ImportDisplayCaptureInfo"},
+    {0x00190000, nullptr, "SaveVramSysArea"},
+    {0x001A0000, nullptr, "RestoreVramSysArea"},
+    {0x001B0000, nullptr, "ResetGpuCore"},
+    {0x001C0040, nullptr, "SetLedForceOff"},
+    {0x001D0040, nullptr, "SetTestCommand"},
+    {0x001E0080, nullptr, "SetInternalPriorities"},
+    {0x001F0082, nullptr, "StoreDataCache"},
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -721,9 +748,9 @@ Interface::Interface() {
     g_interrupt_event = nullptr;
 
     using Kernel::MemoryPermission;
-    g_shared_memory = Kernel::SharedMemory::Create(nullptr, 0x1000,
-                                                   MemoryPermission::ReadWrite, MemoryPermission::ReadWrite,
-                                                   0, Kernel::MemoryRegion::BASE, "GSP:SharedMemory");
+    g_shared_memory = Kernel::SharedMemory::Create(nullptr, 0x1000, MemoryPermission::ReadWrite,
+                                                   MemoryPermission::ReadWrite, 0,
+                                                   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..79a72f77d 100644
--- a/src/core/hle/service/gsp_gpu.h
+++ b/src/core/hle/service/gsp_gpu.h
@@ -6,10 +6,8 @@
 
 #include <cstddef>
 #include <string>
-
 #include "common/bit_field.h"
 #include "common/common_types.h"
-
 #include "core/hle/result.h"
 #include "core/hle/service/service.h"
 
@@ -20,30 +18,30 @@ namespace GSP_GPU {
 
 /// GSP interrupt ID
 enum class InterruptId : u8 {
-    PSC0    = 0x00,
-    PSC1    = 0x01,
-    PDC0    = 0x02, // Seems called every vertical screen line
-    PDC1    = 0x03, // Seems called every frame
-    PPF     = 0x04,
-    P3D     = 0x05,
-    DMA     = 0x06,
+    PSC0 = 0x00,
+    PSC1 = 0x01,
+    PDC0 = 0x02, // Seems called every vertical screen line
+    PDC1 = 0x03, // Seems called every frame
+    PPF = 0x04,
+    P3D = 0x05,
+    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 +59,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,
-    "InterruptRelayQueue struct has incorrect size");
+static_assert(sizeof(InterruptRelayQueue) == 0x40, "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 format;    // maps to 0x1EF00X70 ?
-    u32 shown_fb;  // maps to 0x1EF00X78 ?
+    u32 stride;   // maps to 0x1EF00X90 ?
+    u32 format;   // maps to 0x1EF00X70 ?
+    u32 shown_fb; // maps to 0x1EF00X78 ?
     u32 unknown;
 };
 static_assert(sizeof(FrameBufferInfo) == 0x1c, "Struct has incorrect size");
@@ -91,7 +88,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 +161,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..b916dd759 100644
--- a/src/core/hle/service/gsp_lcd.cpp
+++ b/src/core/hle/service/gsp_lcd.cpp
@@ -10,11 +10,13 @@
 namespace GSP_LCD {
 
 const Interface::FunctionInfo FunctionTable[] = {
+    // clang-format off
     {0x000F0000, nullptr, "PowerOnAllBacklights"},
     {0x00100000, nullptr, "PowerOffAllBacklights"},
     {0x00110040, nullptr, "PowerOnBacklight"},
     {0x00120040, nullptr, "PowerOffBacklight"},
-    {0x00130040, nullptr, "SetLedForceOff"}
+    {0x00130040, nullptr, "SetLedForceOff"},
+    // clang-format on
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index cdec11388..99baded11 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -3,19 +3,15 @@
 // Refer to the license.txt file included.
 
 #include <cmath>
-
-#include "common/logging/log.h"
 #include "common/emu_window.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 "common/logging/log.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/shared_memory.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 "video_core/video_core.h"
 
 namespace Service {
@@ -37,11 +33,13 @@ 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 int CIRCLE_PAD_THRESHOLD_SQUARE = 40 * 40; // a circle pad radius greater than 40 will trigger circle pad direction
+    // 30 degree and 60 degree are angular thresholds for directions
+    constexpr float TAN30 = 0.577350269, TAN60 = 1 / TAN30;
+    // a circle pad radius greater than 40 will trigger circle pad direction
+    constexpr int CIRCLE_PAD_THRESHOLD_SQUARE = 40 * 40;
     PadState state;
     state.hex = 0;
 
@@ -90,7 +88,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 +133,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];
-        std::tie(accelerometer_entry.x, accelerometer_entry.y, accelerometer_entry.z)
-            = VideoCore::g_emu_window->GetAccelerometerState();
+        AccelerometerDataEntry& accelerometer_entry =
+            mem->accelerometer.entries[mem->accelerometer.index];
+        std::tie(accelerometer_entry.x, accelerometer_entry.y, accelerometer_entry.z) =
+            VideoCore::g_emu_window->GetAccelerometerState();
 
         // Make up "raw" entry
         // TODO(wwylele):
@@ -167,8 +167,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)
-            = VideoCore::g_emu_window->GetGyroscopeState();
+        std::tie(gyroscope_entry.x, gyroscope_entry.y, gyroscope_entry.z) =
+            VideoCore::g_emu_window->GetGyroscopeState();
 
         // Make up "raw" entry
         mem->gyroscope.raw_entry.x = gyroscope_entry.x;
@@ -188,7 +188,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 +259,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 +284,9 @@ void Init() {
     AddService(new HID_SPVR_Interface);
 
     using Kernel::MemoryPermission;
-    shared_mem = SharedMemory::Create(nullptr, 0x1000,
-                                      MemoryPermission::ReadWrite, MemoryPermission::Read,
-                                      0, Kernel::MemoryRegion::BASE, "HID:SharedMemory");
+    shared_mem =
+        SharedMemory::Create(nullptr, 0x1000, MemoryPermission::ReadWrite, MemoryPermission::Read,
+                             0, Kernel::MemoryRegion::BASE, "HID:SharedMemory");
 
     next_pad_index = 0;
     next_touch_index = 0;
@@ -296,9 +294,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_gyroscope      = Event::Create(ResetType::OneShot, "HID:EventGyroscope");
-    event_debug_pad      = Event::Create(ResetType::OneShot, "HID:EventDebugPad");
+    event_accelerometer = Event::Create(ResetType::OneShot, "HID:EventAccelerometer");
+    event_gyroscope = Event::Create(ResetType::OneShot, "HID:EventGyroscope");
+    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..7904e7355 100644
--- a/src/core/hle/service/hid/hid.h
+++ b/src/core/hle/service/hid/hid.h
@@ -5,14 +5,13 @@
 #pragma once
 
 #include <array>
-
 #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 +102,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 +120,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 +134,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 +148,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 +175,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)                  \
-    static_assert(offsetof(SharedMem, field_name) == position * 4, \
-                  "Field "#field_name" has invalid position")
+#define ASSERT_REG_POSITION(field_name, position)                                                  \
+    static_assert(offsetof(SharedMem, field_name) == position * 4,                                 \
+                  "Field " #field_name " has invalid position")
 
 ASSERT_REG_POSITION(pad.index_reset_ticks, 0x0);
 ASSERT_REG_POSITION(touch.index_reset_ticks, 0x2A);
@@ -187,33 +186,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_A            = {{1u << 0}};
-const PadState PAD_B            = {{1u << 1}};
-const PadState PAD_SELECT       = {{1u << 2}};
-const PadState PAD_START        = {{1u << 3}};
-const PadState PAD_RIGHT        = {{1u << 4}};
-const PadState PAD_LEFT         = {{1u << 5}};
-const PadState PAD_UP           = {{1u << 6}};
-const PadState PAD_DOWN         = {{1u << 7}};
-const PadState PAD_R            = {{1u << 8}};
-const PadState PAD_L            = {{1u << 9}};
-const PadState PAD_X            = {{1u << 10}};
-const PadState PAD_Y            = {{1u << 11}};
-
-const PadState PAD_ZL           = {{1u << 14}};
-const PadState PAD_ZR           = {{1u << 15}};
-
-const PadState PAD_TOUCH        = {{1u << 20}};
-
-const PadState PAD_C_RIGHT      = {{1u << 24}};
-const PadState PAD_C_LEFT       = {{1u << 25}};
-const PadState PAD_C_UP         = {{1u << 26}};
-const PadState PAD_C_DOWN       = {{1u << 27}};
+const PadState PAD_NONE = {{0}};
+const PadState PAD_A = {{1u << 0}};
+const PadState PAD_B = {{1u << 1}};
+const PadState PAD_SELECT = {{1u << 2}};
+const PadState PAD_START = {{1u << 3}};
+const PadState PAD_RIGHT = {{1u << 4}};
+const PadState PAD_LEFT = {{1u << 5}};
+const PadState PAD_UP = {{1u << 6}};
+const PadState PAD_DOWN = {{1u << 7}};
+const PadState PAD_R = {{1u << 8}};
+const PadState PAD_L = {{1u << 9}};
+const PadState PAD_X = {{1u << 10}};
+const PadState PAD_Y = {{1u << 11}};
+
+const PadState PAD_ZL = {{1u << 14}};
+const PadState PAD_ZR = {{1u << 15}};
+
+const PadState PAD_TOUCH = {{1u << 20}};
+
+const PadState PAD_C_RIGHT = {{1u << 24}};
+const PadState PAD_C_LEFT = {{1u << 25}};
+const PadState PAD_C_UP = {{1u << 26}};
+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_UP    = {{1u << 30}};
-const PadState PAD_CIRCLE_DOWN  = {{1u << 31}};
+const PadState PAD_CIRCLE_LEFT = {{1u << 29}};
+const PadState PAD_CIRCLE_UP = {{1u << 30}};
+const PadState PAD_CIRCLE_DOWN = {{1u << 31}};
 
 /**
  * HID::GetIPCHandles service function
@@ -305,6 +304,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"},
-    {0x000B0000, nullptr,                            "StartAnalogStickCalibration"},
-    {0x000E0000, nullptr,                            "GetAnalogStickCalibrateParam"},
-    {0x00110000, EnableAccelerometer,                "EnableAccelerometer"},
-    {0x00120000, DisableAccelerometer,               "DisableAccelerometer"},
-    {0x00130000, EnableGyroscopeLow,                 "EnableGyroscopeLow"},
-    {0x00140000, DisableGyroscopeLow,                "DisableGyroscopeLow"},
+    {0x000A0000, GetIPCHandles, "GetIPCHandles"},
+    {0x000B0000, nullptr, "StartAnalogStickCalibration"},
+    {0x000E0000, nullptr, "GetAnalogStickCalibrateParam"},
+    {0x00110000, EnableAccelerometer, "EnableAccelerometer"},
+    {0x00120000, DisableAccelerometer, "DisableAccelerometer"},
+    {0x00130000, EnableGyroscopeLow, "EnableGyroscopeLow"},
+    {0x00140000, DisableGyroscopeLow, "DisableGyroscopeLow"},
     {0x00150000, GetGyroscopeLowRawToDpsCoefficient, "GetGyroscopeLowRawToDpsCoefficient"},
-    {0x00160000, GetGyroscopeLowCalibrateParam,      "GetGyroscopeLowCalibrateParam"},
-    {0x00170000, GetSoundVolume,                     "GetSoundVolume"},
+    {0x00160000, GetGyroscopeLowCalibrateParam, "GetGyroscopeLowCalibrateParam"},
+    {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"},
-    {0x000B0000, nullptr,                            "StartAnalogStickCalibration"},
-    {0x000E0000, nullptr,                            "GetAnalogStickCalibrateParam"},
-    {0x00110000, EnableAccelerometer,                "EnableAccelerometer"},
-    {0x00120000, DisableAccelerometer,               "DisableAccelerometer"},
-    {0x00130000, EnableGyroscopeLow,                 "EnableGyroscopeLow"},
-    {0x00140000, DisableGyroscopeLow,                "DisableGyroscopeLow"},
+    {0x000A0000, GetIPCHandles, "GetIPCHandles"},
+    {0x000B0000, nullptr, "StartAnalogStickCalibration"},
+    {0x000E0000, nullptr, "GetAnalogStickCalibrateParam"},
+    {0x00110000, EnableAccelerometer, "EnableAccelerometer"},
+    {0x00120000, DisableAccelerometer, "DisableAccelerometer"},
+    {0x00130000, EnableGyroscopeLow, "EnableGyroscopeLow"},
+    {0x00140000, DisableGyroscopeLow, "DisableGyroscopeLow"},
     {0x00150000, GetGyroscopeLowRawToDpsCoefficient, "GetGyroscopeLowRawToDpsCoefficient"},
-    {0x00160000, GetGyroscopeLowCalibrateParam,      "GetGyroscopeLowCalibrateParam"},
-    {0x00170000, GetSoundVolume,                     "GetSoundVolume"},
+    {0x00160000, GetGyroscopeLowCalibrateParam, "GetGyroscopeLowCalibrateParam"},
+    {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"},
-    {0x00020082, nullptr,                 "CreateContext"},
-    {0x00030040, nullptr,                 "CloseContext"},
-    {0x00040040, nullptr,                 "CancelConnection"},
-    {0x00050040, nullptr,                 "GetRequestState"},
-    {0x00060040, nullptr,                 "GetDownloadSizeState"},
-    {0x00070040, nullptr,                 "GetRequestError"},
-    {0x00080042, nullptr,                 "InitializeConnectionSession"},
-    {0x00090040, nullptr,                 "BeginRequest"},
-    {0x000A0040, nullptr,                 "BeginRequestAsync"},
-    {0x000B0082, nullptr,                 "ReceiveData"},
-    {0x000C0102, nullptr,                 "ReceiveDataTimeout"},
-    {0x000D0146, nullptr,                 "SetProxy"},
-    {0x000E0040, nullptr,                 "SetProxyDefault"},
-    {0x000F00C4, nullptr,                 "SetBasicAuthorization"},
-    {0x00100080, nullptr,                 "SetSocketBufferSize"},
-    {0x001100C4, nullptr,                 "AddRequestHeader"},
-    {0x001200C4, nullptr,                 "AddPostDataAscii"},
-    {0x001300C4, nullptr,                 "AddPostDataBinary"},
-    {0x00140082, nullptr,                 "AddPostDataRaw"},
-    {0x00150080, nullptr,                 "SetPostDataType"},
-    {0x001600C4, nullptr,                 "SendPostDataAscii"},
-    {0x00170144, nullptr,                 "SendPostDataAsciiTimeout"},
-    {0x001800C4, nullptr,                 "SendPostDataBinary"},
-    {0x00190144, nullptr,                 "SendPostDataBinaryTimeout"},
-    {0x001A0082, nullptr,                 "SendPostDataRaw"},
-    {0x001B0102, nullptr,                 "SendPOSTDataRawTimeout"},
-    {0x001C0080, nullptr,                 "SetPostDataEncoding"},
-    {0x001D0040, nullptr,                 "NotifyFinishSendPostData"},
-    {0x001E00C4, nullptr,                 "GetResponseHeader"},
-    {0x001F0144, nullptr,                 "GetResponseHeaderTimeout"},
-    {0x00200082, nullptr,                 "GetResponseData"},
-    {0x00210102, nullptr,                 "GetResponseDataTimeout"},
-    {0x00220040, nullptr,                 "GetResponseStatusCode"},
-    {0x002300C0, nullptr,                 "GetResponseStatusCodeTimeout"},
-    {0x00240082, nullptr,                 "AddTrustedRootCA"},
-    {0x00250080, nullptr,                 "AddDefaultCert"},
-    {0x00260080, nullptr,                 "SelectRootCertChain"},
-    {0x002700C4, nullptr,                 "SetClientCert"},
-    {0x002B0080, nullptr,                 "SetSSLOpt"},
-    {0x002C0080, nullptr,                 "SetSSLClearOpt"},
-    {0x002D0000, nullptr,                 "CreateRootCertChain"},
-    {0x002E0040, nullptr,                 "DestroyRootCertChain"},
-    {0x002F0082, nullptr,                 "RootCertChainAddCert"},
-    {0x00300080, nullptr,                 "RootCertChainAddDefaultCert"},
-    {0x00350186, nullptr,                 "SetDefaultProxy"},
-    {0x00360000, nullptr,                 "ClearDNSCache"},
-    {0x00370080, nullptr,                 "SetKeepAlive"},
-    {0x003800C0, nullptr,                 "SetPostDataTypeSize"},
-    {0x00390000, nullptr,                 "Finalize"},
+    {0x00010044, nullptr, "Initialize"},
+    {0x00020082, nullptr, "CreateContext"},
+    {0x00030040, nullptr, "CloseContext"},
+    {0x00040040, nullptr, "CancelConnection"},
+    {0x00050040, nullptr, "GetRequestState"},
+    {0x00060040, nullptr, "GetDownloadSizeState"},
+    {0x00070040, nullptr, "GetRequestError"},
+    {0x00080042, nullptr, "InitializeConnectionSession"},
+    {0x00090040, nullptr, "BeginRequest"},
+    {0x000A0040, nullptr, "BeginRequestAsync"},
+    {0x000B0082, nullptr, "ReceiveData"},
+    {0x000C0102, nullptr, "ReceiveDataTimeout"},
+    {0x000D0146, nullptr, "SetProxy"},
+    {0x000E0040, nullptr, "SetProxyDefault"},
+    {0x000F00C4, nullptr, "SetBasicAuthorization"},
+    {0x00100080, nullptr, "SetSocketBufferSize"},
+    {0x001100C4, nullptr, "AddRequestHeader"},
+    {0x001200C4, nullptr, "AddPostDataAscii"},
+    {0x001300C4, nullptr, "AddPostDataBinary"},
+    {0x00140082, nullptr, "AddPostDataRaw"},
+    {0x00150080, nullptr, "SetPostDataType"},
+    {0x001600C4, nullptr, "SendPostDataAscii"},
+    {0x00170144, nullptr, "SendPostDataAsciiTimeout"},
+    {0x001800C4, nullptr, "SendPostDataBinary"},
+    {0x00190144, nullptr, "SendPostDataBinaryTimeout"},
+    {0x001A0082, nullptr, "SendPostDataRaw"},
+    {0x001B0102, nullptr, "SendPOSTDataRawTimeout"},
+    {0x001C0080, nullptr, "SetPostDataEncoding"},
+    {0x001D0040, nullptr, "NotifyFinishSendPostData"},
+    {0x001E00C4, nullptr, "GetResponseHeader"},
+    {0x001F0144, nullptr, "GetResponseHeaderTimeout"},
+    {0x00200082, nullptr, "GetResponseData"},
+    {0x00210102, nullptr, "GetResponseDataTimeout"},
+    {0x00220040, nullptr, "GetResponseStatusCode"},
+    {0x002300C0, nullptr, "GetResponseStatusCodeTimeout"},
+    {0x00240082, nullptr, "AddTrustedRootCA"},
+    {0x00250080, nullptr, "AddDefaultCert"},
+    {0x00260080, nullptr, "SelectRootCertChain"},
+    {0x002700C4, nullptr, "SetClientCert"},
+    {0x002B0080, nullptr, "SetSSLOpt"},
+    {0x002C0080, nullptr, "SetSSLClearOpt"},
+    {0x002D0000, nullptr, "CreateRootCertChain"},
+    {0x002E0040, nullptr, "DestroyRootCertChain"},
+    {0x002F0082, nullptr, "RootCertChainAddCert"},
+    {0x00300080, nullptr, "RootCertChainAddDefaultCert"},
+    {0x00350186, nullptr, "SetDefaultProxy"},
+    {0x00360000, nullptr, "ClearDNSCache"},
+    {0x00370080, nullptr, "SetKeepAlive"},
+    {0x003800C0, nullptr, "SetPostDataTypeSize"},
+    {0x00390000, nullptr, "Finalize"},
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/ir/ir.cpp b/src/core/hle/service/ir/ir.cpp
index 079a87e48..4d6639ded 100644
--- a/src/core/hle/service/ir/ir.cpp
+++ b/src/core/hle/service/ir/ir.cpp
@@ -4,12 +4,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 +31,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 unk1               = cmd_buff[3];
-    u32 send_buff_size     = cmd_buff[4];
-    u32 unk2               = cmd_buff[5];
-    u8  baud_rate          = cmd_buff[6] & 0xFF;
-    Handle handle          = cmd_buff[8];
-
-    if(Kernel::g_handle_table.IsValid(handle)) {
+    u32 recv_buff_size = cmd_buff[2];
+    u32 unk1 = cmd_buff[3];
+    u32 send_buff_size = cmd_buff[4];
+    u32 unk2 = cmd_buff[5];
+    u8 baud_rate = cmd_buff[6] & 0xFF;
+    Handle handle = cmd_buff[8];
+
+    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 +46,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 +93,13 @@ void Init() {
     AddService(new IR_User_Interface);
 
     using Kernel::MemoryPermission;
-    shared_memory = SharedMemory::Create(nullptr, 0x1000,
-                                         Kernel::MemoryPermission::ReadWrite, Kernel::MemoryPermission::ReadWrite,
-                                         0, Kernel::MemoryRegion::BASE, "IR:SharedMemory");
+    shared_memory = SharedMemory::Create(nullptr, 0x1000, Kernel::MemoryPermission::ReadWrite,
+                                         Kernel::MemoryPermission::ReadWrite, 0,
+                                         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"},
-    {0x00020080, nullptr,                 "Initialize"},
-    {0x00030000, nullptr,                 "Shutdown"},
-    {0x00090000, nullptr,                 "WriteToTwoFields"},
+    {0x00010000, GetHandles, "GetHandles"},
+    {0x00020080, nullptr, "Initialize"},
+    {0x00030000, nullptr, "Shutdown"},
+    {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..429615f31 100644
--- a/src/core/hle/service/ir/ir_u.cpp
+++ b/src/core/hle/service/ir/ir_u.cpp
@@ -8,24 +8,26 @@ namespace Service {
 namespace IR {
 
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010000, nullptr,                 "Initialize"},
-    {0x00020000, nullptr,                 "Shutdown"},
-    {0x00030042, nullptr,                 "StartSendTransfer"},
-    {0x00040000, nullptr,                 "WaitSendTransfer"},
-    {0x000500C2, nullptr,                 "StartRecvTransfer"},
-    {0x00060000, nullptr,                 "WaitRecvTransfer"},
-    {0x00070080, nullptr,                 "GetRecvTransferCount"},
-    {0x00080000, nullptr,                 "GetSendState"},
-    {0x00090040, nullptr,                 "SetBitRate"},
-    {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"},
+    // clang-format off
+    {0x00010000, nullptr, "Initialize"},
+    {0x00020000, nullptr, "Shutdown"},
+    {0x00030042, nullptr, "StartSendTransfer"},
+    {0x00040000, nullptr, "WaitSendTransfer"},
+    {0x000500C2, nullptr, "StartRecvTransfer"},
+    {0x00060000, nullptr, "WaitRecvTransfer"},
+    {0x00070080, nullptr, "GetRecvTransferCount"},
+    {0x00080000, nullptr, "GetSendState"},
+    {0x00090040, nullptr, "SetBitRate"},
+    {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"},
+    // clang-format off
 };
 
 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"},
-    {0x00020000, FinalizeIrNop,            "FinalizeIrNop"},
-    {0x00030000, nullptr,                  "ClearReceiveBuffer"},
-    {0x00040000, nullptr,                  "ClearSendBuffer"},
-    {0x000500C0, nullptr,                  "WaitConnection"},
-    {0x00060040, RequireConnection,        "RequireConnection"},
-    {0x000702C0, nullptr,                  "AutoConnection"},
-    {0x00080000, nullptr,                  "AnyConnection"},
-    {0x00090000, Disconnect,               "Disconnect"},
-    {0x000A0000, nullptr,                  "GetReceiveEvent"},
-    {0x000B0000, nullptr,                  "GetSendEvent"},
+    {0x00010182, nullptr, "InitializeIrNop"},
+    {0x00020000, FinalizeIrNop, "FinalizeIrNop"},
+    {0x00030000, nullptr, "ClearReceiveBuffer"},
+    {0x00040000, nullptr, "ClearSendBuffer"},
+    {0x000500C0, nullptr, "WaitConnection"},
+    {0x00060040, RequireConnection, "RequireConnection"},
+    {0x000702C0, nullptr, "AutoConnection"},
+    {0x00080000, nullptr, "AnyConnection"},
+    {0x00090000, Disconnect, "Disconnect"},
+    {0x000A0000, nullptr, "GetReceiveEvent"},
+    {0x000B0000, nullptr, "GetSendEvent"},
     {0x000C0000, GetConnectionStatusEvent, "GetConnectionStatusEvent"},
-    {0x000D0042, nullptr,                  "SendIrNop"},
-    {0x000E0042, nullptr,                  "SendIrNopLarge"},
-    {0x000F0040, nullptr,                  "ReceiveIrnop"},
-    {0x00100042, nullptr,                  "ReceiveIrnopLarge"},
-    {0x00110040, nullptr,                  "GetLatestReceiveErrorResult"},
-    {0x00120040, nullptr,                  "GetLatestSendErrorResult"},
-    {0x00130000, nullptr,                  "GetConnectionStatus"},
-    {0x00140000, nullptr,                  "GetTryingToConnectStatus"},
-    {0x00150000, nullptr,                  "GetReceiveSizeFreeAndUsed"},
-    {0x00160000, nullptr,                  "GetSendSizeFreeAndUsed"},
-    {0x00170000, nullptr,                  "GetConnectionRole"},
-    {0x00180182, InitializeIrNopShared,    "InitializeIrNopShared"},
-    {0x00190040, nullptr,                  "ReleaseReceivedData"},
-    {0x001A0040, nullptr,                  "SetOwnMachineId"},
+    {0x000D0042, nullptr, "SendIrNop"},
+    {0x000E0042, nullptr, "SendIrNopLarge"},
+    {0x000F0040, nullptr, "ReceiveIrnop"},
+    {0x00100042, nullptr, "ReceiveIrnopLarge"},
+    {0x00110040, nullptr, "GetLatestReceiveErrorResult"},
+    {0x00120040, nullptr, "GetLatestSendErrorResult"},
+    {0x00130000, nullptr, "GetConnectionStatus"},
+    {0x00140000, nullptr, "GetTryingToConnectStatus"},
+    {0x00150000, nullptr, "GetReceiveSizeFreeAndUsed"},
+    {0x00160000, nullptr, "GetSendSizeFreeAndUsed"},
+    {0x00170000, nullptr, "GetConnectionRole"},
+    {0x00180182, InitializeIrNopShared, "InitializeIrNopShared"},
+    {0x00190040, nullptr, "ReleaseReceivedData"},
+    {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..b7d250312 100644
--- a/src/core/hle/service/ldr_ro/cro_helper.cpp
+++ b/src/core/hle/service/ldr_ro/cro_helper.cpp
@@ -5,7 +5,6 @@
 #include "common/alignment.h"
 #include "common/logging/log.h"
 #include "common/scope_exit.h"
-
 #include "core/hle/service/ldr_ro/cro_helper.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -14,37 +13,30 @@
 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, // data
     1, // module name
-    sizeof(SegmentEntry),
-    sizeof(ExportNamedSymbolEntry),
-    sizeof(ExportIndexedSymbolEntry),
+    sizeof(SegmentEntry), sizeof(ExportNamedSymbolEntry), sizeof(ExportIndexedSymbolEntry),
     1, // export strings
-    sizeof(ExportTreeEntry),
-    sizeof(ImportModuleEntry),
-    sizeof(ExternalRelocationEntry),
-    sizeof(ImportNamedSymbolEntry),
-    sizeof(ImportIndexedSymbolEntry),
+    sizeof(ExportTreeEntry), sizeof(ImportModuleEntry), sizeof(ExternalRelocationEntry),
+    sizeof(ImportNamedSymbolEntry), sizeof(ImportIndexedSymbolEntry),
     sizeof(ImportAnonymousSymbolEntry),
     1, // import strings
-    sizeof(StaticAnonymousSymbolEntry),
-    sizeof(InternalRelocationEntry),
-    sizeof(StaticRelocationEntry)
+    sizeof(StaticAnonymousSymbolEntry), sizeof(InternalRelocationEntry),
+    sizeof(StaticRelocationEntry),
 }};
 
-const std::array<CROHelper::HeaderField, 4> CROHelper::FIX_BARRIERS {{
-    Fix0Barrier,
-    Fix1Barrier,
-    Fix2Barrier,
-    Fix3Barrier
+const std::array<CROHelper::HeaderField, 4> CROHelper::FIX_BARRIERS{{
+    Fix0Barrier, Fix1Barrier, Fix2Barrier, Fix3Barrier,
 }};
 
 VAddr CROHelper::SegmentTagToAddress(SegmentTag segment_tag) const {
@@ -63,7 +55,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 +116,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 +160,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;
@@ -213,24 +206,12 @@ ResultCode CROHelper::RebaseHeader(u32 cro_size) {
 
     // verifies that all offsets are in the correct order
     constexpr std::array<HeaderField, 18> OFFSET_ORDER = {{
-        CodeOffset,
-        ModuleNameOffset,
-        SegmentTableOffset,
-        ExportNamedSymbolTableOffset,
-        ExportTreeTableOffset,
-        ExportIndexedSymbolTableOffset,
-        ExportStringsOffset,
-        ImportModuleTableOffset,
-        ExternalRelocationTableOffset,
-        ImportNamedSymbolTableOffset,
-        ImportIndexedSymbolTableOffset,
-        ImportAnonymousSymbolTableOffset,
-        ImportStringsOffset,
-        StaticAnonymousSymbolTableOffset,
-        InternalRelocationTableOffset,
-        StaticRelocationTableOffset,
-        DataOffset,
-        FileSize
+        CodeOffset, ModuleNameOffset, SegmentTableOffset, ExportNamedSymbolTableOffset,
+        ExportTreeTableOffset, ExportIndexedSymbolTableOffset, ExportStringsOffset,
+        ImportModuleTableOffset, ExternalRelocationTableOffset, ImportNamedSymbolTableOffset,
+        ImportIndexedSymbolTableOffset, ImportAnonymousSymbolTableOffset, ImportStringsOffset,
+        StaticAnonymousSymbolTableOffset, InternalRelocationTableOffset,
+        StaticRelocationTableOffset, DataOffset, FileSize,
     }};
 
     u32 prev_offset = GetField(OFFSET_ORDER[0]);
@@ -266,9 +247,9 @@ ResultCode CROHelper::RebaseHeader(u32 cro_size) {
     return RESULT_SUCCESS;
 }
 
-ResultVal<VAddr> CROHelper::RebaseSegmentTable(u32 cro_size,
-    VAddr data_segment_address, u32 data_segment_size,
-    VAddr bss_segment_address, u32 bss_segment_size) {
+ResultVal<VAddr> CROHelper::RebaseSegmentTable(u32 cro_size, VAddr data_segment_address,
+                                               u32 data_segment_size, VAddr bss_segment_address,
+                                               u32 bss_segment_size) {
 
     u32 prev_data_segment = 0;
     u32 segment_num = GetField(SegmentNum);
@@ -309,8 +290,8 @@ ResultCode CROHelper::RebaseExportNamedSymbolTable() {
 
         if (entry.name_offset != 0) {
             entry.name_offset += module_address;
-            if (entry.name_offset < export_strings_offset
-                || entry.name_offset >= export_strings_end) {
+            if (entry.name_offset < export_strings_offset ||
+                entry.name_offset >= export_strings_end) {
                 return CROFormatError(0x11);
             }
         }
@@ -337,9 +318,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 +333,24 @@ ResultCode CROHelper::RebaseImportModuleTable() {
 
         if (entry.name_offset != 0) {
             entry.name_offset += module_address;
-            if (entry.name_offset < import_strings_offset
-                || entry.name_offset >= import_strings_end) {
+            if (entry.name_offset < import_strings_offset ||
+                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
-                || entry.import_indexed_symbol_table_offset > index_import_table_end) {
+            if (entry.import_indexed_symbol_table_offset < import_indexed_symbol_table_offset ||
+                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
-                || entry.import_anonymous_symbol_table_offset > offset_import_table_end) {
+            if (entry.import_anonymous_symbol_table_offset < import_anonymous_symbol_table_offset ||
+                entry.import_anonymous_symbol_table_offset > offset_import_table_end) {
                 return CROFormatError(0x18);
             }
         }
@@ -379,25 +364,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
-                || entry.name_offset >= import_strings_end) {
+            if (entry.name_offset < import_strings_offset ||
+                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
-                || entry.relocation_batch_offset > external_relocation_table_end) {
+            if (entry.relocation_batch_offset < external_relocation_table_offset ||
+                entry.relocation_batch_offset > external_relocation_table_end) {
                 return CROFormatError(0x1B);
             }
         }
@@ -409,17 +396,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
-                || entry.relocation_batch_offset > external_relocation_table_end) {
+            if (entry.relocation_batch_offset < external_relocation_table_offset ||
+                entry.relocation_batch_offset > external_relocation_table_end) {
                 return CROFormatError(0x14);
             }
         }
@@ -431,17 +420,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
-                || entry.relocation_batch_offset > external_relocation_table_end) {
+            if (entry.relocation_batch_offset < external_relocation_table_offset ||
+                entry.relocation_batch_offset > external_relocation_table_end) {
                 return CROFormatError(0x17);
             }
         }
@@ -475,7 +466,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 +520,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
-            || batch_address > static_relocation_table_end) {
+        if (batch_address < static_relocation_table_offset ||
+            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 +567,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 +579,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);
-        ResultCode result = ApplyRelocation(target_address, relocation.type, relocation.addend, symbol_segment.offset, target_addressB);
+        LOG_TRACE(Service_LDR, "Internally relocates 0x%08X with 0x%08X", target_address,
+                  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 +733,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> {
-                std::string symbol_name = Memory::ReadCString(entry.name_offset, import_strings_size);
-                u32 symbol_address = source.FindExportNamedSymbol(symbol_name);
-
-                if (symbol_address != 0) {
-                    LOG_TRACE(Service_LDR, "CRO \"%s\" imports \"%s\" from \"%s\"",
-                        ModuleName().data(), symbol_name.data(), source.ModuleName().data());
-
-                    ResultCode result = ApplyRelocationBatch(relocation_addr, symbol_address);
-                    if (result.IsError()) {
-                        LOG_ERROR(Service_LDR, "Error applying relocation batch %08X", result.raw);
-                        return result;
+            ResultCode result =
+                ForEachAutoLinkCRO(crs_address, [&](CROHelper source) -> ResultVal<bool> {
+                    std::string symbol_name =
+                        Memory::ReadCString(entry.name_offset, import_strings_size);
+                    u32 symbol_address = source.FindExportNamedSymbol(symbol_name);
+
+                    if (symbol_address != 0) {
+                        LOG_TRACE(Service_LDR, "CRO \"%s\" imports \"%s\" from \"%s\"",
+                                  ModuleName().data(), symbol_name.data(),
+                                  source.ModuleName().data());
+
+                        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 +780,6 @@ ResultCode CROHelper::ResetImportNamedSymbol() {
             LOG_ERROR(Service_LDR, "Error reseting relocation batch %08X", result.raw);
             return result;
         }
-
     }
     return RESULT_SUCCESS;
 }
@@ -831,40 +833,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> {
-            if (want_cro_name == source.ModuleName()) {
-                LOG_INFO(Service_LDR, "CRO \"%s\" imports %d indexed symbols from \"%s\"",
-                    ModuleName().data(), entry.import_indexed_symbol_num, source.ModuleName().data());
-                for (u32 j = 0; j < entry.import_indexed_symbol_num; ++j) {
-                    ImportIndexedSymbolEntry im;
-                    entry.GetImportIndexedSymbolEntry(j, im);
-                    ExportIndexedSymbolEntry ex;
-                    source.GetEntry(im.index, ex);
-                    u32 symbol_address = source.SegmentTagToAddress(ex.symbol_position);
-                    LOG_TRACE(Service_LDR, "    Imports 0x%08X", symbol_address);
-                    ResultCode result = ApplyRelocationBatch(im.relocation_batch_offset, symbol_address);
-                    if (result.IsError()) {
-                        LOG_ERROR(Service_LDR, "Error applying relocation batch %08X", result.raw);
-                        return result;
+        ResultCode result =
+            ForEachAutoLinkCRO(crs_address, [&](CROHelper source) -> ResultVal<bool> {
+                if (want_cro_name == source.ModuleName()) {
+                    LOG_INFO(Service_LDR, "CRO \"%s\" imports %d indexed symbols from \"%s\"",
+                             ModuleName().data(), entry.import_indexed_symbol_num,
+                             source.ModuleName().data());
+                    for (u32 j = 0; j < entry.import_indexed_symbol_num; ++j) {
+                        ImportIndexedSymbolEntry im;
+                        entry.GetImportIndexedSymbolEntry(j, im);
+                        ExportIndexedSymbolEntry ex;
+                        source.GetEntry(im.index, ex);
+                        u32 symbol_address = source.SegmentTagToAddress(ex.symbol_position);
+                        LOG_TRACE(Service_LDR, "    Imports 0x%08X", symbol_address);
+                        ResultCode 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\"",
-                    ModuleName().data(), entry.import_anonymous_symbol_num, source.ModuleName().data());
-                for (u32 j = 0; j < entry.import_anonymous_symbol_num; ++j) {
-                    ImportAnonymousSymbolEntry im;
-                    entry.GetImportAnonymousSymbolEntry(j, im);
-                    u32 symbol_address = source.SegmentTagToAddress(im.symbol_position);
-                    LOG_TRACE(Service_LDR, "    Imports 0x%08X", symbol_address);
-                    ResultCode 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\"",
+                             ModuleName().data(), entry.import_anonymous_symbol_num,
+                             source.ModuleName().data());
+                    for (u32 j = 0; j < entry.import_anonymous_symbol_num; ++j) {
+                        ImportAnonymousSymbolEntry im;
+                        entry.GetImportAnonymousSymbolEntry(j, im);
+                        u32 symbol_address = source.SegmentTagToAddress(im.symbol_position);
+                        LOG_TRACE(Service_LDR, "    Imports 0x%08X", symbol_address);
+                        ResultCode result =
+                            ApplyRelocationBatch(im.relocation_batch_offset, 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;
         }
@@ -873,8 +882,8 @@ ResultCode CROHelper::ApplyModuleImport(VAddr crs_address) {
 }
 
 ResultCode CROHelper::ApplyExportNamedSymbol(CROHelper target) {
-    LOG_DEBUG(Service_LDR, "CRO \"%s\" exports named symbols to \"%s\"",
-        ModuleName().data(), target.ModuleName().data());
+    LOG_DEBUG(Service_LDR, "CRO \"%s\" exports named symbols to \"%s\"", 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 +894,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 +911,8 @@ ResultCode CROHelper::ApplyExportNamedSymbol(CROHelper target) {
 }
 
 ResultCode CROHelper::ResetExportNamedSymbol(CROHelper target) {
-    LOG_DEBUG(Service_LDR, "CRO \"%s\" unexports named symbols to \"%s\"",
-        ModuleName().data(), target.ModuleName().data());
+    LOG_DEBUG(Service_LDR, "CRO \"%s\" unexports named symbols to \"%s\"", 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 +924,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 +952,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\"",
-            module_name.data(), entry.import_indexed_symbol_num, target.ModuleName().data());
+        LOG_INFO(Service_LDR, "CRO \"%s\" exports %d indexed symbols to \"%s\"", module_name.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 +961,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 +970,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 +1001,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\"",
-            module_name.data(), target.ModuleName().data());
+        LOG_DEBUG(Service_LDR, "CRO \"%s\" unexports indexed symbols to \"%s\"", module_name.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 +1015,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 +1041,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"){
-            ResultCode result = ForEachAutoLinkCRO(crs_address, [&](CROHelper source) -> ResultVal<bool> {
-                u32 symbol_address = source.FindExportNamedSymbol("nnroAeabiAtexit_");
+        if (Memory::ReadCString(entry.name_offset, import_strings_size) == "__aeabi_atexit") {
+            ResultCode result =
+                ForEachAutoLinkCRO(crs_address, [&](CROHelper source) -> ResultVal<bool> {
+                    u32 symbol_address = source.FindExportNamedSymbol("nnroAeabiAtexit_");
 
-                if (symbol_address != 0) {
-                    LOG_DEBUG(Service_LDR, "CRO \"%s\" import exit function from \"%s\"",
-                        ModuleName().data(), source.ModuleName().data());
+                    if (symbol_address != 0) {
+                        LOG_DEBUG(Service_LDR, "CRO \"%s\" import exit function from \"%s\"",
+                                  ModuleName().data(), source.ModuleName().data());
 
-                    ResultCode result = ApplyRelocationBatch(relocation_addr, symbol_address);
-                    if (result.IsError()) {
-                        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()) {
                 LOG_ERROR(Service_LDR, "Error applying exit relocation %08X", result.raw);
                 return result;
@@ -1070,9 +1088,9 @@ static ResultCode VerifyStringTableLength(VAddr address, u32 size) {
     return RESULT_SUCCESS;
 }
 
-ResultCode CROHelper::Rebase(VAddr crs_address, u32 cro_size,
-    VAddr data_segment_addresss, u32 data_segment_size,
-    VAddr bss_segment_address, u32 bss_segment_size, bool is_crs) {
+ResultCode CROHelper::Rebase(VAddr crs_address, u32 cro_size, VAddr data_segment_addresss,
+                             u32 data_segment_size, VAddr bss_segment_address, u32 bss_segment_size,
+                             bool is_crs) {
 
     ResultCode result = RebaseHeader(cro_size);
     if (result.IsError()) {
@@ -1088,9 +1106,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,
-            data_segment_addresss, data_segment_size,
-            bss_segment_address, bss_segment_size);
+        auto result_val = RebaseSegmentTable(cro_size, data_segment_addresss, data_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 +1391,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 +1418,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 +1438,9 @@ u32 CROHelper::GetFixEnd(u32 fix_level) const {
     u32 entry_size_i = 2;
     int field = ModuleNameOffset;
     while (true) {
-        end = std::max<u32>(end,
-            GetField(static_cast<HeaderField>(field)) +
-            GetField(static_cast<HeaderField>(field + 1)) * ENTRY_SIZE[entry_size_i]);
+        end = std::max<u32>(end, GetField(static_cast<HeaderField>(field)) +
+                                     GetField(static_cast<HeaderField>(field + 1)) *
+                                         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..6a0d0d3bf 100644
--- a/src/core/hle/service/ldr_ro/cro_helper.h
+++ b/src/core/hle/service/ldr_ro/cro_helper.h
@@ -6,12 +6,10 @@
 
 #include <array>
 #include <tuple>
-
 #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 +19,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) \
-        static_assert(std::is_standard_layout<name>::value, "CRO structure " #name " doesn't use standard layout"); \
-        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)
+#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_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) \
-        static_assert(std::is_standard_layout<name>::value, "CRO structure " #name " doesn't use standard layout"); \
-        static_assert(sizeof(name) == (size), "Unexpected struct size for CRO structure " #name)
+#define ASSERT_CRO_STRUCT(name, size)                                                              \
+    static_assert(std::is_standard_layout<name>::value,                                            \
+                  "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;
@@ -37,8 +38,7 @@ static constexpr u32 CRO_HASH_SIZE = 0x80;
 /// Represents a loaded module (CRO) with interfaces manipulating it.
 class CROHelper final {
 public:
-    explicit CROHelper(VAddr cro_address) : module_address(cro_address) {
-    }
+    explicit CROHelper(VAddr cro_address) : module_address(cro_address) {}
 
     std::string ModuleName() const {
         return Memory::ReadCString(GetField(ModuleNameOffset), GetField(ModuleNameSize));
@@ -59,9 +59,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,
-        VAddr data_segment_addresss, u32 data_segment_size,
-        VAddr bss_segment_address, u32 bss_segment_size, bool is_crs);
+    ResultCode Rebase(VAddr crs_address, u32 cro_size, VAddr data_segment_addresss,
+                      u32 data_segment_size, VAddr bss_segment_address, u32 bss_segment_size,
+                      bool is_crs);
 
     /**
      * Unrebases the module.
@@ -148,8 +148,9 @@ 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.
-     * We don't directly use a struct here, to avoid GetPointer, reinterpret_cast, or Read/WriteBlock repeatedly.
+     * Each item in this enum represents a u32 field in the header begin from address+0x80,
+     * successively. We don't directly use a struct here, to avoid GetPointer, reinterpret_cast, or
+     * Read/WriteBlock repeatedly.
      */
     enum HeaderField {
         Magic = 0,
@@ -208,18 +209,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,
-        BSS    = 3,
+        Data = 2,
+        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;
@@ -282,7 +285,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 +294,8 @@ private:
 
     /// Identifies an anonymous symbol imported from another module.
     struct ImportAnonymousSymbolEntry {
-        SegmentTag symbol_position;      // in the exporting segment
-        u32_le relocation_batch_offset;  // pointing to a relocation batch in ExternalRelocationTable
+        SegmentTag symbol_position;     // in the exporting segment
+        u32_le relocation_batch_offset; // pointing to a relocation batch in ExternalRelocationTable
 
         static constexpr HeaderField TABLE_OFFSET_FIELD = ImportAnonymousSymbolTableOffset;
     };
@@ -300,42 +303,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 import_indexed_symbol_table_offset;   // pointing to a subtable in ImportIndexedSymbolTable
+        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_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),
-                &entry, sizeof(ImportIndexedSymbolEntry));
+            Memory::ReadBlock(import_indexed_symbol_table_offset +
+                                  index * sizeof(ImportIndexedSymbolEntry),
+                              &entry, sizeof(ImportIndexedSymbolEntry));
         }
 
         void GetImportAnonymousSymbolEntry(u32 index, ImportAnonymousSymbolEntry& entry) {
-            Memory::ReadBlock(import_anonymous_symbol_table_offset + index * sizeof(ImportAnonymousSymbolEntry),
-                &entry, sizeof(ImportAnonymousSymbolEntry));
+            Memory::ReadBlock(import_anonymous_symbol_table_offset +
+                                  index * sizeof(ImportAnonymousSymbolEntry),
+                              &entry, sizeof(ImportAnonymousSymbolEntry));
         }
     };
     ASSERT_CRO_STRUCT(ImportModuleEntry, 20);
 
     enum class RelocationType : u8 {
-        Nothing                = 0,
-        AbsoluteAddress        = 2,
-        RelativeAddress        = 3,
-        ThumbBranch            = 10,
-        ArmBranch              = 28,
-        ModifyArmBranch        = 29,
-        AbsoluteAddress2       = 38,
+        Nothing = 0,
+        AbsoluteAddress = 2,
+        RelativeAddress = 3,
+        ThumbBranch = 10,
+        ArmBranch = 28,
+        ModifyArmBranch = 29,
+        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 +374,8 @@ private:
 
     /// Identifies a special static anonymous symbol (no game is known using this).
     struct StaticAnonymousSymbolEntry {
-        SegmentTag symbol_position;      // to self's segment
-        u32_le relocation_batch_offset;  // pointing to a relocation batch in StaticRelocationTable
+        SegmentTag symbol_position;     // to self's segment
+        u32_le relocation_batch_offset; // pointing to a relocation batch in StaticRelocationTable
 
         static constexpr HeaderField TABLE_OFFSET_FIELD = StaticAnonymousSymbolTableOffset;
     };
@@ -446,12 +454,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 +488,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,
-        u32 addend, u32 symbol_address, u32 target_future_address);
+    ResultCode ApplyRelocation(VAddr target_address, RelocationType relocation_type, u32 addend,
+                               u32 symbol_address, u32 target_future_address);
 
     /**
      * Clears a relocation to zero
@@ -492,7 +503,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 +519,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 +533,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,
-        VAddr data_segment_address, u32 data_segment_size,
-        VAddr bss_segment_address, u32 bss_segment_size);
+    ResultVal<VAddr> RebaseSegmentTable(u32 cro_size, VAddr data_segment_address,
+                                        u32 data_segment_size, VAddr bss_segment_address,
+                                        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 +640,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 +666,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 +688,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..ec183d1f5 100644
--- a/src/core/hle/service/ldr_ro/ldr_ro.cpp
+++ b/src/core/hle/service/ldr_ro/ldr_ro.cpp
@@ -5,7 +5,6 @@
 #include "common/alignment.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-
 #include "core/arm/arm_interface.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/vm_manager.h"
@@ -18,24 +17,33 @@
 
 namespace LDR_RO {
 
-static const ResultCode ERROR_ALREADY_INITIALIZED =   // 0xD9612FF9
-    ResultCode(ErrorDescription::AlreadyInitialized,         ErrorModule::RO, ErrorSummary::Internal,        ErrorLevel::Permanent);
-static const ResultCode ERROR_NOT_INITIALIZED =       // 0xD9612FF8
-    ResultCode(ErrorDescription::NotInitialized,             ErrorModule::RO, ErrorSummary::Internal,        ErrorLevel::Permanent);
-static const ResultCode ERROR_BUFFER_TOO_SMALL =      // 0xE0E12C1F
-    ResultCode(static_cast<ErrorDescription>(31),            ErrorModule::RO, ErrorSummary::InvalidArgument, ErrorLevel::Usage);
-static const ResultCode ERROR_MISALIGNED_ADDRESS =    // 0xD9012FF1
-    ResultCode(ErrorDescription::MisalignedAddress,          ErrorModule::RO, ErrorSummary::WrongArgument,   ErrorLevel::Permanent);
-static const ResultCode ERROR_MISALIGNED_SIZE =       // 0xD9012FF2
-    ResultCode(ErrorDescription::MisalignedSize,             ErrorModule::RO, ErrorSummary::WrongArgument,   ErrorLevel::Permanent);
-static const ResultCode ERROR_ILLEGAL_ADDRESS =       // 0xE1612C0F
-    ResultCode(static_cast<ErrorDescription>(15),            ErrorModule::RO, ErrorSummary::Internal,        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 const ResultCode ERROR_ALREADY_INITIALIZED = // 0xD9612FF9
+    ResultCode(ErrorDescription::AlreadyInitialized, ErrorModule::RO, ErrorSummary::Internal,
+               ErrorLevel::Permanent);
+static const ResultCode ERROR_NOT_INITIALIZED = // 0xD9612FF8
+    ResultCode(ErrorDescription::NotInitialized, ErrorModule::RO, ErrorSummary::Internal,
+               ErrorLevel::Permanent);
+static const ResultCode ERROR_BUFFER_TOO_SMALL = // 0xE0E12C1F
+    ResultCode(static_cast<ErrorDescription>(31), ErrorModule::RO, ErrorSummary::InvalidArgument,
+               ErrorLevel::Usage);
+static const ResultCode ERROR_MISALIGNED_ADDRESS = // 0xD9012FF1
+    ResultCode(ErrorDescription::MisalignedAddress, ErrorModule::RO, ErrorSummary::WrongArgument,
+               ErrorLevel::Permanent);
+static const ResultCode ERROR_MISALIGNED_SIZE = // 0xD9012FF2
+    ResultCode(ErrorDescription::MisalignedSize, ErrorModule::RO, ErrorSummary::WrongArgument,
+               ErrorLevel::Permanent);
+static const ResultCode ERROR_ILLEGAL_ADDRESS = // 0xE1612C0F
+    ResultCode(static_cast<ErrorDescription>(15), ErrorModule::RO, ErrorSummary::Internal,
+               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 +52,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()
-        && vma->second.base + vma->second.size >= buffer_ptr + size
-        && vma->second.permissions == Kernel::VMAPermission::ReadWrite
-        && vma->second.meminfo_state == Kernel::MemoryState::Private;
+    return vma != Kernel::g_current_process->vm_manager.vma_map.end() &&
+           vma->second.base + vma->second.size >= buffer_ptr + size &&
+           vma->second.permissions == Kernel::VMAPermission::ReadWrite &&
+           vma->second.meminfo_state == Kernel::MemoryState::Private;
 }
 
 /**
@@ -66,13 +74,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];
-    VAddr crs_address    = cmd_buff[3];
-    u32 descriptor       = cmd_buff[4];
-    u32 process          = cmd_buff[5];
+    u32 crs_size = cmd_buff[2];
+    VAddr crs_address = cmd_buff[3];
+    u32 descriptor = cmd_buff[4];
+    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",
-                crs_buffer_ptr, crs_address, crs_size, descriptor, process);
+    LOG_DEBUG(Service_LDR, "called, crs_buffer_ptr=0x%08X, crs_address=0x%08X, crs_size=0x%X, "
+                           "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 +128,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 +141,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 +199,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 descriptor     = cmd_buff[3];
-    u32 process        = cmd_buff[4];
+    u32 crr_size = cmd_buff[2];
+    u32 descriptor = cmd_buff[3];
+    u32 process = cmd_buff[4];
 
     if (descriptor != 0) {
         LOG_ERROR(Service_LDR, "IPC handle descriptor failed validation (0x%X)", descriptor);
@@ -200,7 +213,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 +232,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 process        = cmd_buff[3];
+    u32 descriptor = cmd_buff[2];
+    u32 process = cmd_buff[3];
 
     if (descriptor != 0) {
         LOG_ERROR(Service_LDR, "IPC handle descriptor failed validation (0x%X)", descriptor);
@@ -231,7 +245,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 +278,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_address          = cmd_buff[2];
-    u32 cro_size               = cmd_buff[3];
+    VAddr cro_buffer_ptr = cmd_buff[1];
+    VAddr cro_address = cmd_buff[2];
+    u32 cro_size = cmd_buff[3];
     VAddr data_segment_address = cmd_buff[4];
-    u32 zero                   = cmd_buff[5];
-    u32 data_segment_size      = cmd_buff[6];
-    u32 bss_segment_address    = cmd_buff[7];
-    u32 bss_segment_size       = cmd_buff[8];
-    bool auto_link             = (cmd_buff[9] & 0xFF) != 0;
-    u32 fix_level              = cmd_buff[10];
-    VAddr crr_address          = cmd_buff[11];
-    u32 descriptor             = cmd_buff[12];
-    u32 process                = cmd_buff[13];
-
-    LOG_DEBUG(Service_LDR, "called (%s), cro_buffer_ptr=0x%08X, cro_address=0x%08X, cro_size=0x%X, "
-        "data_segment_address=0x%08X, zero=%d, data_segment_size=0x%X, bss_segment_address=0x%08X, bss_segment_size=0x%X, "
-        "auto_link=%s, fix_level=%d, crr_address=0x%08X, descriptor=0x%08X, process=0x%08X",
-        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
-        );
+    u32 zero = cmd_buff[5];
+    u32 data_segment_size = cmd_buff[6];
+    u32 bss_segment_address = cmd_buff[7];
+    u32 bss_segment_size = cmd_buff[8];
+    bool auto_link = (cmd_buff[9] & 0xFF) != 0;
+    u32 fix_level = cmd_buff[10];
+    VAddr crr_address = cmd_buff[11];
+    u32 descriptor = cmd_buff[12];
+    u32 process = cmd_buff[13];
+
+    LOG_DEBUG(Service_LDR,
+              "called (%s), cro_buffer_ptr=0x%08X, cro_address=0x%08X, cro_size=0x%X, "
+              "data_segment_address=0x%08X, zero=%d, data_segment_size=0x%X, "
+              "bss_segment_address=0x%08X, bss_segment_size=0x%X, "
+              "auto_link=%s, fix_level=%d, crr_address=0x%08X, descriptor=0x%08X, process=0x%08X",
+              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 +346,8 @@ static void LoadCRO(Service::Interface* self, bool link_on_load_bug_fix) {
         return;
     }
 
-    if (cro_address < Memory::PROCESS_IMAGE_VADDR
-        || cro_address + cro_size > Memory::PROCESS_IMAGE_VADDR_END) {
+    if (cro_address < Memory::PROCESS_IMAGE_VADDR ||
+        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 +355,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 +367,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 +405,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 +431,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 +449,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 +461,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",
-        cro.ModuleName().data(), cro_address, cro_address+fix_size);
+    LOG_INFO(Service_LDR, "CRO \"%s\" loaded at 0x%08X, fixed_end=0x%08X", cro.ModuleName().data(),
+             cro_address, cro_address + fix_size);
 
     cmd_buff[1] = RESULT_SUCCESS.raw;
     cmd_buff[2] = fix_size;
@@ -464,14 +488,15 @@ static void LoadCRO(Service::Interface* self) {
  */
 static void UnloadCRO(Service::Interface* self) {
     u32* cmd_buff = Kernel::GetCommandBuffer();
-    VAddr cro_address      = cmd_buff[1];
-    u32 zero               = cmd_buff[2];
-    VAddr cro_buffer_ptr   = cmd_buff[3];
-    u32 descriptor         = cmd_buff[4];
-    u32 process            = cmd_buff[5];
+    VAddr cro_address = cmd_buff[1];
+    u32 zero = cmd_buff[2];
+    VAddr cro_buffer_ptr = cmd_buff[3];
+    u32 descriptor = cmd_buff[4];
+    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",
-        cro_address, zero, cro_buffer_ptr, descriptor, process);
+    LOG_DEBUG(Service_LDR, "called, cro_address=0x%08X, zero=%d, cro_buffer_ptr=0x%08X, "
+                           "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 +583,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 process       = cmd_buff[3];
+    u32 descriptor = cmd_buff[2];
+    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 +645,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 process       = cmd_buff[3];
+    u32 descriptor = cmd_buff[2];
+    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 +707,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 process          = cmd_buff[3];
+    u32 descriptor = cmd_buff[2];
+    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 +749,17 @@ static void Shutdown(Service::Interface* self) {
 }
 
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x000100C2, Initialize,            "Initialize"},
-    {0x00020082, LoadCRR,               "LoadCRR"},
-    {0x00030042, UnloadCRR,             "UnloadCRR"},
-    {0x000402C2, LoadCRO<false>,        "LoadCRO"},
-    {0x000500C2, UnloadCRO,             "UnloadCRO"},
-    {0x00060042, LinkCRO,               "LinkCRO"},
-    {0x00070042, UnlinkCRO,             "UnlinkCRO"},
-    {0x00080042, Shutdown,              "Shutdown"},
-    {0x000902C2, LoadCRO<true>,         "LoadCRO_New"},
+    // clang-format off
+    {0x000100C2, Initialize, "Initialize"},
+    {0x00020082, LoadCRR, "LoadCRR"},
+    {0x00030042, UnloadCRR, "UnloadCRR"},
+    {0x000402C2, LoadCRO<false>, "LoadCRO"},
+    {0x000500C2, UnloadCRO, "UnloadCRO"},
+    {0x00060042, LinkCRO, "LinkCRO"},
+    {0x00070042, UnlinkCRO, "UnlinkCRO"},
+    {0x00080042, Shutdown, "Shutdown"},
+    {0x000902C2, LoadCRO<true>, "LoadCRO_New"},
+    // clang-format on
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/ldr_ro/memory_synchronizer.cpp b/src/core/hle/service/ldr_ro/memory_synchronizer.cpp
index 4402876e6..989887264 100644
--- a/src/core/hle/service/ldr_ro/memory_synchronizer.cpp
+++ b/src/core/hle/service/ldr_ro/memory_synchronizer.cpp
@@ -3,9 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-
 #include "common/assert.h"
-
 #include "core/hle/service/ldr_ro/memory_synchronizer.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -14,9 +12,8 @@
 namespace LDR_RO {
 
 auto MemorySynchronizer::FindMemoryBlock(VAddr mapping, VAddr original) {
-    auto block = std::find_if(memory_blocks.begin(), memory_blocks.end(), [=](MemoryBlock& b){
-        return b.original == original;
-    });
+    auto block = std::find_if(memory_blocks.begin(), memory_blocks.end(),
+                              [=](MemoryBlock& b) { return b.original == original; });
     ASSERT(block->mapping == mapping);
     return block;
 }
diff --git a/src/core/hle/service/ldr_ro/memory_synchronizer.h b/src/core/hle/service/ldr_ro/memory_synchronizer.h
index 92f267912..883ee4acf 100644
--- a/src/core/hle/service/ldr_ro/memory_synchronizer.h
+++ b/src/core/hle/service/ldr_ro/memory_synchronizer.h
@@ -5,7 +5,6 @@
 #pragma once
 
 #include <vector>
-
 #include "core/memory.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
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"},
-    {0x00020000, nullptr,               "UnmapSharedMem"},
-    {0x00030140, nullptr,               "Initialize"},
-    {0x00040040, nullptr,               "AdjustSampling"},
-    {0x00050000, nullptr,               "StopSampling"},
-    {0x00060000, nullptr,               "IsSampling"},
-    {0x00070000, nullptr,               "GetEventHandle"},
-    {0x00080040, nullptr,               "SetGain"},
-    {0x00090000, nullptr,               "GetGain"},
-    {0x000A0040, nullptr,               "SetPower"},
-    {0x000B0000, nullptr,               "GetPower"},
-    {0x000C0042, nullptr,               "size"},
-    {0x000D0040, nullptr,               "SetClamp"},
-    {0x000E0000, nullptr,               "GetClamp"},
-    {0x000F0040, nullptr,               "SetAllowShellClosed"},
-    {0x00100040, nullptr,               "unknown_input2"},
+    {0x00010042, nullptr, "MapSharedMem"},
+    {0x00020000, nullptr, "UnmapSharedMem"},
+    {0x00030140, nullptr, "Initialize"},
+    {0x00040040, nullptr, "AdjustSampling"},
+    {0x00050000, nullptr, "StopSampling"},
+    {0x00060000, nullptr, "IsSampling"},
+    {0x00070000, nullptr, "GetEventHandle"},
+    {0x00080040, nullptr, "SetGain"},
+    {0x00090000, nullptr, "GetGain"},
+    {0x000A0040, nullptr, "SetPower"},
+    {0x000B0000, nullptr, "GetPower"},
+    {0x000C0042, nullptr, "size"},
+    {0x000D0040, nullptr, "SetClamp"},
+    {0x000E0000, nullptr, "GetClamp"},
+    {0x000F0040, nullptr, "SetAllowShellClosed"},
+    {0x00100040, nullptr, "unknown_input2"},
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/ndm/ndm.cpp b/src/core/hle/service/ndm/ndm.cpp
index bc9c3413d..5eb97f0d3 100644
--- a/src/core/hle/service/ndm/ndm.cpp
+++ b/src/core/hle/service/ndm/ndm.cpp
@@ -4,21 +4,23 @@
 
 #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 {
     DEFAULT_RETRY_INTERVAL = 10,
-    DEFAULT_SCAN_INTERVAL  = 30
+    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 +74,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;
@@ -228,9 +231,7 @@ void Init() {
     AddService(new NDM_U_Interface);
 }
 
-void Shutdown() {
-
-}
+void Shutdown() {}
 
-}// namespace NDM
-}// namespace Service
+} // namespace NDM
+} // namespace Service
diff --git a/src/core/hle/service/ndm/ndm.h b/src/core/hle/service/ndm/ndm.h
index 5c2b968dc..979e7fcf1 100644
--- a/src/core/hle/service/ndm/ndm.h
+++ b/src/core/hle/service/ndm/ndm.h
@@ -13,35 +13,30 @@ class Interface;
 namespace NDM {
 
 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,
-    Cec     = (1 << static_cast<u32>(Daemon::Cec)),
-    Boss    = (1 << static_cast<u32>(Daemon::Boss)),
-    Nim     = (1 << static_cast<u32>(Daemon::Nim)),
-    Friend  = (1 << static_cast<u32>(Daemon::Friend)),
+    None = 0,
+    Cec = (1 << static_cast<u32>(Daemon::Cec)),
+    Boss = (1 << static_cast<u32>(Daemon::Boss)),
+    Nim = (1 << static_cast<u32>(Daemon::Nim)),
+    Friend = (1 << static_cast<u32>(Daemon::Friend)),
     Default = Cec | Friend,
-    All     = Cec | Boss | Nim | Friend
+    All = Cec | Boss | Nim | Friend,
 };
 
-enum class DaemonStatus : u32 {
-    Busy       = 0,
-    Idle       = 1,
-    Suspending = 2,
-    Suspended  = 3
-};
+enum class DaemonStatus : u32 { Busy = 0, Idle = 1, Suspending = 2, Suspended = 3 };
 
 enum class ExclusiveState : u32 {
-    None                = 0,
-    Infrastructure      = 1,
+    None = 0,
+    Infrastructure = 1,
     LocalCommunications = 2,
-    Streetpass          = 3,
-    StreetpassData      = 4,
+    Streetpass = 3,
+    StreetpassData = 4,
 };
 
 /**
@@ -205,7 +200,6 @@ void SetRetryInterval(Service::Interface* self);
  */
 void GetRetryInterval(Service::Interface* self);
 
-
 /**
  *  NDM::OverrideDefaultDaemons service function
  *  Inputs:
@@ -233,7 +227,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 +247,5 @@ void Init();
 /// Shutdown NDM service
 void Shutdown();
 
-}// namespace NDM
-}// namespace Service
+} // namespace NDM
+} // 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"},
-    {0x00020002, LeaveExclusiveState,     "LeaveExclusiveState"},
-    {0x00030000, QueryExclusiveMode,      "QueryExclusiveMode"},
-    {0x00040002, LockState,               "LockState"},
-    {0x00050002, UnlockState,             "UnlockState"},
-    {0x00060040, SuspendDaemons,          "SuspendDaemons"},
-    {0x00070040, ResumeDaemons,           "ResumeDaemons"},
-    {0x00080040, SuspendScheduler,        "SuspendScheduler"},
-    {0x00090000, ResumeScheduler,         "ResumeScheduler"},
-    {0x000A0000, nullptr,                 "GetCurrentState"},
-    {0x000B0000, nullptr,                 "GetTargetState"},
-    {0x000C0000, nullptr,                 "<Stubbed>"},
-    {0x000D0040, QueryStatus,             "QueryStatus"},
-    {0x000E0040, GetDaemonDisableCount,   "GetDaemonDisableCount"},
-    {0x000F0000, GetSchedulerDisableCount,"GetSchedulerDisableCount"},
-    {0x00100040, SetScanInterval,         "SetScanInterval"},
-    {0x00110000, GetScanInterval,         "GetScanInterval"},
-    {0x00120040, SetRetryInterval,        "SetRetryInterval"},
-    {0x00130000, GetRetryInterval,        "GetRetryInterval"},
-    {0x00140040, OverrideDefaultDaemons,  "OverrideDefaultDaemons"},
-    {0x00150000, ResetDefaultDaemons,     "ResetDefaultDaemons"},
-    {0x00160000, GetDefaultDaemons,       "GetDefaultDaemons"},
+    {0x00010042, EnterExclusiveState, "EnterExclusiveState"},
+    {0x00020002, LeaveExclusiveState, "LeaveExclusiveState"},
+    {0x00030000, QueryExclusiveMode, "QueryExclusiveMode"},
+    {0x00040002, LockState, "LockState"},
+    {0x00050002, UnlockState, "UnlockState"},
+    {0x00060040, SuspendDaemons, "SuspendDaemons"},
+    {0x00070040, ResumeDaemons, "ResumeDaemons"},
+    {0x00080040, SuspendScheduler, "SuspendScheduler"},
+    {0x00090000, ResumeScheduler, "ResumeScheduler"},
+    {0x000A0000, nullptr, "GetCurrentState"},
+    {0x000B0000, nullptr, "GetTargetState"},
+    {0x000C0000, nullptr, "<Stubbed>"},
+    {0x000D0040, QueryStatus, "QueryStatus"},
+    {0x000E0040, GetDaemonDisableCount, "GetDaemonDisableCount"},
+    {0x000F0000, GetSchedulerDisableCount, "GetSchedulerDisableCount"},
+    {0x00100040, SetScanInterval, "SetScanInterval"},
+    {0x00110000, GetScanInterval, "GetScanInterval"},
+    {0x00120040, SetRetryInterval, "SetRetryInterval"},
+    {0x00130000, GetRetryInterval, "GetRetryInterval"},
+    {0x00140040, OverrideDefaultDaemons, "OverrideDefaultDaemons"},
+    {0x00150000, ResetDefaultDaemons, "ResetDefaultDaemons"},
+    {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..8b70ec45b 100644
--- a/src/core/hle/service/news/news.cpp
+++ b/src/core/hle/service/news/news.cpp
@@ -3,11 +3,10 @@
 // Refer to the license.txt file included.
 
 #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 {
@@ -19,8 +18,7 @@ void Init() {
     AddService(new NEWS_U_Interface);
 }
 
-void Shutdown() {
-}
+void Shutdown() {}
 
 } // 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"},
-    {0x00050000, nullptr,               "GetTotalNotifications"},
-    {0x00060042, nullptr,               "SetNewsDBHeader"},
-    {0x00070082, nullptr,               "SetNotificationHeader"},
-    {0x00080082, nullptr,               "SetNotificationMessage"},
-    {0x00090082, nullptr,               "SetNotificationImage"},
-    {0x000A0042, nullptr,               "GetNewsDBHeader"},
-    {0x000B0082, nullptr,               "GetNotificationHeader"},
-    {0x000C0082, nullptr,               "GetNotificationMessage"},
-    {0x000D0082, nullptr,               "GetNotificationImage"},
-    {0x000E0040, nullptr,               "SetInfoLEDPattern"},
-    {0x00120082, nullptr,               "GetNotificationHeaderOther"},
-    {0x00130000, nullptr,               "WriteNewsDBSavedata"},
+    {0x000100C6, nullptr, "AddNotification"},
+    {0x00050000, nullptr, "GetTotalNotifications"},
+    {0x00060042, nullptr, "SetNewsDBHeader"},
+    {0x00070082, nullptr, "SetNotificationHeader"},
+    {0x00080082, nullptr, "SetNotificationMessage"},
+    {0x00090082, nullptr, "SetNotificationImage"},
+    {0x000A0042, nullptr, "GetNewsDBHeader"},
+    {0x000B0082, nullptr, "GetNotificationHeader"},
+    {0x000C0082, nullptr, "GetNotificationMessage"},
+    {0x000D0082, nullptr, "GetNotificationImage"},
+    {0x000E0040, nullptr, "SetInfoLEDPattern"},
+    {0x00120082, nullptr, "GetNotificationHeaderOther"},
+    {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..0be94322c 100644
--- a/src/core/hle/service/nim/nim.cpp
+++ b/src/core/hle/service/nim/nim.cpp
@@ -4,12 +4,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 {
@@ -31,8 +30,7 @@ void Init() {
     AddService(new NIM_U_Interface);
 }
 
-void Shutdown() {
-}
+void Shutdown() {}
 
 } // 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"},
-    {0x00040042, nullptr,               "SetTin"},
-    {0x000902D0, nullptr,               "ListContentSetsEx"},
-    {0x00180000, nullptr,               "GetBalance"},
-    {0x001D0000, nullptr,               "GetCustomerSupportCode"},
-    {0x00210000, nullptr,               "Initialize"},
-    {0x00240282, nullptr,               "CalculateContentsRequiredSize"},
-    {0x00250000, nullptr,               "RefreshServerTime"},
+    {0x00030042, nullptr, "SetApplicationId"},
+    {0x00040042, nullptr, "SetTin"},
+    {0x000902D0, nullptr, "ListContentSetsEx"},
+    {0x00180000, nullptr, "GetBalance"},
+    {0x001D0000, nullptr, "GetCustomerSupportCode"},
+    {0x00210000, nullptr, "Initialize"},
+    {0x00240282, nullptr, "CalculateContentsRequiredSize"},
+    {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"},
-    {0x0016020A, nullptr,                      "ListTitles"},
-    {0x002D0042, nullptr,                      "DownloadTickets"},
-    {0x00420240, nullptr,                      "StartDownload"},
+    {0x000A0000, nullptr, "CheckSysupdateAvailableSOAP"},
+    {0x0016020A, nullptr, "ListTitles"},
+    {0x002D0042, nullptr, "DownloadTickets"},
+    {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"},
-    {0x00020000, nullptr,                  "GetUpdateDownloadProgress"},
-    {0x00040000, nullptr,                  "FinishTitlesInstall"},
-    {0x00050000, nullptr,                  "CheckForSysUpdateEvent"},
-    {0x00090000, CheckSysUpdateAvailable,  "CheckSysUpdateAvailable"},
-    {0x000A0000, nullptr,                  "GetState"},
+    {0x00010000, nullptr, "StartSysUpdate"},
+    {0x00020000, nullptr, "GetUpdateDownloadProgress"},
+    {0x00040000, nullptr, "FinishTitlesInstall"},
+    {0x00050000, nullptr, "CheckForSysUpdateEvent"},
+    {0x00090000, CheckSysUpdateAvailable, "CheckSysUpdateAvailable"},
+    {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/nim/nim_u.h b/src/core/hle/service/nim/nim_u.h
index bc89dc0f3..c4b74985a 100644
--- a/src/core/hle/service/nim/nim_u.h
+++ b/src/core/hle/service/nim/nim_u.h
@@ -1,6 +1,6 @@
 // Copyright 2015 Citra Emulator Project
 // Licensed under GPLv2 or any later version
-// Refer to the license.txt file included..
+// Refer to the license.txt file included.
 
 #pragma once
 
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"},
-    {0x000200C0, nullptr,                      "LaunchTitle"},
-    {0x00030000, nullptr,                      "TerminateApplication"},
-    {0x00040040, nullptr,                      "TerminateProcess"},
-    {0x000500C0, nullptr,                      "LaunchApplicationFIRM"},
-    {0x00060042, nullptr,                      "SetFIRMParams4A0"},
-    {0x00070042, nullptr,                      "CardUpdateInitialize"},
-    {0x00080000, nullptr,                      "CardUpdateShutdown"},
-    {0x000D0140, nullptr,                      "SetTWLBannerHMAC"},
-    {0x000E0000, nullptr,                      "ShutdownAsync"},
-    {0x00100180, nullptr,                      "RebootSystem"},
-    {0x00110100, nullptr,                      "TerminateTitle"},
-    {0x001200C0, nullptr,                      "SetApplicationCpuTimeLimit"},
-    {0x00150140, nullptr,                      "LaunchApplication"},
-    {0x00160000, nullptr,                      "RebootSystemClean"},
+    {0x000100C0, nullptr, "LaunchFIRM"},
+    {0x000200C0, nullptr, "LaunchTitle"},
+    {0x00030000, nullptr, "TerminateApplication"},
+    {0x00040040, nullptr, "TerminateProcess"},
+    {0x000500C0, nullptr, "LaunchApplicationFIRM"},
+    {0x00060042, nullptr, "SetFIRMParams4A0"},
+    {0x00070042, nullptr, "CardUpdateInitialize"},
+    {0x00080000, nullptr, "CardUpdateShutdown"},
+    {0x000D0140, nullptr, "SetTWLBannerHMAC"},
+    {0x000E0000, nullptr, "ShutdownAsync"},
+    {0x00100180, nullptr, "RebootSystem"},
+    {0x00110100, nullptr, "TerminateTitle"},
+    {0x001200C0, nullptr, "SetApplicationCpuTimeLimit"},
+    {0x00150140, nullptr, "LaunchApplication"},
+    {0x00160000, nullptr, "RebootSystemClean"},
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/nwm_uds.cpp b/src/core/hle/service/nwm_uds.cpp
index ae4640409..27e829209 100644
--- a/src/core/hle/service/nwm_uds.cpp
+++ b/src/core/hle/service/nwm_uds.cpp
@@ -4,7 +4,6 @@
 
 #include "common/common_types.h"
 #include "common/logging/log.h"
-
 #include "core/hle/kernel/event.h"
 #include "core/hle/service/nwm_uds.h"
 
@@ -54,22 +53,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 unk2            = cmd_buff[3];
-    u32 mac_address     = cmd_buff[4];
+    u32 unk1 = cmd_buff[2];
+    u32 unk2 = cmd_buff[3];
+    u32 mac_address = cmd_buff[4];
 
-    u32 unk3            = cmd_buff[6];
+    u32 unk3 = cmd_buff[6];
 
-    u32 wlan_comm_id    = cmd_buff[15];
-    u32 ctr_gen_id      = cmd_buff[16];
-    u32 value           = cmd_buff[17];
-    u32 input_handle    = cmd_buff[18];
+    u32 wlan_comm_id = cmd_buff[15];
+    u32 ctr_gen_id = cmd_buff[16];
+    u32 value = cmd_buff[17];
+    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 +92,47 @@ static void RecvBeaconBroadcastData(Service::Interface* self) {
  */
 static void Initialize(Service::Interface* self) {
     u32* cmd_buff = Kernel::GetCommandBuffer();
-    u32 unk1   = cmd_buff[1];
-    u32 unk2   = cmd_buff[12];
-    u32 value  = cmd_buff[13];
+    u32 unk1 = cmd_buff[1];
+    u32 unk2 = cmd_buff[12];
+    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"},
-    {0x00030000, Shutdown,                  "Shutdown"},
-    {0x00040402, nullptr,                   "CreateNetwork"},
-    {0x00050040, nullptr,                   "EjectClient"},
-    {0x00060000, nullptr,                   "EjectSpectator"},
-    {0x00070080, nullptr,                   "UpdateNetworkAttribute"},
-    {0x00080000, nullptr,                   "DestroyNetwork"},
-    {0x000A0000, nullptr,                   "DisconnectNetwork"},
-    {0x000B0000, nullptr,                   "GetConnectionStatus"},
-    {0x000D0040, nullptr,                   "GetNodeInformation"},
-    {0x000F0404, RecvBeaconBroadcastData,   "RecvBeaconBroadcastData"},
-    {0x00100042, nullptr,                   "SetBeaconAdditionalData"},
-    {0x00110040, nullptr,                   "GetApplicationData"},
-    {0x00120100, nullptr,                   "Bind"},
-    {0x00130040, nullptr,                   "Unbind"},
-    {0x001400C0, nullptr,                   "RecvBroadcastDataFrame"},
-    {0x00150080, nullptr,                   "SetMaxSendDelay"},
-    {0x00170182, nullptr,                   "SendTo"},
-    {0x001A0000, nullptr,                   "GetChannel"},
-    {0x001B0302, Initialize,                "Initialize"},
-    {0x001D0044, nullptr,                   "BeginHostingNetwork"},
-    {0x001E0084, nullptr,                   "ConnectToNetwork"},
-    {0x001F0006, nullptr,                   "DecryptBeaconData"},
-    {0x00200040, nullptr,                   "Flush"},
-    {0x00210080, nullptr,                   "SetProbeResponseParam"},
-    {0x00220402, nullptr,                   "ScanOnConnection"},
+    {0x00020000, nullptr, "Scrap"},
+    {0x00030000, Shutdown, "Shutdown"},
+    {0x00040402, nullptr, "CreateNetwork"},
+    {0x00050040, nullptr, "EjectClient"},
+    {0x00060000, nullptr, "EjectSpectator"},
+    {0x00070080, nullptr, "UpdateNetworkAttribute"},
+    {0x00080000, nullptr, "DestroyNetwork"},
+    {0x000A0000, nullptr, "DisconnectNetwork"},
+    {0x000B0000, nullptr, "GetConnectionStatus"},
+    {0x000D0040, nullptr, "GetNodeInformation"},
+    {0x000F0404, RecvBeaconBroadcastData, "RecvBeaconBroadcastData"},
+    {0x00100042, nullptr, "SetBeaconAdditionalData"},
+    {0x00110040, nullptr, "GetApplicationData"},
+    {0x00120100, nullptr, "Bind"},
+    {0x00130040, nullptr, "Unbind"},
+    {0x001400C0, nullptr, "RecvBroadcastDataFrame"},
+    {0x00150080, nullptr, "SetMaxSendDelay"},
+    {0x00170182, nullptr, "SendTo"},
+    {0x001A0000, nullptr, "GetChannel"},
+    {0x001B0302, Initialize, "Initialize"},
+    {0x001D0044, nullptr, "BeginHostingNetwork"},
+    {0x001E0084, nullptr, "ConnectToNetwork"},
+    {0x001F0006, nullptr, "DecryptBeaconData"},
+    {0x00200040, nullptr, "Flush"},
+    {0x00210080, nullptr, "SetProbeResponseParam"},
+    {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"},
-    {0x00020082, nullptr,                 "LaunchFIRMSetParams"},
-    {0x00030080, nullptr,                 "TerminateProcesse"},
-    {0x00040100, nullptr,                 "TerminateProcessTID"},
-    {0x000500C0, nullptr,                 "TerminateProcessTID_unknown"},
-    {0x00070042, nullptr,                 "GetFIRMLaunchParams"},
-    {0x00080100, nullptr,                 "GetTitleExheaderFlags"},
-    {0x00090042, nullptr,                 "SetFIRMLaunchParams"},
-    {0x000A0140, nullptr,                 "SetResourceLimit"},
-    {0x000B0140, nullptr,                 "GetResourceLimitMax"},
-    {0x000C0080, nullptr,                 "UnregisterProcess"},
-    {0x000D0240, nullptr,                 "LaunchTitleUpdate"},
+    {0x00010140, nullptr, "LaunchTitle"},
+    {0x00020082, nullptr, "LaunchFIRMSetParams"},
+    {0x00030080, nullptr, "TerminateProcesse"},
+    {0x00040100, nullptr, "TerminateProcessTID"},
+    {0x000500C0, nullptr, "TerminateProcessTID_unknown"},
+    {0x00070042, nullptr, "GetFIRMLaunchParams"},
+    {0x00080100, nullptr, "GetTitleExheaderFlags"},
+    {0x00090042, nullptr, "SetFIRMLaunchParams"},
+    {0x000A0140, nullptr, "SetResourceLimit"},
+    {0x000B0140, nullptr, "GetResourceLimitMax"},
+    {0x000C0080, nullptr, "UnregisterProcess"},
+    {0x000D0240, nullptr, "LaunchTitleUpdate"},
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/ptm/ptm.cpp b/src/core/hle/service/ptm/ptm.cpp
index e2c17d93b..6e6b63329 100644
--- a/src/core/hle/service/ptm/ptm.cpp
+++ b/src/core/hle/service/ptm/ptm.cpp
@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #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"
@@ -11,12 +10,13 @@
 #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,18 +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() {
-
-}
+void Shutdown() {}
 
 } // namespace PTM
 } // namespace Service
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,
-    LowBattery         = 2,
-    HalfFull           = 3,
-    MostlyFull         = 4,
-    CompletelyFull     = 5,
+    CriticalBattery = 1,
+    LowBattery = 2,
+    HalfFull = 3,
+    MostlyFull = 4,
+    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
-    u16 total_coins; ///< Total Play Coins
+    u32 magic;               ///< Magic number: 0x4F00
+    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 last_step_count; ///< Step count for the day the last 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
     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"},
-    {0x08080000, nullptr,               "GetPlayHistoryStart"},
-    {0x08090000, nullptr,               "GetPlayHistoryLength"},
-    {0x080B0080, nullptr,               "CalcPlayHistoryStart"},
+    {0x08070082, nullptr, "GetPlayHistory"},
+    {0x08080000, nullptr, "GetPlayHistoryStart"},
+    {0x08090000, nullptr, "GetPlayHistoryLength"},
+    {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 {
-    return "ptm:play";
-}
+    std::string GetPortName() const override {
+        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"},
-    {0x04020042, nullptr,             "ReplySleepQuery"},
-    {0x04030042, nullptr,             "NotifySleepPreparationComplete"},
-    {0x04040102, nullptr,             "SetWakeupTrigger"},
-    {0x04050000, nullptr,             "GetAwakeReason"},
-    {0x04060000, nullptr,             "RequestSleep"},
-    {0x040700C0, nullptr,             "ShutdownAsync"},
-    {0x04080000, nullptr,             "Awake"},
-    {0x04090080, nullptr,             "RebootAsync"},
-    {0x040A0000, CheckNew3DS,         "CheckNew3DS"},
-    {0x08010640, nullptr,             "SetInfoLEDPattern"},
-    {0x08020040, nullptr,             "SetInfoLEDPatternHeader"},
-    {0x08030000, nullptr,             "GetInfoLEDStatus"},
-    {0x08040040, nullptr,             "SetBatteryEmptyLEDPattern"},
-    {0x08050000, nullptr,             "ClearStepHistory"},
-    {0x080600C2, nullptr,             "SetStepHistory"},
-    {0x08070082, nullptr,             "GetPlayHistory"},
-    {0x08080000, nullptr,             "GetPlayHistoryStart"},
-    {0x08090000, nullptr,             "GetPlayHistoryLength"},
-    {0x080A0000, nullptr,             "ClearPlayHistory"},
-    {0x080B0080, nullptr,             "CalcPlayHistoryStart"},
-    {0x080C0080, nullptr,             "SetUserTime"},
-    {0x080D0000, nullptr,             "InvalidateSystemTime"},
-    {0x080E0140, nullptr,             "NotifyPlayEvent"},
-    {0x080F0000, IsLegacyPowerOff,    "IsLegacyPowerOff"},
-    {0x08100000, nullptr,             "ClearLegacyPowerOff"},
-    {0x08110000, GetShellState,       "GetShellState"},
-    {0x08120000, nullptr,             "IsShutdownByBatteryEmpty"},
-    {0x08130000, nullptr,             "FormatSavedata"},
-    {0x08140000, nullptr,             "GetLegacyJumpProhibitedFlag"},
-    {0x08180040, nullptr,             "ConfigureNew3DSCPU"},
+    {0x040100C0, nullptr, "SetRtcAlarmEx"},
+    {0x04020042, nullptr, "ReplySleepQuery"},
+    {0x04030042, nullptr, "NotifySleepPreparationComplete"},
+    {0x04040102, nullptr, "SetWakeupTrigger"},
+    {0x04050000, nullptr, "GetAwakeReason"},
+    {0x04060000, nullptr, "RequestSleep"},
+    {0x040700C0, nullptr, "ShutdownAsync"},
+    {0x04080000, nullptr, "Awake"},
+    {0x04090080, nullptr, "RebootAsync"},
+    {0x040A0000, CheckNew3DS, "CheckNew3DS"},
+    {0x08010640, nullptr, "SetInfoLEDPattern"},
+    {0x08020040, nullptr, "SetInfoLEDPatternHeader"},
+    {0x08030000, nullptr, "GetInfoLEDStatus"},
+    {0x08040040, nullptr, "SetBatteryEmptyLEDPattern"},
+    {0x08050000, nullptr, "ClearStepHistory"},
+    {0x080600C2, nullptr, "SetStepHistory"},
+    {0x08070082, nullptr, "GetPlayHistory"},
+    {0x08080000, nullptr, "GetPlayHistoryStart"},
+    {0x08090000, nullptr, "GetPlayHistoryLength"},
+    {0x080A0000, nullptr, "ClearPlayHistory"},
+    {0x080B0080, nullptr, "CalcPlayHistoryStart"},
+    {0x080C0080, nullptr, "SetUserTime"},
+    {0x080D0000, nullptr, "InvalidateSystemTime"},
+    {0x080E0140, nullptr, "NotifyPlayEvent"},
+    {0x080F0000, IsLegacyPowerOff, "IsLegacyPowerOff"},
+    {0x08100000, nullptr, "ClearLegacyPowerOff"},
+    {0x08110000, GetShellState, "GetShellState"},
+    {0x08120000, nullptr, "IsShutdownByBatteryEmpty"},
+    {0x08130000, nullptr, "FormatSavedata"},
+    {0x08140000, nullptr, "GetLegacyJumpProhibitedFlag"},
+    {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"},
-    {0x00020080, nullptr,               "SetRtcAlarm"},
-    {0x00030000, nullptr,               "GetRtcAlarm"},
-    {0x00040000, nullptr,               "CancelRtcAlarm"},
-    {0x00050000, GetAdapterState,       "GetAdapterState"},
-    {0x00060000, GetShellState,         "GetShellState"},
-    {0x00070000, GetBatteryLevel,       "GetBatteryLevel"},
+    {0x00010002, nullptr, "RegisterAlarmClient"},
+    {0x00020080, nullptr, "SetRtcAlarm"},
+    {0x00030000, nullptr, "GetRtcAlarm"},
+    {0x00040000, nullptr, "CancelRtcAlarm"},
+    {0x00050000, GetAdapterState, "GetAdapterState"},
+    {0x00060000, GetShellState, "GetShellState"},
+    {0x00070000, GetBatteryLevel, "GetBatteryLevel"},
     {0x00080000, GetBatteryChargeState, "GetBatteryChargeState"},
-    {0x00090000, nullptr,               "GetPedometerState"},
-    {0x000A0042, nullptr,               "GetStepHistoryEntry"},
-    {0x000B00C2, nullptr,               "GetStepHistory"},
-    {0x000C0000, GetTotalStepCount,     "GetTotalStepCount"},
-    {0x000D0040, nullptr,               "SetPedometerRecordingMode"},
-    {0x000E0000, nullptr,               "GetPedometerRecordingMode"},
-    {0x000F0084, nullptr,               "GetStepHistoryAll"},
+    {0x00090000, nullptr, "GetPedometerState"},
+    {0x000A0042, nullptr, "GetStepHistoryEntry"},
+    {0x000B00C2, nullptr, "GetStepHistory"},
+    {0x000C0000, GetTotalStepCount, "GetTotalStepCount"},
+    {0x000D0040, nullptr, "SetPedometerRecordingMode"},
+    {0x000E0000, nullptr, "GetPedometerRecordingMode"},
+    {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..ca7eeac8a 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -4,42 +4,40 @@
 
 #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"
-#include "core/hle/service/csnd_snd.h"
-#include "core/hle/service/dsp_dsp.h"
-#include "core/hle/service/err_f.h"
-#include "core/hle/service/gsp_gpu.h"
-#include "core/hle/service/gsp_lcd.h"
-#include "core/hle/service/http_c.h"
-#include "core/hle/service/mic_u.h"
-#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/soc_u.h"
-#include "core/hle/service/srv.h"
-#include "core/hle/service/ssl_c.h"
-#include "core/hle/service/y2r_u.h"
-
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/apt/apt.h"
 #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/csnd_snd.h"
 #include "core/hle/service/dlp/dlp.h"
+#include "core/hle/service/dsp_dsp.h"
+#include "core/hle/service/err_f.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/gsp_gpu.h"
+#include "core/hle/service/gsp_lcd.h"
 #include "core/hle/service/hid/hid.h"
+#include "core/hle/service/http_c.h"
 #include "core/hle/service/ir/ir.h"
 #include "core/hle/service/ldr_ro/ldr_ro.h"
+#include "core/hle/service/mic_u.h"
 #include "core/hle/service/ndm/ndm.h"
 #include "core/hle/service/news/news.h"
 #include "core/hle/service/nim/nim.h"
+#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/ptm/ptm.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"
+#include "core/hle/service/y2r_u.h"
 
 namespace Service {
 
@@ -50,11 +48,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 +66,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;
-        LOG_ERROR(Service, "unknown / unimplemented %s", MakeFunctionString(function_name.c_str(), GetPortName().c_str(), cmd_buff).c_str());
+        std::string function_name = (itr == m_functions.end())
+                                        ? 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 +168,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..39b5ffaae 100644
--- a/src/core/hle/service/service.h
+++ b/src/core/hle/service/service.h
@@ -7,11 +7,8 @@
 #include <cstddef>
 #include <string>
 #include <unordered_map>
-
 #include <boost/container/flat_map.hpp>
-
 #include "common/common_types.h"
-
 #include "core/hle/kernel/session.h"
 #include "core/hle/result.h"
 
@@ -28,13 +25,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;
-        Function    func;
+        u32 id;
+        Function func;
         const char* name;
     };
 
@@ -49,7 +48,6 @@ public:
     ResultVal<bool> SyncRequest() override;
 
 protected:
-
     /**
      * Registers the functions in the service
      */
@@ -62,7 +60,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..4279b67fb 100644
--- a/src/core/hle/service/soc_u.cpp
+++ b/src/core/hle/service/soc_u.cpp
@@ -6,53 +6,51 @@
 #include <cstring>
 #include <unordered_map>
 #include <vector>
-
 #include "common/assert.h"
 #include "common/bit_field.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "common/scope_exit.h"
-
 #include "core/hle/kernel/session.h"
 #include "core/hle/result.h"
 #include "core/hle/service/soc_u.h"
 #include "core/memory.h"
 
 #ifdef _WIN32
-    #include <winsock2.h>
-    #include <ws2tcpip.h>
-
-    // MinGW does not define several errno constants
-    #ifndef _MSC_VER
-        #define EBADMSG 104
-        #define ENODATA 120
-        #define ENOMSG  122
-        #define ENOSR   124
-        #define ENOSTR  125
-        #define ETIME   137
-        #define EIDRM   2001
-        #define ENOLINK 2002
-    #endif // _MSC_VER
+#include <winsock2.h>
+#include <ws2tcpip.h>
+
+// MinGW does not define several errno constants
+#ifndef _MSC_VER
+#define EBADMSG 104
+#define ENODATA 120
+#define ENOMSG 122
+#define ENOSR 124
+#define ENOSTR 125
+#define ETIME 137
+#define EIDRM 2001
+#define ENOLINK 2002
+#endif // _MSC_VER
 #else
-    #include <cerrno>
-    #include <fcntl.h>
-    #include <netinet/in.h>
-    #include <netdb.h>
-    #include <poll.h>
-    #include <sys/socket.h>
-    #include <unistd.h>
+#include <cerrno>
+#include <fcntl.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <poll.h>
+#include <sys/socket.h>
+#include <unistd.h>
 #endif
 
 #ifdef _WIN32
-#    define WSAEAGAIN      WSAEWOULDBLOCK
-#    define WSAEMULTIHOP   -1 // Invalid dummy value
-#    define ERRNO(x)       WSA##x
-#    define GET_ERRNO      WSAGetLastError()
-#    define poll(x, y, z)  WSAPoll(x, y, z);
+#define WSAEAGAIN WSAEWOULDBLOCK
+#define WSAEMULTIHOP -1 // Invalid dummy value
+#define ERRNO(x) WSA##x
+#define GET_ERRNO WSAGetLastError()
+#define poll(x, y, z) WSAPoll(x, y, z);
 #else
-#    define ERRNO(x)       x
-#    define GET_ERRNO      errno
-#    define closesocket(x) close(x)
+#define ERRNO(x) x
+#define GET_ERRNO errno
+#define closesocket(x) close(x)
 #endif
 
 static const s32 SOCKET_ERROR_VALUE = -1;
@@ -63,83 +61,83 @@ 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 = { {
-    { E2BIG, 1 },
-    { ERRNO(EACCES), 2 },
-    { ERRNO(EADDRINUSE), 3 },
-    { ERRNO(EADDRNOTAVAIL), 4 },
-    { ERRNO(EAFNOSUPPORT), 5 },
-    { ERRNO(EAGAIN), 6 },
-    { ERRNO(EALREADY), 7 },
-    { ERRNO(EBADF), 8 },
-    { EBADMSG, 9 },
-    { EBUSY, 10 },
-    { ECANCELED, 11 },
-    { ECHILD, 12 },
-    { ERRNO(ECONNABORTED), 13 },
-    { ERRNO(ECONNREFUSED), 14 },
-    { ERRNO(ECONNRESET), 15 },
-    { EDEADLK, 16 },
-    { ERRNO(EDESTADDRREQ), 17 },
-    { EDOM, 18 },
-    { ERRNO(EDQUOT), 19 },
-    { EEXIST, 20 },
-    { ERRNO(EFAULT), 21 },
-    { EFBIG, 22 },
-    { ERRNO(EHOSTUNREACH), 23 },
-    { EIDRM, 24 },
-    { EILSEQ, 25 },
-    { ERRNO(EINPROGRESS), 26 },
-    { ERRNO(EINTR), 27 },
-    { ERRNO(EINVAL), 28 },
-    { EIO, 29 },
-    { ERRNO(EISCONN), 30 },
-    { EISDIR, 31 },
-    { ERRNO(ELOOP), 32 },
-    { ERRNO(EMFILE), 33 },
-    { EMLINK, 34 },
-    { ERRNO(EMSGSIZE), 35 },
-    { ERRNO(EMULTIHOP), 36 },
-    { ERRNO(ENAMETOOLONG), 37 },
-    { ERRNO(ENETDOWN), 38 },
-    { ERRNO(ENETRESET), 39 },
-    { ERRNO(ENETUNREACH), 40 },
-    { ENFILE, 41 },
-    { ERRNO(ENOBUFS), 42 },
-    { ENODATA, 43 },
-    { ENODEV, 44 },
-    { ENOENT, 45 },
-    { ENOEXEC, 46 },
-    { ENOLCK, 47 },
-    { ENOLINK, 48 },
-    { ENOMEM, 49 },
-    { ENOMSG, 50 },
-    { ERRNO(ENOPROTOOPT), 51 },
-    { ENOSPC, 52 },
-    { ENOSR, 53 },
-    { ENOSTR, 54 },
-    { ENOSYS, 55 },
-    { ERRNO(ENOTCONN), 56 },
-    { ENOTDIR, 57 },
-    { ERRNO(ENOTEMPTY), 58 },
-    { ERRNO(ENOTSOCK), 59 },
-    { ENOTSUP, 60 },
-    { ENOTTY, 61 },
-    { ENXIO, 62 },
-    { ERRNO(EOPNOTSUPP), 63 },
-    { EOVERFLOW, 64 },
-    { EPERM, 65 },
-    { EPIPE, 66 },
-    { EPROTO, 67 },
-    { ERRNO(EPROTONOSUPPORT), 68 },
-    { ERRNO(EPROTOTYPE), 69 },
-    { ERANGE, 70 },
-    { EROFS, 71 },
-    { ESPIPE, 72 },
-    { ESRCH, 73 },
-    { ERRNO(ESTALE), 74 },
-    { ETIME, 75 },
-    { ERRNO(ETIMEDOUT), 76 }
+static const std::unordered_map<int, int> error_map = {{
+    {E2BIG, 1},
+    {ERRNO(EACCES), 2},
+    {ERRNO(EADDRINUSE), 3},
+    {ERRNO(EADDRNOTAVAIL), 4},
+    {ERRNO(EAFNOSUPPORT), 5},
+    {ERRNO(EAGAIN), 6},
+    {ERRNO(EALREADY), 7},
+    {ERRNO(EBADF), 8},
+    {EBADMSG, 9},
+    {EBUSY, 10},
+    {ECANCELED, 11},
+    {ECHILD, 12},
+    {ERRNO(ECONNABORTED), 13},
+    {ERRNO(ECONNREFUSED), 14},
+    {ERRNO(ECONNRESET), 15},
+    {EDEADLK, 16},
+    {ERRNO(EDESTADDRREQ), 17},
+    {EDOM, 18},
+    {ERRNO(EDQUOT), 19},
+    {EEXIST, 20},
+    {ERRNO(EFAULT), 21},
+    {EFBIG, 22},
+    {ERRNO(EHOSTUNREACH), 23},
+    {EIDRM, 24},
+    {EILSEQ, 25},
+    {ERRNO(EINPROGRESS), 26},
+    {ERRNO(EINTR), 27},
+    {ERRNO(EINVAL), 28},
+    {EIO, 29},
+    {ERRNO(EISCONN), 30},
+    {EISDIR, 31},
+    {ERRNO(ELOOP), 32},
+    {ERRNO(EMFILE), 33},
+    {EMLINK, 34},
+    {ERRNO(EMSGSIZE), 35},
+    {ERRNO(EMULTIHOP), 36},
+    {ERRNO(ENAMETOOLONG), 37},
+    {ERRNO(ENETDOWN), 38},
+    {ERRNO(ENETRESET), 39},
+    {ERRNO(ENETUNREACH), 40},
+    {ENFILE, 41},
+    {ERRNO(ENOBUFS), 42},
+    {ENODATA, 43},
+    {ENODEV, 44},
+    {ENOENT, 45},
+    {ENOEXEC, 46},
+    {ENOLCK, 47},
+    {ENOLINK, 48},
+    {ENOMEM, 49},
+    {ENOMSG, 50},
+    {ERRNO(ENOPROTOOPT), 51},
+    {ENOSPC, 52},
+    {ENOSR, 53},
+    {ENOSTR, 54},
+    {ENOSYS, 55},
+    {ERRNO(ENOTCONN), 56},
+    {ENOTDIR, 57},
+    {ERRNO(ENOTEMPTY), 58},
+    {ERRNO(ENOTSOCK), 59},
+    {ENOTSUP, 60},
+    {ENOTTY, 61},
+    {ENXIO, 62},
+    {ERRNO(EOPNOTSUPP), 63},
+    {EOVERFLOW, 64},
+    {EPERM, 65},
+    {EPIPE, 66},
+    {EPROTO, 67},
+    {ERRNO(EPROTONOSUPPORT), 68},
+    {ERRNO(EPROTOTYPE), 69},
+    {ERANGE, 70},
+    {EROFS, 71},
+    {ESPIPE, 72},
+    {ESRCH, 73},
+    {ERRNO(ESTALE), 74},
+    {ETIME, 75},
+    {ERRNO(ETIMEDOUT), 76},
 }};
 
 /// Converts a network error from platform-specific to 3ds-specific
@@ -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 = { {
-    { 0x0004,   SO_REUSEADDR },
-    { 0x0080,   -1 },
-    { 0x0100,   -1 },
-    { 0x1001,   SO_SNDBUF },
-    { 0x1002,   SO_RCVBUF },
-    { 0x1003,   -1 },
+static const std::unordered_map<int, int> sockopt_map = {{
+    {0x0004, SO_REUSEADDR},
+    {0x0080, -1},
+    {0x0100, -1},
+    {0x1001, SO_SNDBUF},
+    {0x1002, SO_RCVBUF},
+    {0x1003, -1},
 #ifdef _WIN32
     /// Unsupported in WinSock2
-    { 0x1004,   -1 },
+    {0x1004, -1},
 #else
-    { 0x1004,   SO_RCVLOWAT },
+    {0x1004, SO_RCVLOWAT},
 #endif
-    { 0x1008,   SO_TYPE },
-    { 0x1009,   SO_ERROR },
+    {0x1008, SO_TYPE},
+    {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 sa_family; ///< The address family of the sockaddr
+        u8 len;           ///< The length of the entire structure, only the set fields count
+        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
-        u32 sin_addr; ///< The actual address of the sockaddr_in
+        u16 sin_port;  ///< The port associated with this 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[2] = posix_ret;
+        cmd_buffer[1] = result;
+        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"},
-    {0x000200C2, Socket,                        "Socket"},
-    {0x00030082, Listen,                        "Listen"},
-    {0x00040082, Accept,                        "Accept"},
-    {0x00050084, Bind,                          "Bind"},
-    {0x00060084, Connect,                       "Connect"},
-    {0x00070104, nullptr,                       "recvfrom_other"},
-    {0x00080102, RecvFrom,                      "RecvFrom"},
-    {0x00090106, nullptr,                       "sendto_other"},
-    {0x000A0106, SendTo,                        "SendTo"},
-    {0x000B0042, Close,                         "Close"},
-    {0x000C0082, Shutdown,                      "Shutdown"},
-    {0x000D0082, nullptr,                       "GetHostByName"},
-    {0x000E00C2, nullptr,                       "GetHostByAddr"},
-    {0x000F0106, nullptr,                       "GetAddrInfo"},
-    {0x00100102, nullptr,                       "GetNameInfo"},
-    {0x00110102, GetSockOpt,                    "GetSockOpt"},
-    {0x00120104, SetSockOpt,                    "SetSockOpt"},
-    {0x001300C2, Fcntl,                         "Fcntl"},
-    {0x00140084, Poll,                          "Poll"},
-    {0x00150042, nullptr,                       "SockAtMark"},
-    {0x00160000, GetHostId,                     "GetHostId"},
-    {0x00170082, GetSockName,                   "GetSockName"},
-    {0x00180082, GetPeerName,                   "GetPeerName"},
-    {0x00190000, ShutdownSockets,               "ShutdownSockets"},
-    {0x001A00C0, nullptr,                       "GetNetworkOpt"},
-    {0x001B0040, nullptr,                       "ICMPSocket"},
-    {0x001C0104, nullptr,                       "ICMPPing"},
-    {0x001D0040, nullptr,                       "ICMPCancel"},
-    {0x001E0040, nullptr,                       "ICMPClose"},
-    {0x001F0040, nullptr,                       "GetResolverInfo"},
-    {0x00210002, nullptr,                       "CloseSockets"},
-    {0x00230040, nullptr,                       "AddGlobalSocket"},
+    {0x00010044, InitializeSockets, "InitializeSockets"},
+    {0x000200C2, Socket, "Socket"},
+    {0x00030082, Listen, "Listen"},
+    {0x00040082, Accept, "Accept"},
+    {0x00050084, Bind, "Bind"},
+    {0x00060084, Connect, "Connect"},
+    {0x00070104, nullptr, "recvfrom_other"},
+    {0x00080102, RecvFrom, "RecvFrom"},
+    {0x00090106, nullptr, "sendto_other"},
+    {0x000A0106, SendTo, "SendTo"},
+    {0x000B0042, Close, "Close"},
+    {0x000C0082, Shutdown, "Shutdown"},
+    {0x000D0082, nullptr, "GetHostByName"},
+    {0x000E00C2, nullptr, "GetHostByAddr"},
+    {0x000F0106, nullptr, "GetAddrInfo"},
+    {0x00100102, nullptr, "GetNameInfo"},
+    {0x00110102, GetSockOpt, "GetSockOpt"},
+    {0x00120104, SetSockOpt, "SetSockOpt"},
+    {0x001300C2, Fcntl, "Fcntl"},
+    {0x00140084, Poll, "Poll"},
+    {0x00150042, nullptr, "SockAtMark"},
+    {0x00160000, GetHostId, "GetHostId"},
+    {0x00170082, GetSockName, "GetSockName"},
+    {0x00180082, GetPeerName, "GetPeerName"},
+    {0x00190000, ShutdownSockets, "ShutdownSockets"},
+    {0x001A00C0, nullptr, "GetNetworkOpt"},
+    {0x001B0040, nullptr, "ICMPSocket"},
+    {0x001C0104, nullptr, "ICMPPing"},
+    {0x001D0040, nullptr, "ICMPCancel"},
+    {0x001E0040, nullptr, "ICMPClose"},
+    {0x001F0040, nullptr, "GetResolverInfo"},
+    {0x00210002, nullptr, "CloseSockets"},
+    {0x00230040, nullptr, "AddGlobalSocket"},
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/soc_u.h b/src/core/hle/service/soc_u.h
index a091f597c..8d02ed30f 100644
--- a/src/core/hle/service/soc_u.h
+++ b/src/core/hle/service/soc_u.h
@@ -5,7 +5,6 @@
 #pragma once
 
 #include <string>
-
 #include "core/hle/service/service.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/srv.cpp b/src/core/hle/service/srv.cpp
index 3c05f836b..b25be413a 100644
--- a/src/core/hle/service/srv.cpp
+++ b/src/core/hle/service/srv.cpp
@@ -4,9 +4,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 +27,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[1] = RESULT_SUCCESS.raw; // No error
+    cmd_buff[0] = IPC::MakeHeader(0x1, 0x1, 0); // 0x10040
+    cmd_buff[1] = RESULT_SUCCESS.raw;           // No error
     LOG_WARNING(Service_SRV, "(STUBBED) called");
 }
 
@@ -56,7 +56,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 +105,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 +124,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 +145,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
-    LOG_WARNING(Service_SRV, "(STUBBED) called, notification_id=0x%X, flags=%u", notification_id, flags);
+    cmd_buff[1] = RESULT_SUCCESS.raw;           // No error
+    LOG_WARNING(Service_SRV, "(STUBBED) called, notification_id=0x%X, flags=%u", notification_id,
+                flags);
 }
 
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010002, RegisterClient,          "RegisterClient"},
-    {0x00020000, EnableNotification,      "EnableNotification"},
-    {0x00030100, nullptr,                 "RegisterService"},
-    {0x000400C0, nullptr,                 "UnregisterService"},
-    {0x00050100, GetServiceHandle,        "GetServiceHandle"},
-    {0x000600C2, nullptr,                 "RegisterPort"},
-    {0x000700C0, nullptr,                 "UnregisterPort"},
-    {0x00080100, nullptr,                 "GetPort"},
-    {0x00090040, Subscribe,               "Subscribe"},
-    {0x000A0040, Unsubscribe,             "Unsubscribe"},
-    {0x000B0000, nullptr,                 "ReceiveNotification"},
-    {0x000C0080, PublishToSubscriber,     "PublishToSubscriber"},
-    {0x000D0040, nullptr,                 "PublishAndGetSubscriber"},
-    {0x000E00C0, nullptr,                 "IsServiceRegistered"},
+    {0x00010002, RegisterClient, "RegisterClient"},
+    {0x00020000, EnableNotification, "EnableNotification"},
+    {0x00030100, nullptr, "RegisterService"},
+    {0x000400C0, nullptr, "UnregisterService"},
+    {0x00050100, GetServiceHandle, "GetServiceHandle"},
+    {0x000600C2, nullptr, "RegisterPort"},
+    {0x000700C0, nullptr, "UnregisterPort"},
+    {0x00080100, nullptr, "GetPort"},
+    {0x00090040, Subscribe, "Subscribe"},
+    {0x000A0040, Unsubscribe, "Unsubscribe"},
+    {0x000B0000, nullptr, "ReceiveNotification"},
+    {0x000C0080, PublishToSubscriber, "PublishToSubscriber"},
+    {0x000D0040, nullptr, "PublishAndGetSubscriber"},
+    {0x000E00C0, nullptr, "IsServiceRegistered"},
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/ssl_c.cpp b/src/core/hle/service/ssl_c.cpp
index a8aff1abf..abab1d271 100644
--- a/src/core/hle/service/ssl_c.cpp
+++ b/src/core/hle/service/ssl_c.cpp
@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include <random>
-
 #include "common/common_types.h"
 #include "core/hle/service/ssl_c.h"
 
@@ -37,7 +36,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,26 +59,26 @@ static void GenerateRandomData(Service::Interface* self) {
 }
 
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010002, Initialize,            "Initialize"},
-    {0x000200C2, nullptr,               "CreateContext"},
-    {0x00030000, nullptr,               "CreateRootCertChain"},
-    {0x00040040, nullptr,               "DestroyRootCertChain"},
-    {0x00050082, nullptr,               "AddTrustedRootCA"},
-    {0x00060080, nullptr,               "RootCertChainAddDefaultCert"},
-    {0x00070080, nullptr,               "RootCertChainRemoveCert"},
-    {0x000E0040, nullptr,               "OpenDefaultClientCertContext"},
-    {0x000F0040, nullptr,               "CloseClientCertContext"},
-    {0x00110042, GenerateRandomData,    "GenerateRandomData"},
-    {0x00120042, nullptr,               "InitializeConnectionSession"},
-    {0x00130040, nullptr,               "StartConnection"},
-    {0x00140040, nullptr,               "StartConnectionGetOut"},
-    {0x00150082, nullptr,               "Read"},
-    {0x00170082, nullptr,               "Write"},
-    {0x00180080, nullptr,               "ContextSetRootCertChain"},
-    {0x00190080, nullptr,               "ContextSetClientCert"},
-    {0x001B0080, nullptr,               "ContextClearOpt"},
-    {0x001E0040, nullptr,               "DestroyContext"},
-    {0x001F0082, nullptr,               "ContextInitSharedmem"}
+    {0x00010002, Initialize, "Initialize"},
+    {0x000200C2, nullptr, "CreateContext"},
+    {0x00030000, nullptr, "CreateRootCertChain"},
+    {0x00040040, nullptr, "DestroyRootCertChain"},
+    {0x00050082, nullptr, "AddTrustedRootCA"},
+    {0x00060080, nullptr, "RootCertChainAddDefaultCert"},
+    {0x00070080, nullptr, "RootCertChainRemoveCert"},
+    {0x000E0040, nullptr, "OpenDefaultClientCertContext"},
+    {0x000F0040, nullptr, "CloseClientCertContext"},
+    {0x00110042, GenerateRandomData, "GenerateRandomData"},
+    {0x00120042, nullptr, "InitializeConnectionSession"},
+    {0x00130040, nullptr, "StartConnection"},
+    {0x00140040, nullptr, "StartConnectionGetOut"},
+    {0x00150082, nullptr, "Read"},
+    {0x00170082, nullptr, "Write"},
+    {0x00180080, nullptr, "ContextSetRootCertChain"},
+    {0x00190080, nullptr, "ContextSetClientCert"},
+    {0x001B0080, nullptr, "ContextClearOpt"},
+    {0x001E0040, nullptr, "DestroyContext"},
+    {0x001F0082, nullptr, "ContextInitSharedmem"},
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/y2r_u.cpp b/src/core/hle/service/y2r_u.cpp
index d16578f87..097e09d28 100644
--- a/src/core/hle/service/y2r_u.cpp
+++ b/src/core/hle/service/y2r_u.cpp
@@ -3,11 +3,9 @@
 // Refer to the license.txt file included.
 
 #include <cstring>
-
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/service/y2r_u.h"
@@ -39,16 +37,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, 0x193, 0x77, 0x2F, 0x1DB, -0x1933,  0xA7C, -0x1D51 }}, // ITU_Rec709
-    {{ 0x12A, 0x198, 0xD0, 0x64, 0x204, -0x1BDE, 0x10F2, -0x229B }}, // ITU_Rec601_Scaling
-    {{ 0x12A, 0x1CA, 0x88, 0x36, 0x21C, -0x1F04,  0x99C, -0x2421 }}, // ITU_Rec709_Scaling
+    {{0x100, 0x166, 0xB6, 0x58, 0x1C5, -0x166F, 0x10EE, -0x1C5B}}, // ITU_Rec601
+    {{0x100, 0x193, 0x77, 0x2F, 0x1DB, -0x1933, 0xA7C, -0x1D51}},  // ITU_Rec709
+    {{0x12A, 0x198, 0xD0, 0x64, 0x204, -0x1BDE, 0x10F2, -0x229B}}, // ITU_Rec601_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 +59,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 +71,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 +293,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",
-            conversion.src_Y.image_size, conversion.src_Y.transfer_unit, conversion.src_Y.gap, cmd_buff[6]);
+    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, "
+                           "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 +310,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",
-            conversion.src_U.image_size, conversion.src_U.transfer_unit, conversion.src_U.gap, cmd_buff[6]);
+    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, "
+                           "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 +327,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",
-            conversion.src_V.image_size, conversion.src_V.transfer_unit, conversion.src_V.gap, cmd_buff[6]);
+    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, "
+                           "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 +344,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",
-            conversion.src_YUYV.image_size, conversion.src_YUYV.transfer_unit, conversion.src_YUYV.gap, cmd_buff[6]);
+    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, "
+                           "src_process_handle=0x%08X",
+              conversion.src_YUYV.image_size, conversion.src_YUYV.transfer_unit,
+              conversion.src_YUYV.gap, cmd_buff[6]);
 }
 
 /**
@@ -418,8 +425,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",
-            conversion.dst.image_size, conversion.dst.transfer_unit, conversion.dst.gap, cmd_buff[6]);
+    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, "
+                           "dst_process_handle=0x%08X",
+              conversion.dst.image_size, conversion.dst.transfer_unit, conversion.dst.gap,
+              cmd_buff[6]);
 }
 
 /**
@@ -486,8 +495,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[4], coefficients[5], coefficients[6], coefficients[7]);
+              coefficients[0], coefficients[1], coefficients[2], coefficients[3], coefficients[4],
+              coefficients[5], coefficients[6], coefficients[7]);
 }
 
 static void GetCoefficient(Service::Interface* self) {
@@ -575,8 +584,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);
-    Memory::RasterizerFlushAndInvalidateRegion(Memory::VirtualToPhysicalAddress(conversion.dst.address), total_output_size);
+    u32 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 +659,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 "
-            "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);
+    LOG_DEBUG(
+        Service_Y2R,
+        "called input_format=%hhu output_format=%hhu rotation=%hhu block_alignment=%hhu "
+        "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 +713,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 +724,51 @@ static void GetPackageParameter(Service::Interface* self) {
 }
 
 const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010040, SetInputFormat,          "SetInputFormat"},
-    {0x00020000, GetInputFormat,          "GetInputFormat"},
-    {0x00030040, SetOutputFormat,         "SetOutputFormat"},
-    {0x00040000, GetOutputFormat,         "GetOutputFormat"},
-    {0x00050040, SetRotation,             "SetRotation"},
-    {0x00060000, GetRotation,             "GetRotation"},
-    {0x00070040, SetBlockAlignment,       "SetBlockAlignment"},
-    {0x00080000, GetBlockAlignment,       "GetBlockAlignment"},
-    {0x00090040, SetSpacialDithering,     "SetSpacialDithering"},
-    {0x000A0000, GetSpacialDithering,     "GetSpacialDithering"},
-    {0x000B0040, SetTemporalDithering,    "SetTemporalDithering"},
-    {0x000C0000, GetTemporalDithering,    "GetTemporalDithering"},
+    {0x00010040, SetInputFormat, "SetInputFormat"},
+    {0x00020000, GetInputFormat, "GetInputFormat"},
+    {0x00030040, SetOutputFormat, "SetOutputFormat"},
+    {0x00040000, GetOutputFormat, "GetOutputFormat"},
+    {0x00050040, SetRotation, "SetRotation"},
+    {0x00060000, GetRotation, "GetRotation"},
+    {0x00070040, SetBlockAlignment, "SetBlockAlignment"},
+    {0x00080000, GetBlockAlignment, "GetBlockAlignment"},
+    {0x00090040, SetSpacialDithering, "SetSpacialDithering"},
+    {0x000A0000, GetSpacialDithering, "GetSpacialDithering"},
+    {0x000B0040, SetTemporalDithering, "SetTemporalDithering"},
+    {0x000C0000, GetTemporalDithering, "GetTemporalDithering"},
     {0x000D0040, SetTransferEndInterrupt, "SetTransferEndInterrupt"},
     {0x000E0000, GetTransferEndInterrupt, "GetTransferEndInterrupt"},
-    {0x000F0000, GetTransferEndEvent,     "GetTransferEndEvent"},
-    {0x00100102, SetSendingY,             "SetSendingY"},
-    {0x00110102, SetSendingU,             "SetSendingU"},
-    {0x00120102, SetSendingV,             "SetSendingV"},
-    {0x00130102, SetSendingYUYV,          "SetSendingYUYV"},
-    {0x00140000, IsFinishedSendingYuv,    "IsFinishedSendingYuv"},
-    {0x00150000, IsFinishedSendingY,      "IsFinishedSendingY"},
-    {0x00160000, IsFinishedSendingU,      "IsFinishedSendingU"},
-    {0x00170000, IsFinishedSendingV,      "IsFinishedSendingV"},
-    {0x00180102, SetReceiving,            "SetReceiving"},
-    {0x00190000, IsFinishedReceiving,     "IsFinishedReceiving"},
-    {0x001A0040, SetInputLineWidth,       "SetInputLineWidth"},
-    {0x001B0000, GetInputLineWidth,       "GetInputLineWidth"},
-    {0x001C0040, SetInputLines,           "SetInputLines"},
-    {0x001D0000, GetInputLines,           "GetInputLines"},
-    {0x001E0100, SetCoefficient,          "SetCoefficient"},
-    {0x001F0000, GetCoefficient,          "GetCoefficient"},
-    {0x00200040, SetStandardCoefficient,  "SetStandardCoefficient"},
-    {0x00210040, GetStandardCoefficient,  "GetStandardCoefficient"},
-    {0x00220040, SetAlpha,                "SetAlpha"},
-    {0x00230000, GetAlpha,                "GetAlpha"},
-    {0x00240200, SetDitheringWeightParams,"SetDitheringWeightParams"},
-    {0x00250000, GetDitheringWeightParams,"GetDitheringWeightParams"},
-    {0x00260000, StartConversion,         "StartConversion"},
-    {0x00270000, StopConversion,          "StopConversion"},
-    {0x00280000, IsBusyConversion,        "IsBusyConversion"},
-    {0x002901C0, SetPackageParameter,     "SetPackageParameter"},
-    {0x002A0000, PingProcess,             "PingProcess"},
-    {0x002B0000, DriverInitialize,        "DriverInitialize"},
-    {0x002C0000, DriverFinalize,          "DriverFinalize"},
-    {0x002D0000, GetPackageParameter,     "GetPackageParameter"},
+    {0x000F0000, GetTransferEndEvent, "GetTransferEndEvent"},
+    {0x00100102, SetSendingY, "SetSendingY"},
+    {0x00110102, SetSendingU, "SetSendingU"},
+    {0x00120102, SetSendingV, "SetSendingV"},
+    {0x00130102, SetSendingYUYV, "SetSendingYUYV"},
+    {0x00140000, IsFinishedSendingYuv, "IsFinishedSendingYuv"},
+    {0x00150000, IsFinishedSendingY, "IsFinishedSendingY"},
+    {0x00160000, IsFinishedSendingU, "IsFinishedSendingU"},
+    {0x00170000, IsFinishedSendingV, "IsFinishedSendingV"},
+    {0x00180102, SetReceiving, "SetReceiving"},
+    {0x00190000, IsFinishedReceiving, "IsFinishedReceiving"},
+    {0x001A0040, SetInputLineWidth, "SetInputLineWidth"},
+    {0x001B0000, GetInputLineWidth, "GetInputLineWidth"},
+    {0x001C0040, SetInputLines, "SetInputLines"},
+    {0x001D0000, GetInputLines, "GetInputLines"},
+    {0x001E0100, SetCoefficient, "SetCoefficient"},
+    {0x001F0000, GetCoefficient, "GetCoefficient"},
+    {0x00200040, SetStandardCoefficient, "SetStandardCoefficient"},
+    {0x00210040, GetStandardCoefficient, "GetStandardCoefficient"},
+    {0x00220040, SetAlpha, "SetAlpha"},
+    {0x00230000, GetAlpha, "GetAlpha"},
+    {0x00240200, SetDitheringWeightParams, "SetDitheringWeightParams"},
+    {0x00250000, GetDitheringWeightParams, "GetDitheringWeightParams"},
+    {0x00260000, StartConversion, "StartConversion"},
+    {0x00270000, StopConversion, "StopConversion"},
+    {0x00280000, IsBusyConversion, "IsBusyConversion"},
+    {0x002901C0, SetPackageParameter, "SetPackageParameter"},
+    {0x002A0000, PingProcess, "PingProcess"},
+    {0x002B0000, DriverInitialize, "DriverInitialize"},
+    {0x002C0000, DriverFinalize, "DriverFinalize"},
+    {0x002D0000, GetPackageParameter, "GetPackageParameter"},
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/y2r_u.h b/src/core/hle/service/y2r_u.h
index 95fa2fdb7..1b47b5322 100644
--- a/src/core/hle/service/y2r_u.h
+++ b/src/core/hle/service/y2r_u.h
@@ -6,9 +6,7 @@
 
 #include <array>
 #include <string>
-
 #include "common/common_types.h"
-
 #include "core/hle/result.h"
 #include "core/hle/service/service.h"
 
diff --git a/src/core/hle/shared_page.cpp b/src/core/hle/shared_page.cpp
index 4d9272923..d0d92487d 100644
--- a/src/core/hle/shared_page.cpp
+++ b/src/core/hle/shared_page.cpp
@@ -5,7 +5,6 @@
 #include <chrono>
 #include <cstring>
 #include <ctime>
-
 #include "core/core_timing.h"
 #include "core/hle/shared_page.h"
 
@@ -52,8 +51,8 @@ static u64 GetSystemTime() {
 }
 
 static void UpdateTimeCallback(u64 userdata, int cycles_late) {
-    DateTime& date_time = shared_page.date_time_counter % 2 ?
-        shared_page.date_time_0 : shared_page.date_time_1;
+    DateTime& date_time =
+        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 +73,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..106e47efc 100644
--- a/src/core/hle/shared_page.h
+++ b/src/core/hle/shared_page.h
@@ -13,7 +13,6 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
-
 #include "core/memory.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -32,27 +31,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
-    u8       running_hw;                 // 4
+    u32_le date_time_counter; // 0
+    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_link_level;            // 66
-    u8       wifi_unknown2;              // 67
+    u8 wifi_macaddr[6];                  // 60
+    u8 wifi_link_level;                  // 66
+    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   active_menu_title_id;       // A8
+    u64_le menu_title_id;                // A0
+    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..02b397eba 100644
--- a/src/core/hle/svc.cpp
+++ b/src/core/hle/svc.cpp
@@ -3,16 +3,14 @@
 // Refer to the license.txt file included.
 
 #include <map>
-
 #include "common/logging/log.h"
 #include "common/microprofile.h"
 #include "common/scope_exit.h"
 #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/function_wrappers.h"
 #include "core/hle/kernel/address_arbiter.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/event.h"
@@ -26,8 +24,6 @@
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/timer.h"
 #include "core/hle/kernel/vm_manager.h"
-
-#include "core/hle/function_wrappers.h"
 #include "core/hle/result.h"
 #include "core/hle/service/service.h"
 
@@ -40,43 +36,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
-
-const ResultCode ERR_MISALIGNED_ADDRESS{ // 0xE0E01BF1
-        ErrorDescription::MisalignedAddress, ErrorModule::OS,
-        ErrorSummary::InvalidArgument, ErrorLevel::Usage};
-const ResultCode ERR_MISALIGNED_SIZE{ // 0xE0E01BF2
-        ErrorDescription::MisalignedSize, ErrorModule::OS,
-        ErrorSummary::InvalidArgument, ErrorLevel::Usage};
-const ResultCode ERR_INVALID_COMBINATION{ // 0xE0E01BEE
-        ErrorDescription::InvalidCombination, ErrorModule::OS,
-        ErrorSummary::InvalidArgument, ErrorLevel::Usage};
+                                        ErrorSummary::InvalidArgument,
+                                        ErrorLevel::Usage); // 0xE0E0181E
+
+const ResultCode ERR_MISALIGNED_ADDRESS{// 0xE0E01BF1
+                                        ErrorDescription::MisalignedAddress, ErrorModule::OS,
+                                        ErrorSummary::InvalidArgument, ErrorLevel::Usage};
+const ResultCode ERR_MISALIGNED_SIZE{// 0xE0E01BF2
+                                     ErrorDescription::MisalignedSize, ErrorModule::OS,
+                                     ErrorSummary::InvalidArgument, ErrorLevel::Usage};
+const ResultCode ERR_INVALID_COMBINATION{// 0xE0E01BEE
+                                         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_MAP     = 4,
-    MEMOP_UNMAP   = 5,
+    MEMOP_COMMIT = 3,
+    MEMOP_MAP = 4,
+    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_MASK   = 0xF00,
+    MEMOP_REGION_BASE = 0x300,
+    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",
-        operation, addr0, addr1, size, permissions);
+    LOG_DEBUG(Kernel_SVC,
+              "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 +88,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 +100,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:
-    {
-        // TODO(Subv): What happens if an application tries to FREE a block of memory that has a SharedMemory pointing to it?
+    case MEMOP_FREE: {
+        // TODO(Subv): What happens if an application tries to FREE a block of memory that has a
+        // 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 +118,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 +127,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
-    {
-        CASCADE_RESULT(*out_addr, process.HeapAllocate(addr0, size, vma_permissions));
-        break;
-    }
+    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;
+        }
 
-    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;
-        break;
-    }
+    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;
+            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 +165,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",
-        handle, addr, permissions, other_permissions);
+    LOG_TRACE(Kernel_SVC,
+              "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 +184,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 +255,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 +263,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 +278,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 +288,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 +297,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 +338,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 +397,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),
-                                         address, value, nanoseconds);
+    auto res = arbiter->ArbitrateAddress(static_cast<Kernel::ArbitrationType>(type), address, value,
+                                         nanoseconds);
 
     return res;
 }
@@ -406,10 +418,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 1: reason_str = "ASSERT"; break;
-    case 2: reason_str = "USER"; break;
-    default: reason_str = "UNKNOWN"; break;
+    case 0:
+        reason_str = "PANIC";
+        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 +443,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 +454,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,
-    u32 name_count) {
+static ResultCode GetResourceLimitCurrentValues(s64* values, Handle resource_limit_handle,
+                                                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 +472,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 +488,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 +523,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)) {
-        LOG_WARNING(Kernel_SVC, "Newly created thread is allowed to be run in the SysCore, unimplemented.");
+        (processor_id == THREADPROCESSORID_DEFAULT &&
+         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(
-            name, entry_point, priority, arg, processor_id, stack_top));
+    CASCADE_RESULT(SharedPtr<Thread> thread, Kernel::Thread::Create(name, entry_point, priority,
+                                                                    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,
-        name.c_str(), arg, stack_top, priority, processor_id, *out_handle);
+                          "threadpriority=0x%08X, processorid=0x%08X : created handle=0x%08X",
+              entry_point, name.c_str(), arg, stack_top, priority, processor_id, *out_handle);
 
     return RESULT_SUCCESS;
 }
@@ -552,7 +579,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 +603,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 +616,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 +649,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 +669,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 +679,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 +704,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",
-            reset_type, *out_handle);
+    LOG_TRACE(Kernel_SVC, "called reset_type=0x%08X : created handle=0x%08X", reset_type,
+              *out_handle);
     return RESULT_SUCCESS;
 }
 
@@ -719,8 +750,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",
-            reset_type, *out_handle);
+    LOG_TRACE(Kernel_SVC, "called reset_type=0x%08X : created handle=0x%08X", reset_type,
+              *out_handle);
     return RESULT_SUCCESS;
 }
 
@@ -783,17 +814,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 +851,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,
-                                static_cast<MemoryPermission>(my_permission), static_cast<MemoryPermission>(other_permission), addr, region);
+    shared_memory = SharedMemory::Create(
+        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 +882,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))));
-    // 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))));
+    CASCADE_RESULT(*client_port, Kernel::g_handle_table.Create(
+                                     std::move(std::get<SharedPtr<ClientPort>>(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 +902,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
-                 + Kernel::GetMemoryRegion(Kernel::MemoryRegion::SYSTEM)->used
-                 + Kernel::GetMemoryRegion(Kernel::MemoryRegion::BASE)->used;
+            *out = Kernel::GetMemoryRegion(Kernel::MemoryRegion::APPLICATION)->used +
+                   Kernel::GetMemoryRegion(Kernel::MemoryRegion::SYSTEM)->used +
+                   Kernel::GetMemoryRegion(Kernel::MemoryRegion::BASE)->used;
             break;
         case SystemInfoMemUsageRegion::APPLICATION:
             *out = Kernel::GetMemoryRegion(Kernel::MemoryRegion::APPLICATION)->used;
@@ -912,7 +952,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 +975,12 @@ static ResultCode GetProcessInfo(s64* out, Handle process_handle, u32 type) {
 
         if (type >= 21 && type <= 23) {
             return ResultCode( // 0xE0E01BF4
-                    ErrorDescription::NotImplemented, ErrorModule::OS,
-                    ErrorSummary::InvalidArgument, ErrorLevel::Usage);
+                ErrorDescription::NotImplemented, ErrorModule::OS, ErrorSummary::InvalidArgument,
+                ErrorLevel::Usage);
         } else {
             return ResultCode( // 0xD8E007ED
-                    ErrorDescription::InvalidEnumValue, ErrorModule::Kernel,
-                    ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
+                ErrorDescription::InvalidEnumValue, ErrorModule::Kernel,
+                ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
         }
         break;
     }
@@ -949,142 +989,142 @@ static ResultCode GetProcessInfo(s64* out, Handle process_handle, u32 type) {
 }
 
 namespace {
-    struct FunctionDef {
-        using Func = void();
+struct FunctionDef {
+    using Func = void();
 
-        u32         id;
-        Func*       func;
-        const char* name;
-    };
+    u32 id;
+    Func* func;
+    const char* name;
+};
 }
 
 static const FunctionDef SVC_Table[] = {
-    {0x00, nullptr,                         "Unknown"},
-    {0x01, HLE::Wrap<ControlMemory>,        "ControlMemory"},
-    {0x02, HLE::Wrap<QueryMemory>,          "QueryMemory"},
-    {0x03, nullptr,                         "ExitProcess"},
-    {0x04, nullptr,                         "GetProcessAffinityMask"},
-    {0x05, nullptr,                         "SetProcessAffinityMask"},
-    {0x06, nullptr,                         "GetProcessIdealProcessor"},
-    {0x07, nullptr,                         "SetProcessIdealProcessor"},
-    {0x08, HLE::Wrap<CreateThread>,         "CreateThread"},
-    {0x09, ExitThread,                      "ExitThread"},
-    {0x0A, HLE::Wrap<SleepThread>,          "SleepThread"},
-    {0x0B, HLE::Wrap<GetThreadPriority>,    "GetThreadPriority"},
-    {0x0C, HLE::Wrap<SetThreadPriority>,    "SetThreadPriority"},
-    {0x0D, nullptr,                         "GetThreadAffinityMask"},
-    {0x0E, nullptr,                         "SetThreadAffinityMask"},
-    {0x0F, nullptr,                         "GetThreadIdealProcessor"},
-    {0x10, nullptr,                         "SetThreadIdealProcessor"},
-    {0x11, nullptr,                         "GetCurrentProcessorNumber"},
-    {0x12, nullptr,                         "Run"},
-    {0x13, HLE::Wrap<CreateMutex>,          "CreateMutex"},
-    {0x14, HLE::Wrap<ReleaseMutex>,         "ReleaseMutex"},
-    {0x15, HLE::Wrap<CreateSemaphore>,      "CreateSemaphore"},
-    {0x16, HLE::Wrap<ReleaseSemaphore>,     "ReleaseSemaphore"},
-    {0x17, HLE::Wrap<CreateEvent>,          "CreateEvent"},
-    {0x18, HLE::Wrap<SignalEvent>,          "SignalEvent"},
-    {0x19, HLE::Wrap<ClearEvent>,           "ClearEvent"},
-    {0x1A, HLE::Wrap<CreateTimer>,          "CreateTimer"},
-    {0x1B, HLE::Wrap<SetTimer>,             "SetTimer"},
-    {0x1C, HLE::Wrap<CancelTimer>,          "CancelTimer"},
-    {0x1D, HLE::Wrap<ClearTimer>,           "ClearTimer"},
-    {0x1E, HLE::Wrap<CreateMemoryBlock>,    "CreateMemoryBlock"},
-    {0x1F, HLE::Wrap<MapMemoryBlock>,       "MapMemoryBlock"},
-    {0x20, HLE::Wrap<UnmapMemoryBlock>,     "UnmapMemoryBlock"},
+    {0x00, nullptr, "Unknown"},
+    {0x01, HLE::Wrap<ControlMemory>, "ControlMemory"},
+    {0x02, HLE::Wrap<QueryMemory>, "QueryMemory"},
+    {0x03, nullptr, "ExitProcess"},
+    {0x04, nullptr, "GetProcessAffinityMask"},
+    {0x05, nullptr, "SetProcessAffinityMask"},
+    {0x06, nullptr, "GetProcessIdealProcessor"},
+    {0x07, nullptr, "SetProcessIdealProcessor"},
+    {0x08, HLE::Wrap<CreateThread>, "CreateThread"},
+    {0x09, ExitThread, "ExitThread"},
+    {0x0A, HLE::Wrap<SleepThread>, "SleepThread"},
+    {0x0B, HLE::Wrap<GetThreadPriority>, "GetThreadPriority"},
+    {0x0C, HLE::Wrap<SetThreadPriority>, "SetThreadPriority"},
+    {0x0D, nullptr, "GetThreadAffinityMask"},
+    {0x0E, nullptr, "SetThreadAffinityMask"},
+    {0x0F, nullptr, "GetThreadIdealProcessor"},
+    {0x10, nullptr, "SetThreadIdealProcessor"},
+    {0x11, nullptr, "GetCurrentProcessorNumber"},
+    {0x12, nullptr, "Run"},
+    {0x13, HLE::Wrap<CreateMutex>, "CreateMutex"},
+    {0x14, HLE::Wrap<ReleaseMutex>, "ReleaseMutex"},
+    {0x15, HLE::Wrap<CreateSemaphore>, "CreateSemaphore"},
+    {0x16, HLE::Wrap<ReleaseSemaphore>, "ReleaseSemaphore"},
+    {0x17, HLE::Wrap<CreateEvent>, "CreateEvent"},
+    {0x18, HLE::Wrap<SignalEvent>, "SignalEvent"},
+    {0x19, HLE::Wrap<ClearEvent>, "ClearEvent"},
+    {0x1A, HLE::Wrap<CreateTimer>, "CreateTimer"},
+    {0x1B, HLE::Wrap<SetTimer>, "SetTimer"},
+    {0x1C, HLE::Wrap<CancelTimer>, "CancelTimer"},
+    {0x1D, HLE::Wrap<ClearTimer>, "ClearTimer"},
+    {0x1E, HLE::Wrap<CreateMemoryBlock>, "CreateMemoryBlock"},
+    {0x1F, HLE::Wrap<MapMemoryBlock>, "MapMemoryBlock"},
+    {0x20, HLE::Wrap<UnmapMemoryBlock>, "UnmapMemoryBlock"},
     {0x21, HLE::Wrap<CreateAddressArbiter>, "CreateAddressArbiter"},
-    {0x22, HLE::Wrap<ArbitrateAddress>,     "ArbitrateAddress"},
-    {0x23, HLE::Wrap<CloseHandle>,          "CloseHandle"},
+    {0x22, HLE::Wrap<ArbitrateAddress>, "ArbitrateAddress"},
+    {0x23, HLE::Wrap<CloseHandle>, "CloseHandle"},
     {0x24, HLE::Wrap<WaitSynchronization1>, "WaitSynchronization1"},
     {0x25, HLE::Wrap<WaitSynchronizationN>, "WaitSynchronizationN"},
-    {0x26, nullptr,                         "SignalAndWait"},
-    {0x27, HLE::Wrap<DuplicateHandle>,      "DuplicateHandle"},
-    {0x28, HLE::Wrap<GetSystemTick>,        "GetSystemTick"},
-    {0x29, nullptr,                         "GetHandleInfo"},
-    {0x2A, HLE::Wrap<GetSystemInfo>,        "GetSystemInfo"},
-    {0x2B, HLE::Wrap<GetProcessInfo>,       "GetProcessInfo"},
-    {0x2C, nullptr,                         "GetThreadInfo"},
-    {0x2D, HLE::Wrap<ConnectToPort>,        "ConnectToPort"},
-    {0x2E, nullptr,                         "SendSyncRequest1"},
-    {0x2F, nullptr,                         "SendSyncRequest2"},
-    {0x30, nullptr,                         "SendSyncRequest3"},
-    {0x31, nullptr,                         "SendSyncRequest4"},
-    {0x32, HLE::Wrap<SendSyncRequest>,      "SendSyncRequest"},
-    {0x33, nullptr,                         "OpenProcess"},
-    {0x34, nullptr,                         "OpenThread"},
-    {0x35, HLE::Wrap<GetProcessId>,         "GetProcessId"},
+    {0x26, nullptr, "SignalAndWait"},
+    {0x27, HLE::Wrap<DuplicateHandle>, "DuplicateHandle"},
+    {0x28, HLE::Wrap<GetSystemTick>, "GetSystemTick"},
+    {0x29, nullptr, "GetHandleInfo"},
+    {0x2A, HLE::Wrap<GetSystemInfo>, "GetSystemInfo"},
+    {0x2B, HLE::Wrap<GetProcessInfo>, "GetProcessInfo"},
+    {0x2C, nullptr, "GetThreadInfo"},
+    {0x2D, HLE::Wrap<ConnectToPort>, "ConnectToPort"},
+    {0x2E, nullptr, "SendSyncRequest1"},
+    {0x2F, nullptr, "SendSyncRequest2"},
+    {0x30, nullptr, "SendSyncRequest3"},
+    {0x31, nullptr, "SendSyncRequest4"},
+    {0x32, HLE::Wrap<SendSyncRequest>, "SendSyncRequest"},
+    {0x33, nullptr, "OpenProcess"},
+    {0x34, nullptr, "OpenThread"},
+    {0x35, HLE::Wrap<GetProcessId>, "GetProcessId"},
     {0x36, HLE::Wrap<GetProcessIdOfThread>, "GetProcessIdOfThread"},
-    {0x37, HLE::Wrap<GetThreadId>,          "GetThreadId"},
-    {0x38, HLE::Wrap<GetResourceLimit>,     "GetResourceLimit"},
+    {0x37, HLE::Wrap<GetThreadId>, "GetThreadId"},
+    {0x38, HLE::Wrap<GetResourceLimit>, "GetResourceLimit"},
     {0x39, HLE::Wrap<GetResourceLimitLimitValues>, "GetResourceLimitLimitValues"},
     {0x3A, HLE::Wrap<GetResourceLimitCurrentValues>, "GetResourceLimitCurrentValues"},
-    {0x3B, nullptr,                         "GetThreadContext"},
-    {0x3C, HLE::Wrap<Break>,                "Break"},
-    {0x3D, HLE::Wrap<OutputDebugString>,    "OutputDebugString"},
-    {0x3E, nullptr,                         "ControlPerformanceCounter"},
-    {0x3F, nullptr,                         "Unknown"},
-    {0x40, nullptr,                         "Unknown"},
-    {0x41, nullptr,                         "Unknown"},
-    {0x42, nullptr,                         "Unknown"},
-    {0x43, nullptr,                         "Unknown"},
-    {0x44, nullptr,                         "Unknown"},
-    {0x45, nullptr,                         "Unknown"},
-    {0x46, nullptr,                         "Unknown"},
-    {0x47, HLE::Wrap<CreatePort>,           "CreatePort"},
-    {0x48, nullptr,                         "CreateSessionToPort"},
-    {0x49, nullptr,                         "CreateSession"},
-    {0x4A, nullptr,                         "AcceptSession"},
-    {0x4B, nullptr,                         "ReplyAndReceive1"},
-    {0x4C, nullptr,                         "ReplyAndReceive2"},
-    {0x4D, nullptr,                         "ReplyAndReceive3"},
-    {0x4E, nullptr,                         "ReplyAndReceive4"},
-    {0x4F, nullptr,                         "ReplyAndReceive"},
-    {0x50, nullptr,                         "BindInterrupt"},
-    {0x51, nullptr,                         "UnbindInterrupt"},
-    {0x52, nullptr,                         "InvalidateProcessDataCache"},
-    {0x53, nullptr,                         "StoreProcessDataCache"},
-    {0x54, nullptr,                         "FlushProcessDataCache"},
-    {0x55, nullptr,                         "StartInterProcessDma"},
-    {0x56, nullptr,                         "StopDma"},
-    {0x57, nullptr,                         "GetDmaState"},
-    {0x58, nullptr,                         "RestartDma"},
-    {0x59, nullptr,                         "Unknown"},
-    {0x5A, nullptr,                         "Unknown"},
-    {0x5B, nullptr,                         "Unknown"},
-    {0x5C, nullptr,                         "Unknown"},
-    {0x5D, nullptr,                         "Unknown"},
-    {0x5E, nullptr,                         "Unknown"},
-    {0x5F, nullptr,                         "Unknown"},
-    {0x60, nullptr,                         "DebugActiveProcess"},
-    {0x61, nullptr,                         "BreakDebugProcess"},
-    {0x62, nullptr,                         "TerminateDebugProcess"},
-    {0x63, nullptr,                         "GetProcessDebugEvent"},
-    {0x64, nullptr,                         "ContinueDebugEvent"},
-    {0x65, nullptr,                         "GetProcessList"},
-    {0x66, nullptr,                         "GetThreadList"},
-    {0x67, nullptr,                         "GetDebugThreadContext"},
-    {0x68, nullptr,                         "SetDebugThreadContext"},
-    {0x69, nullptr,                         "QueryDebugProcessMemory"},
-    {0x6A, nullptr,                         "ReadProcessMemory"},
-    {0x6B, nullptr,                         "WriteProcessMemory"},
-    {0x6C, nullptr,                         "SetHardwareBreakPoint"},
-    {0x6D, nullptr,                         "GetDebugThreadParam"},
-    {0x6E, nullptr,                         "Unknown"},
-    {0x6F, nullptr,                         "Unknown"},
-    {0x70, nullptr,                         "ControlProcessMemory"},
-    {0x71, nullptr,                         "MapProcessMemory"},
-    {0x72, nullptr,                         "UnmapProcessMemory"},
-    {0x73, nullptr,                         "CreateCodeSet"},
-    {0x74, nullptr,                         "RandomStub"},
-    {0x75, nullptr,                         "CreateProcess"},
-    {0x76, nullptr,                         "TerminateProcess"},
-    {0x77, nullptr,                         "SetProcessResourceLimits"},
-    {0x78, nullptr,                         "CreateResourceLimit"},
-    {0x79, nullptr,                         "SetResourceLimitValues"},
-    {0x7A, nullptr,                         "AddCodeSegment"},
-    {0x7B, nullptr,                         "Backdoor"},
-    {0x7C, nullptr,                         "KernelSetState"},
-    {0x7D, HLE::Wrap<QueryProcessMemory>,   "QueryProcessMemory"},
+    {0x3B, nullptr, "GetThreadContext"},
+    {0x3C, HLE::Wrap<Break>, "Break"},
+    {0x3D, HLE::Wrap<OutputDebugString>, "OutputDebugString"},
+    {0x3E, nullptr, "ControlPerformanceCounter"},
+    {0x3F, nullptr, "Unknown"},
+    {0x40, nullptr, "Unknown"},
+    {0x41, nullptr, "Unknown"},
+    {0x42, nullptr, "Unknown"},
+    {0x43, nullptr, "Unknown"},
+    {0x44, nullptr, "Unknown"},
+    {0x45, nullptr, "Unknown"},
+    {0x46, nullptr, "Unknown"},
+    {0x47, HLE::Wrap<CreatePort>, "CreatePort"},
+    {0x48, nullptr, "CreateSessionToPort"},
+    {0x49, nullptr, "CreateSession"},
+    {0x4A, nullptr, "AcceptSession"},
+    {0x4B, nullptr, "ReplyAndReceive1"},
+    {0x4C, nullptr, "ReplyAndReceive2"},
+    {0x4D, nullptr, "ReplyAndReceive3"},
+    {0x4E, nullptr, "ReplyAndReceive4"},
+    {0x4F, nullptr, "ReplyAndReceive"},
+    {0x50, nullptr, "BindInterrupt"},
+    {0x51, nullptr, "UnbindInterrupt"},
+    {0x52, nullptr, "InvalidateProcessDataCache"},
+    {0x53, nullptr, "StoreProcessDataCache"},
+    {0x54, nullptr, "FlushProcessDataCache"},
+    {0x55, nullptr, "StartInterProcessDma"},
+    {0x56, nullptr, "StopDma"},
+    {0x57, nullptr, "GetDmaState"},
+    {0x58, nullptr, "RestartDma"},
+    {0x59, nullptr, "Unknown"},
+    {0x5A, nullptr, "Unknown"},
+    {0x5B, nullptr, "Unknown"},
+    {0x5C, nullptr, "Unknown"},
+    {0x5D, nullptr, "Unknown"},
+    {0x5E, nullptr, "Unknown"},
+    {0x5F, nullptr, "Unknown"},
+    {0x60, nullptr, "DebugActiveProcess"},
+    {0x61, nullptr, "BreakDebugProcess"},
+    {0x62, nullptr, "TerminateDebugProcess"},
+    {0x63, nullptr, "GetProcessDebugEvent"},
+    {0x64, nullptr, "ContinueDebugEvent"},
+    {0x65, nullptr, "GetProcessList"},
+    {0x66, nullptr, "GetThreadList"},
+    {0x67, nullptr, "GetDebugThreadContext"},
+    {0x68, nullptr, "SetDebugThreadContext"},
+    {0x69, nullptr, "QueryDebugProcessMemory"},
+    {0x6A, nullptr, "ReadProcessMemory"},
+    {0x6B, nullptr, "WriteProcessMemory"},
+    {0x6C, nullptr, "SetHardwareBreakPoint"},
+    {0x6D, nullptr, "GetDebugThreadParam"},
+    {0x6E, nullptr, "Unknown"},
+    {0x6F, nullptr, "Unknown"},
+    {0x70, nullptr, "ControlProcessMemory"},
+    {0x71, nullptr, "MapProcessMemory"},
+    {0x72, nullptr, "UnmapProcessMemory"},
+    {0x73, nullptr, "CreateCodeSet"},
+    {0x74, nullptr, "RandomStub"},
+    {0x75, nullptr, "CreateProcess"},
+    {0x76, nullptr, "TerminateProcess"},
+    {0x77, nullptr, "SetProcessResourceLimits"},
+    {0x78, nullptr, "CreateResourceLimit"},
+    {0x79, nullptr, "SetResourceLimitValues"},
+    {0x7A, nullptr, "AddCodeSegment"},
+    {0x7B, nullptr, "Backdoor"},
+    {0x7C, nullptr, "KernelSetState"},
+    {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..0e6b91e3a 100644
--- a/src/core/hw/gpu.cpp
+++ b/src/core/hw/gpu.cpp
@@ -5,34 +5,26 @@
 #include <cstring>
 #include <numeric>
 #include <type_traits>
-
 #include "common/color.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "common/microprofile.h"
 #include "common/vector_math.h"
-
-#include "core/settings.h"
-#include "core/memory.h"
 #include "core/core_timing.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/memory.h"
+#include "core/settings.h"
 #include "core/tracer/recorder.h"
-
 #include "video_core/command_processor.h"
+#include "video_core/debug_utils/debug_utils.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_base.h"
 #include "video_core/utils.h"
 #include "video_core/video_core.h"
 
-#include "video_core/debug_utils/debug_utils.h"
-
-
 namespace GPU {
 
 Regs g_regs;
@@ -49,7 +41,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 +97,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 +116,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 +143,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 +161,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 +181,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);
-                    Memory::RasterizerFlushRegion(config.GetPhysicalInputAddress(), static_cast<u32>(contiguous_input_size));
+                    size_t 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);
-                    Memory::RasterizerFlushAndInvalidateRegion(config.GetPhysicalOutputAddress(), static_cast<u32>(contiguous_output_size));
+                    size_t 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 +217,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",
-                        config.texture_copy.size,
-                        config.GetPhysicalInputAddress(), input_width, input_gap,
-                        config.GetPhysicalOutputAddress(), output_width, output_gap,
+                    LOG_TRACE(
+                        HW_GPU,
+                        "TextureCopy: 0x%X bytes from 0x%08X(%u+%u)-> 0x%08X(%u+%u), flags 0x%08X",
+                        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 +229,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 +247,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 output_size = output_width * output_height * GPU::Regs::BytesPerPixel(config.output_format);
+                u32 input_size = config.input_width * config.input_height *
+                                 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 +283,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;
-                                dst_offset = VideoCore::GetMortonOffset(x, y, dst_bytes_per_pixel) + coarse_y * stride;
+                                src_offset =
+                                    (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 +299,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 +311,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;
-                                dst_offset = VideoCore::GetMortonOffset(x, y, dst_bytes_per_pixel) + out_coarse_y * out_stride;
+                                src_offset = VideoCore::GetMortonOffset(input_x, input_y,
+                                                                        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> 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);
+                            Math::Vec4<u8> pixel1 = DecodePixel(
+                                config.input_format, src_pixel + 1 * 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 +358,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",
-                      config.output_height * output_width * GPU::Regs::BytesPerPixel(config.output_format),
-                      config.GetPhysicalInputAddress(), config.input_width.Value(), config.input_height.Value(),
-                      config.GetPhysicalOutputAddress(), output_width, output_height,
-                      config.output_format.Value(), config.flags);
+                LOG_TRACE(HW_GPU, "DisplayTriggerTransfer: 0x%08x bytes from 0x%08x(%ux%u)-> "
+                                  "0x%08x(%ux%u), dst format %x, flags 0x%08X",
+                          config.output_height * output_width *
+                              GPU::Regs::BytesPerPixel(config.output_format),
+                          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 +381,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 +408,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<u32>(u32 &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<u64>(u64& 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<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 +437,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) ||
-            Settings::values.frame_skip == 0) {
+    if ((((Settings::values.frame_skip != 1) ^ last_skip_frame) &&
+         last_skip_frame != g_skip_frame) ||
+        Settings::values.frame_skip == 0) {
         VideoCore::g_renderer->SwapBuffers();
     }
 
@@ -448,12 +469,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_left2  = 0x1822C800;
+    framebuffer_top.address_left1 = 0x181E6000;
+    framebuffer_top.address_left2 = 0x1822C800;
     framebuffer_top.address_right1 = 0x18273000;
     framebuffer_top.address_right2 = 0x182B9800;
-    framebuffer_sub.address_left1  = 0x1848F000;
-    framebuffer_sub.address_left2  = 0x184C7800;
+    framebuffer_sub.address_left1 = 0x1848F000;
+    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..32ddc5697 100644
--- a/src/core/hw/gpu.h
+++ b/src/core/hw/gpu.h
@@ -6,7 +6,6 @@
 
 #include <cstddef>
 #include <type_traits>
-
 #include "common/assert.h"
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
@@ -17,7 +16,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 +30,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) \
-    ((typename std::enable_if<backup_workaround_index == GPU_REG_INDEX(field_name), size_t>::type)GPU_REG_INDEX(field_name))
+#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))
 #endif
 
 // MMIO region 0x1EFxxxxx
@@ -44,18 +45,18 @@ struct Regs {
 //       support for that.
 #define ASSERT_MEMBER_SIZE(name, size_in_bytes)
 #else
-#define ASSERT_MEMBER_SIZE(name, size_in_bytes)  \
-    static_assert(sizeof(name) == size_in_bytes, \
+#define ASSERT_MEMBER_SIZE(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,
-        RGB8   = 1,
+        RGBA8 = 0,
+        RGB8 = 1,
         RGB565 = 2,
         RGB5A1 = 3,
-        RGBA4  = 4,
+        RGBA4 = 4,
     };
 
     /**
@@ -88,8 +89,8 @@ struct Regs {
             BitField<0, 16, u32> value_16bit;
 
             // TODO: Verify component order
-            BitField< 0, 8, u32> value_24bit_r;
-            BitField< 8, 8, u32> value_24bit_g;
+            BitField<0, 8, u32> value_24bit_r;
+            BitField<8, 8, u32> value_24bit_g;
             BitField<16, 8, u32> value_24bit_b;
         };
 
@@ -126,7 +127,7 @@ struct Regs {
         union {
             u32 size;
 
-            BitField< 0, 16, u32> width;
+            BitField<0, 16, u32> width;
             BitField<16, 16, u32> height;
         };
 
@@ -138,7 +139,7 @@ struct Regs {
         union {
             u32 format;
 
-            BitField< 0, 3, PixelFormat> color_format;
+            BitField<0, 3, PixelFormat> color_format;
         };
 
         INSERT_PADDING_WORDS(0x1);
@@ -180,35 +181,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
-            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
+            NoScale = 0, // Doesn't scale the image
+            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
         };
 
         union {
             u32 flags;
 
-            BitField< 0, 1, u32> flip_vertically;  // flips input data vertically
-            BitField< 1, 1, u32> input_linear;     // Converts from linear to tiled format
-            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< 5, 1, u32> dont_swizzle;
-            BitField< 8, 3, PixelFormat> input_format;
+            BitField<0, 1, u32> flip_vertically; // flips input data vertically
+            BitField<1, 1, u32> input_linear;    // Converts from linear to tiled format
+            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<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 +228,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 +270,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 +297,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)             \
-    static_assert(offsetof(Regs, field_name) == position * 4, \
-                  "Field "#field_name" has invalid position")
-
-ASSERT_REG_POSITION(memory_fill_config[0],    0x00004);
-ASSERT_REG_POSITION(memory_fill_config[1],    0x00008);
-ASSERT_REG_POSITION(framebuffer_config[0],    0x00117);
-ASSERT_REG_POSITION(framebuffer_config[1],    0x00157);
-ASSERT_REG_POSITION(display_transfer_config,  0x00300);
+#define ASSERT_REG_POSITION(field_name, position)                                                  \
+    static_assert(offsetof(Regs, field_name) == position * 4,                                      \
+                  "Field " #field_name " has invalid position")
+
+ASSERT_REG_POSITION(memory_fill_config[0], 0x00004);
+ASSERT_REG_POSITION(memory_fill_config[1], 0x00008);
+ASSERT_REG_POSITION(framebuffer_config[0], 0x00117);
+ASSERT_REG_POSITION(framebuffer_config[1], 0x00157);
+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 +330,4 @@ void Init();
 /// Shutdown hardware
 void Shutdown();
 
-
 } // namespace
diff --git a/src/core/hw/hw.cpp b/src/core/hw/hw.cpp
index b5fdbf9c1..9ff8825b2 100644
--- a/src/core/hw/hw.cpp
+++ b/src/core/hw/hw.cpp
@@ -4,15 +4,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 +70,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<u32>(u32 &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<u64>(u64& 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<u8>(u8& var, const u32 addr);
 
 template void Write<u64>(u32 addr, const u64 data);
 template void Write<u32>(u32 addr, const u32 data);
@@ -82,8 +81,7 @@ template void Write<u16>(u32 addr, const u16 data);
 template void Write<u8>(u32 addr, const u8 data);
 
 /// Update hardware
-void Update() {
-}
+void Update() {}
 
 /// Initialize hardware
 void Init() {
@@ -98,5 +96,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_CSND      = 0x1EC03000,
-    VADDR_DSP       = 0x1EC40000,
-    VADDR_PDN       = 0x1EC41000,
-    VADDR_CODEC     = 0x1EC41000,
-    VADDR_SPI       = 0x1EC42000,
-    VADDR_SPI_2     = 0x1EC43000,   // Only used under TWL_FIRM?
-    VADDR_I2C       = 0x1EC44000,
-    VADDR_CODEC_2   = 0x1EC45000,
-    VADDR_HID       = 0x1EC46000,
-    VADDR_GPIO      = 0x1EC47000,
-    VADDR_I2C_2     = 0x1EC48000,
-    VADDR_SPI_3     = 0x1EC60000,
-    VADDR_I2C_3     = 0x1EC61000,
-    VADDR_MIC       = 0x1EC62000,
-    VADDR_PXI       = 0x1EC63000,
-    VADDR_LCD       = 0x1ED02000,
-    VADDR_DSP_2     = 0x1ED03000,
-    VADDR_HASH_2    = 0x1EE01000,
-    VADDR_GPU       = 0x1EF00000,
+    VADDR_HASH = 0x1EC01000,
+    VADDR_CSND = 0x1EC03000,
+    VADDR_DSP = 0x1EC40000,
+    VADDR_PDN = 0x1EC41000,
+    VADDR_CODEC = 0x1EC41000,
+    VADDR_SPI = 0x1EC42000,
+    VADDR_SPI_2 = 0x1EC43000, // Only used under TWL_FIRM?
+    VADDR_I2C = 0x1EC44000,
+    VADDR_CODEC_2 = 0x1EC45000,
+    VADDR_HID = 0x1EC46000,
+    VADDR_GPIO = 0x1EC47000,
+    VADDR_I2C_2 = 0x1EC48000,
+    VADDR_SPI_3 = 0x1EC60000,
+    VADDR_I2C_3 = 0x1EC61000,
+    VADDR_MIC = 0x1EC62000,
+    VADDR_PXI = 0x1EC63000,
+    VADDR_LCD = 0x1ED02000,
+    VADDR_DSP_2 = 0x1ED03000,
+    VADDR_HASH_2 = 0x1EE01000,
+    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..2aa89de18 100644
--- a/src/core/hw/lcd.cpp
+++ b/src/core/hw/lcd.cpp
@@ -3,13 +3,10 @@
 // Refer to the license.txt file included.
 
 #include <cstring>
-
 #include "common/common_types.h"
 #include "common/logging/log.h"
-
 #include "core/hw/hw.h"
 #include "core/hw/lcd.h"
-
 #include "core/tracer/recorder.h"
 #include "video_core/debug_utils/debug_utils.h"
 
@@ -18,7 +15,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 +45,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<u32>(u32 &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<u64>(u64& 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<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..191fd44af 100644
--- a/src/core/hw/lcd.h
+++ b/src/core/hw/lcd.h
@@ -6,7 +6,6 @@
 
 #include <cstddef>
 #include <type_traits>
-
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -42,16 +41,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 +57,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) \
-    static_assert(offsetof(Regs, field_name) == position * 4, \
-              "Field "#field_name" has invalid position")
+#define ASSERT_REG_POSITION(field_name, position)                                                  \
+    static_assert(offsetof(Regs, field_name) == position * 4,                                      \
+                  "Field " #field_name " has invalid position")
 
-ASSERT_REG_POSITION(color_fill_top,    0x81);
-ASSERT_REG_POSITION(backlight_top,     0x90);
+ASSERT_REG_POSITION(color_fill_top, 0x81);
+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 +72,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..6a6c707a2 100644
--- a/src/core/hw/y2r.cpp
+++ b/src/core/hw/y2r.cpp
@@ -6,13 +6,11 @@
 #include <array>
 #include <cstddef>
 #include <memory>
-
 #include "common/assert.h"
 #include "common/color.h"
 #include "common/common_types.h"
 #include "common/math_util.h"
 #include "common/vector_math.h"
-
 #include "core/hle/service/y2r_u.h"
 #include "core/hw/y2r.h"
 #include "core/memory.h"
@@ -27,9 +25,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,
-        const u8* input_Y, const u8* input_U, const u8* input_V, ImageTile output[],
-        unsigned int width, unsigned int height, const CoefficientSet& coefficients) {
+static void ConvertYUVToRGB(InputFormat input_format, const u8* input_Y, const u8* input_U,
+                            const u8* input_V, ImageTile output[], unsigned int width,
+                            unsigned int height, const CoefficientSet& coefficients) {
 
     for (unsigned int y = 0; y < height; ++y) {
         for (unsigned int x = 0; x < width; ++x) {
@@ -58,11 +56,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 g = cY - c[3]*U - c[2]*V;
-            s32 b = cY + c[4]*U;
+            s32 r = cY + c[1] * V;
+            s32 g = cY - c[2] * V - c[3] * U;
+            s32 b = cY + c[4] * U;
 
             const s32 rounding_offset = 0x18;
             r = (r >> 3) + c[5] + rounding_offset;
@@ -74,14 +72,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) |
-                   ((u32)Clamp(g >> 5, 0, 0xFF) << 16) |
+            *out = ((u32)Clamp(r >> 5, 0, 0xFF) << 24) | ((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 +101,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 +112,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{
-                (u8)(color >> 24), (u8)(color >> 16), (u8)(color >> 8), alpha
-            };
+            Math::Vec4<u8> col_vec{(u8)(color >> 24), (u8)(color >> 16), (u8)(color >> 8), alpha};
 
             switch (output_format) {
             case OutputFormat::RGBA8:
@@ -145,7 +142,8 @@ static void SendData(const u32* input, ConversionBuffer& buf, int amount_of_data
     }
 }
 
-static const u8 linear_lut[64] = {
+static const u8 linear_lut[TILE_SIZE] = {
+    // clang-format off
      0,  1,  2,  3,  4,  5,  6,  7,
      8,  9, 10, 11, 12, 13, 14, 15,
     16, 17, 18, 19, 20, 21, 22, 23,
@@ -154,9 +152,11 @@ static const u8 linear_lut[64] = {
     40, 41, 42, 43, 44, 45, 46, 47,
     48, 49, 50, 51, 52, 53, 54, 55,
     56, 57, 58, 59, 60, 61, 62, 63,
+    // clang-format on
 };
 
-static const u8 morton_lut[64] = {
+static const u8 morton_lut[TILE_SIZE] = {
+    // clang-format off
      0,  1,  4,  5, 16, 17, 20, 21,
      2,  3,  6,  7, 18, 19, 22, 23,
      8,  9, 12, 13, 24, 25, 28, 29,
@@ -165,15 +165,18 @@ static const u8 morton_lut[64] = {
     34, 35, 38, 39, 50, 51, 54, 55,
     40, 41, 44, 45, 56, 57, 60, 61,
     42, 43, 46, 47, 58, 59, 62, 63,
+    // clang-format on
 };
 
-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 +185,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 +279,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 +327,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 +374,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..1c10740a0 100644
--- a/src/core/loader/3dsx.cpp
+++ b/src/core/loader/3dsx.cpp
@@ -4,9 +4,7 @@
 
 #include <algorithm>
 #include <vector>
-
 #include "common/logging/log.h"
-
 #include "core/file_sys/archive_romfs.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
@@ -37,20 +35,14 @@ namespace Loader {
  * The BSS section must be cleared manually by the application.
  */
 
-enum THREEDSX_Error {
-    ERROR_NONE = 0,
-    ERROR_READ = 1,
-    ERROR_FILE = 2,
-    ERROR_ALLOC = 3
-};
+enum THREEDSX_Error { 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 +58,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 +72,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 +94,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 +107,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.seg_sizes[0] = (hdr.code_seg_size + 0xFFF) &~0xFFF;
-    loadinfo.seg_sizes[1] = (hdr.rodata_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] };
+    // loadinfo segments must be a multiple of 0x1000
+    loadinfo.seg_sizes[0] = (hdr.code_seg_size + 0xFFF) & ~0xFFF;
+    loadinfo.seg_sizes[1] = (hdr.rodata_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 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 +139,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 +148,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 +165,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 +190,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 +204,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.size   = loadinfo.seg_sizes[0];
+    code_set->code.addr = loadinfo.seg_addrs[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.size   = loadinfo.seg_sizes[1];
+    code_set->rodata.addr = loadinfo.seg_addrs[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.size   = loadinfo.seg_sizes[2];
+    code_set->data.addr = loadinfo.seg_addrs[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 +256,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..cfcc21cc4 100644
--- a/src/core/loader/3dsx.h
+++ b/src/core/loader/3dsx.h
@@ -5,7 +5,6 @@
 #pragma once
 
 #include <string>
-
 #include "common/common_types.h"
 #include "core/loader/loader.h"
 
@@ -17,7 +16,8 @@ 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,
+                       const std::string& filepath)
         : AppLoader(std::move(file)), filename(std::move(filename)), filepath(filepath) {}
 
     /**
@@ -55,7 +55,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..8eb5200ab 100644
--- a/src/core/loader/elf.cpp
+++ b/src/core/loader/elf.cpp
@@ -3,14 +3,12 @@
 // 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"
 #include "common/logging/log.h"
 #include "common/symbols.h"
-
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/loader/elf.h"
@@ -24,112 +22,111 @@ using Kernel::CodeSet;
 
 // File type
 enum ElfType {
-    ET_NONE   = 0,
-    ET_REL    = 1,
-    ET_EXEC   = 2,
-    ET_DYN    = 3,
-    ET_CORE   = 4,
+    ET_NONE = 0,
+    ET_REL = 1,
+    ET_EXEC = 2,
+    ET_DYN = 3,
+    ET_CORE = 4,
     ET_LOPROC = 0xFF00,
     ET_HIPROC = 0xFFFF,
 };
 
 // Machine/Architecture
 enum ElfMachine {
-    EM_NONE  = 0,
-    EM_M32   = 1,
+    EM_NONE = 0,
+    EM_M32 = 1,
     EM_SPARC = 2,
-    EM_386   = 3,
-    EM_68K   = 4,
-    EM_88K   = 5,
-    EM_860   = 7,
-    EM_MIPS  = 8
+    EM_386 = 3,
+    EM_68K = 4,
+    EM_88K = 5,
+    EM_860 = 7,
+    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_MAG1    1
-#define EI_MAG2    2
-#define EI_MAG3    3
-#define EI_CLASS   4
-#define EI_DATA    5
+#define EI_MAG0 0
+#define EI_MAG1 1
+#define EI_MAG2 2
+#define EI_MAG3 3
+#define EI_CLASS 4
+#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_PROGBITS        1
-#define SHT_SYMTAB          2
-#define SHT_STRTAB          3
-#define SHT_RELA            4
-#define SHT_HASH            5
-#define SHT_DYNAMIC         6
-#define SHT_NOTE            7
-#define SHT_NOBITS          8
-#define SHT_REL             9
-#define SHT_SHLIB          10
-#define SHT_DYNSYM         11
+#define SHT_NULL 0
+#define SHT_PROGBITS 1
+#define SHT_SYMTAB 2
+#define SHT_STRTAB 3
+#define SHT_RELA 4
+#define SHT_HASH 5
+#define SHT_DYNAMIC 6
+#define SHT_NOTE 7
+#define SHT_NOBITS 8
+#define SHT_REL 9
+#define SHT_SHLIB 10
+#define SHT_DYNSYM 11
 #define SHT_LOPROC 0x70000000
 #define SHT_HIPROC 0x7FFFFFFF
 #define SHT_LOUSER 0x80000000
 #define SHT_HIUSER 0xFFFFFFFF
 
 // Section flags
-enum ElfSectionFlags
-{
-    SHF_WRITE     = 0x1,
-    SHF_ALLOC     = 0x2,
+enum ElfSectionFlags {
+    SHF_WRITE = 0x1,
+    SHF_ALLOC = 0x2,
     SHF_EXECINSTR = 0x4,
-    SHF_MASKPROC  = 0xF0000000,
+    SHF_MASKPROC = 0xF0000000,
 };
 
 // Segment types
-#define PT_NULL             0
-#define PT_LOAD             1
-#define PT_DYNAMIC          2
-#define PT_INTERP           3
-#define PT_NOTE             4
-#define PT_SHLIB            5
-#define PT_PHDR             6
-#define PT_LOPROC  0x70000000
-#define PT_HIPROC  0x7FFFFFFF
+#define PT_NULL 0
+#define PT_LOAD 1
+#define PT_DYNAMIC 2
+#define PT_INTERP 3
+#define PT_NOTE 4
+#define PT_SHLIB 5
+#define PT_PHDR 6
+#define PT_LOPROC 0x70000000
+#define PT_HIPROC 0x7FFFFFFF
 
 // Segment flags
-#define PF_X               0x1
-#define PF_W               0x2
-#define PF_R               0x4
+#define PF_X 0x1
+#define PF_W 0x2
+#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 signed   int   Elf32_Sword;
-typedef unsigned int   Elf32_Word;
+typedef unsigned int Elf32_Off;
+typedef signed int Elf32_Sword;
+typedef unsigned int Elf32_Word;
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // ELF file header
 
 struct Elf32_Ehdr {
     unsigned char e_ident[EI_NIDENT];
-    Elf32_Half    e_type;
-    Elf32_Half    e_machine;
-    Elf32_Word    e_version;
-    Elf32_Addr    e_entry;
-    Elf32_Off     e_phoff;
-    Elf32_Off     e_shoff;
-    Elf32_Word    e_flags;
-    Elf32_Half    e_ehsize;
-    Elf32_Half    e_phentsize;
-    Elf32_Half    e_phnum;
-    Elf32_Half    e_shentsize;
-    Elf32_Half    e_shnum;
-    Elf32_Half    e_shstrndx;
+    Elf32_Half e_type;
+    Elf32_Half e_machine;
+    Elf32_Word e_version;
+    Elf32_Addr e_entry;
+    Elf32_Off e_phoff;
+    Elf32_Off e_shoff;
+    Elf32_Word e_flags;
+    Elf32_Half e_ehsize;
+    Elf32_Half e_phentsize;
+    Elf32_Half e_phnum;
+    Elf32_Half e_shentsize;
+    Elf32_Half e_shnum;
+    Elf32_Half e_shstrndx;
 };
 
 // Section header
@@ -138,7 +135,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 +146,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 +157,12 @@ struct Elf32_Phdr {
 
 // Symbol table entry
 struct Elf32_Sym {
-    Elf32_Word    st_name;
-    Elf32_Addr    st_value;
-    Elf32_Word    st_size;
+    Elf32_Word st_name;
+    Elf32_Addr st_value;
+    Elf32_Word st_size;
     unsigned char st_info;
     unsigned char st_other;
-    Elf32_Half    st_shndx;
+    Elf32_Half st_shndx;
 };
 
 // Relocation entries
@@ -181,35 +178,51 @@ typedef int SectionID;
 
 class ElfReader {
 private:
-    char *base;
-    u32 *base32;
+    char* base;
+    u32* base32;
 
-    Elf32_Ehdr *header;
-    Elf32_Phdr *segments;
-    Elf32_Shdr *sections;
+    Elf32_Ehdr* header;
+    Elf32_Phdr* segments;
+    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); }
-    ElfMachine GetMachine() const { return (ElfMachine)(header->e_machine); }
-    u32 GetEntryPoint() const { return entryPoint; }
-    u32 GetFlags() const { return (u32)(header->e_flags); }
+    ElfType GetType() const {
+        return (ElfType)(header->e_type);
+    }
+    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 GetNumSections() 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 {
+    int GetNumSegments() const {
+        return (int)(header->e_phnum);
+    }
+    int GetNumSections() 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 +233,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]; }
-    unsigned int GetSectionSize(SectionID section) const { return sections[section].sh_size; }
-    SectionID GetSectionByName(const char *name, int firstSection = 0) const; //-1 for not found
+    u32 GetSectionAddr(SectionID section) const {
+        return sectionAddrs[section];
+    }
+    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 +262,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 +320,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 +352,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 +367,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 +379,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 +431,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..584bf6e27 100644
--- a/src/core/loader/elf.h
+++ b/src/core/loader/elf.h
@@ -5,7 +5,6 @@
 #pragma once
 
 #include <string>
-
 #include "common/common_types.h"
 #include "core/loader/loader.h"
 
@@ -18,7 +17,7 @@ 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..147bf8591 100644
--- a/src/core/loader/loader.cpp
+++ b/src/core/loader/loader.cpp
@@ -4,10 +4,8 @@
 
 #include <memory>
 #include <string>
-
 #include "common/logging/log.h"
 #include "common/string_util.h"
-
 #include "core/hle/kernel/process.h"
 #include "core/loader/3dsx.h"
 #include "core/loader/elf.h"
@@ -18,17 +16,17 @@
 namespace Loader {
 
 const std::initializer_list<Kernel::AddressMapping> default_address_mappings = {
-    { 0x1FF50000,   0x8000, true  }, // part of DSP RAM
-    { 0x1FF70000,   0x8000, true  }, // part of DSP RAM
-    { 0x1F000000, 0x600000, false }, // entire VRAM
+    {0x1FF50000, 0x8000, true},    // part of DSP RAM
+    {0x1FF70000, 0x8000, true},    // part of DSP RAM
+    {0x1F000000, 0x600000, false}, // entire VRAM
 };
 
 FileType IdentifyFile(FileUtil::IOFile& file) {
     FileType type;
 
-#define CHECK_TYPE(loader) \
-    type = AppLoader_##loader::IdentifyType(file); \
-    if (FileType::Error != type) \
+#define CHECK_TYPE(loader)                                                                         \
+    type = AppLoader_##loader::IdentifyType(file);                                                 \
+    if (FileType::Error != type)                                                                   \
         return type;
 
     CHECK_TYPE(THREEDSX)
@@ -100,7 +98,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..9652d7ac5 100644
--- a/src/core/loader/loader.h
+++ b/src/core/loader/loader.h
@@ -9,7 +9,6 @@
 #include <memory>
 #include <string>
 #include <vector>
-
 #include "common/common_types.h"
 #include "common/file_util.h"
 
@@ -30,7 +29,7 @@ enum class FileType {
     CXI,
     CIA,
     ELF,
-    THREEDSX, //3DSX
+    THREEDSX, // 3DSX
 };
 
 /**
@@ -81,8 +80,8 @@ 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)) { }
-    virtual ~AppLoader() { }
+    AppLoader(FileUtil::IOFile&& file) : file(std::move(file)) {}
+    virtual ~AppLoader() {}
 
     /**
      * Returns the type of this file
@@ -140,7 +139,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..2e4510857 100644
--- a/src/core/loader/ncch.cpp
+++ b/src/core/loader/ncch.cpp
@@ -5,11 +5,9 @@
 #include <algorithm>
 #include <cstring>
 #include <memory>
-
 #include "common/logging/log.h"
 #include "common/string_util.h"
 #include "common/swap.h"
-
 #include "core/file_sys/archive_romfs.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
@@ -22,8 +20,8 @@
 
 namespace Loader {
 
-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 kMaxSections = 8;   ///< Maximum number of sections (files) in an ExeFs
+static const int kBlockSize = 0x200; ///< Size of ExeFS blocks (in bytes)
 
 /**
  * Get the decompressed size of an LZSS compressed ExeFS file
@@ -44,7 +42,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 +54,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 +127,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 +146,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 +155,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(
-            static_cast<Kernel::ResourceLimitCategory>(exheader_header.arm11_system_local_caps.resource_limit_category));
+        Kernel::g_current_process->resource_limit =
+            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 +195,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 +258,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;
-    entry_point             = exheader_header.codeset_info.text.address;
-    code_size               = exheader_header.codeset_info.text.code_size;
-    stack_size              = exheader_header.codeset_info.stack_size;
-    bss_size                = exheader_header.codeset_info.bss_size;
-    core_version            = exheader_header.arm11_system_local_caps.core_version;
-    priority                = exheader_header.arm11_system_local_caps.priority;
+    is_compressed = (exheader_header.codeset_info.flags.flag & 1) == 1;
+    entry_point = exheader_header.codeset_info.text.address;
+    code_size = exheader_header.codeset_info.text.code_size;
+    stack_size = exheader_header.codeset_info.stack_size;
+    bss_size = exheader_header.codeset_info.bss_size;
+    core_version = exheader_header.arm11_system_local_caps.core_version;
+    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,  "Program ID:                  %016llX" , ncch_header.program_id);
-    LOG_DEBUG(Loader, "Code compressed:             %s"    , is_compressed ? "yes" : "no");
+    LOG_INFO(Loader, "Name:                        %s", exheader_header.codeset_info.name);
+    LOG_INFO(Loader, "Program ID:                  %016llX", ncch_header.program_id);
+    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, "Thread priority:             0x%X"  , priority);
-    LOG_DEBUG(Loader, "Resource limit category:     %d"    , resource_limit_category);
+    LOG_DEBUG(Loader, "Core version:                %d", core_version);
+    LOG_DEBUG(Loader, "Thread priority:             0x%X", priority);
+    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 +313,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 +334,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 +347,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..04350d006 100644
--- a/src/core/loader/ncch.h
+++ b/src/core/loader/ncch.h
@@ -5,11 +5,9 @@
 #pragma once
 
 #include <memory>
-
 #include "common/bit_field.h"
 #include "common/common_types.h"
 #include "common/swap.h"
-
 #include "core/loader/loader.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -164,7 +162,7 @@ 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 +220,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 +244,24 @@ private:
      */
     ResultStatus LoadExeFS();
 
-    bool            is_exefs_loaded = false;
-    bool            is_compressed = false;
-
-    u32             entry_point = 0;
-    u32             code_size = 0;
-    u32             stack_size = 0;
-    u32             bss_size = 0;
-    u32             core_version = 0;
-    u8              priority = 0;
-    u8              resource_limit_category = 0;
-    u32             ncch_offset = 0; // Offset to NCCH header, can be 0 or after NCSD header
-    u32             exefs_offset = 0;
-
-    NCCH_Header     ncch_header;
-    ExeFs_Header    exefs_header;
+    bool is_exefs_loaded = false;
+    bool is_compressed = false;
+
+    u32 entry_point = 0;
+    u32 code_size = 0;
+    u32 stack_size = 0;
+    u32 bss_size = 0;
+    u32 core_version = 0;
+    u8 priority = 0;
+    u8 resource_limit_category = 0;
+    u32 ncch_offset = 0; // Offset to NCCH header, can be 0 or after NCSD header
+    u32 exefs_offset = 0;
+
+    NCCH_Header ncch_header;
+    ExeFs_Header exefs_header;
     ExHeader_Header exheader_header;
 
-    std::string     filepath;
+    std::string filepath;
 };
 
 } // namespace Loader
diff --git a/src/core/loader/smdh.cpp b/src/core/loader/smdh.cpp
index 2d014054a..ccbeb7961 100644
--- a/src/core/loader/smdh.cpp
+++ b/src/core/loader/smdh.cpp
@@ -4,12 +4,9 @@
 
 #include <cstring>
 #include <vector>
-
 #include "common/common_types.h"
-
 #include "core/loader/loader.h"
 #include "core/loader/smdh.h"
-
 #include "video_core/utils.h"
 
 namespace Loader {
diff --git a/src/core/loader/smdh.h b/src/core/loader/smdh.h
index 2011abda2..ac7726c8f 100644
--- a/src/core/loader/smdh.h
+++ b/src/core/loader/smdh.h
@@ -6,7 +6,6 @@
 
 #include <array>
 #include <vector>
-
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
@@ -56,7 +55,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..df029d655 100644
--- a/src/core/memory.cpp
+++ b/src/core/memory.cpp
@@ -4,17 +4,14 @@
 
 #include <array>
 #include <cstring>
-
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "common/swap.h"
-
 #include "core/hle/kernel/process.h"
 #include "core/memory.h"
 #include "core/memory_setup.h"
 #include "core/mmio.h"
-
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"
 
@@ -25,11 +22,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 +54,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 +78,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 +165,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 +186,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 +195,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 +205,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 +220,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 +235,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 +310,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 +338,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 +391,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 +461,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 +480,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 +489,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 +519,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 +537,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 +546,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 +573,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 +620,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..8fd3080ff 100644
--- a/src/core/memory.h
+++ b/src/core/memory.h
@@ -6,7 +6,6 @@
 
 #include <cstddef>
 #include <string>
-
 #include "common/common_types.h"
 
 namespace Memory {
@@ -22,92 +21,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_SIZE      = 0x01000000, ///< IO area size (16MB)
+    IO_AREA_PADDR = 0x10100000,
+    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_SIZE      = 0x00002000, ///< MPCore internal memory size (8KB)
+    MPCORE_RAM_PADDR = 0x17E00000,
+    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_SIZE      = 0x00600000, ///< VRAM size (6MB)
+    VRAM_PADDR = 0x18000000,
+    VRAM_SIZE = 0x00600000, ///< VRAM size (6MB)
     VRAM_PADDR_END = VRAM_PADDR + VRAM_SIZE,
 
     /// DSP memory
-    DSP_RAM_PADDR     = 0x1FF00000,
-    DSP_RAM_SIZE      = 0x00080000, ///< DSP memory size (512KB)
+    DSP_RAM_PADDR = 0x1FF00000,
+    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_SIZE      = 0x00080000, ///< AXI WRAM size (512KB)
+    AXI_WRAM_PADDR = 0x1FF80000,
+    AXI_WRAM_SIZE = 0x00080000, ///< AXI WRAM size (512KB)
     AXI_WRAM_PADDR_END = AXI_WRAM_PADDR + AXI_WRAM_SIZE,
 
     /// Main FCRAM
-    FCRAM_PADDR     = 0x20000000,
-    FCRAM_SIZE      = 0x08000000, ///< FCRAM size (128MB)
+    FCRAM_PADDR = 0x20000000,
+    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_MAX_SIZE  = 0x03F00000,
+    PROCESS_IMAGE_VADDR = 0x00100000,
+    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_SIZE      = 0x04000000,
+    IPC_MAPPING_VADDR = 0x04000000,
+    IPC_MAPPING_SIZE = 0x04000000,
     IPC_MAPPING_VADDR_END = IPC_MAPPING_VADDR + IPC_MAPPING_SIZE,
 
     /// Application heap (includes stack).
-    HEAP_VADDR     = 0x08000000,
-    HEAP_SIZE      = 0x08000000,
+    HEAP_VADDR = 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_SIZE      = 0x04000000,
+    SHARED_MEMORY_VADDR = 0x10000000,
+    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.
-    LINEAR_HEAP_VADDR     = 0x14000000,
-    LINEAR_HEAP_SIZE      = 0x08000000,
+    /// Maps 1:1 to an offset in FCRAM. Used for HW allocations that need to be linear in physical
+    /// memory.
+    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_SIZE      = 0x00001000,
+    CONFIG_MEMORY_VADDR = 0x1FF80000,
+    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_SIZE      = 0x00001000,
+    SHARED_PAGE_VADDR = 0x1FF81000,
+    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_ENTRY_SIZE     = 0x200,
+    TLS_AREA_VADDR = 0x1FF82000,
+    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_SIZE      = 0x10000000,
+    NEW_LINEAR_HEAP_VADDR = 0x30000000,
+    NEW_LINEAR_HEAP_SIZE = 0x10000000,
     NEW_LINEAR_HEAP_VADDR_END = NEW_LINEAR_HEAP_VADDR + NEW_LINEAR_HEAP_SIZE,
 };
 
@@ -166,5 +166,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..3fdf3a87d 100644
--- a/src/core/memory_setup.h
+++ b/src/core/memory_setup.h
@@ -5,7 +5,6 @@
 #pragma once
 
 #include "common/common_types.h"
-
 #include "core/mmio.h"
 
 namespace Memory {
@@ -30,5 +29,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..f45126da8 100644
--- a/src/core/mmio.h
+++ b/src/core/mmio.h
@@ -5,7 +5,6 @@
 #pragma once
 
 #include <memory>
-
 #include "common/common_types.h"
 
 namespace Memory {
@@ -36,5 +35,4 @@ public:
 };
 
 using MMIORegionPointer = std::shared_ptr<MMIORegion>;
-
 };
diff --git a/src/core/settings.cpp b/src/core/settings.cpp
index 1b6733a79..4a0969b00 100644
--- a/src/core/settings.cpp
+++ b/src/core/settings.cpp
@@ -2,12 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "settings.h"
-
 #include "audio_core/audio_core.h"
-
 #include "core/gdbstub/gdbstub.h"
-
+#include "settings.h"
 #include "video_core/video_core.h"
 
 namespace Settings {
@@ -25,7 +22,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..5a64f8018 100644
--- a/src/core/settings.h
+++ b/src/core/settings.h
@@ -4,9 +4,8 @@
 
 #pragma once
 
-#include <string>
 #include <array>
-
+#include <string>
 #include "common/common_types.h"
 
 namespace Settings {
@@ -14,14 +13,31 @@ namespace Settings {
 namespace NativeInput {
 enum Values {
     // directly mapped keys
-    A, B, X, Y,
-    L, R, ZL, ZR,
-    START, SELECT, HOME,
-    DUP, DDOWN, DLEFT, DRIGHT,
-    CUP, CDOWN, CLEFT, CRIGHT,
+    A,
+    B,
+    X,
+    Y,
+    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 +45,21 @@ enum Values {
 
 static const std::array<const char*, NUM_INPUTS> Mapping = {{
     // directly mapped keys
-    "pad_a", "pad_b", "pad_x", "pad_y",
-    "pad_l", "pad_r", "pad_zl", "pad_zr",
-    "pad_start", "pad_select", "pad_home",
-    "pad_dup", "pad_ddown", "pad_dleft", "pad_dright",
-    "pad_cup", "pad_cdown", "pad_cleft", "pad_cright",
+    "pad_a", "pad_b", "pad_x", "pad_y", "pad_l", "pad_r", "pad_zl", "pad_zr", "pad_start",
+    "pad_select", "pad_home", "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,
-    L, R, ZL, ZR,
-    START, SELECT, HOME,
-    DUP, DDOWN, DLEFT, DRIGHT,
-    CUP, CDOWN, CLEFT, CRIGHT,
-    CIRCLE_UP, CIRCLE_DOWN, CIRCLE_LEFT, CIRCLE_RIGHT,
-    CIRCLE_MODIFIER,
+    A,     B,      X,      Y,         L,           R,           ZL,           ZR,
+    START, SELECT, HOME,   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 +100,4 @@ struct Values {
 } extern values;
 
 void Apply();
-
 }
diff --git a/src/core/system.cpp b/src/core/system.cpp
index 4fc266cb0..7d54811a0 100644
--- a/src/core/system.cpp
+++ b/src/core/system.cpp
@@ -3,21 +3,19 @@
 // Refer to the license.txt file included.
 
 #include "audio_core/audio_core.h"
-
 #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
-    Error,                  ///< Something went wrong (no module specified)
-    ErrorInitCore,          ///< Something went wrong during core init
-    ErrorInitVideoCore,     ///< Something went wrong during video core init
+    Success,            ///< Everything is fine
+    Error,              ///< Something went wrong (no module specified)
+    ErrorInitCore,      ///< Something went wrong during 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..215f86359 100644
--- a/src/core/tracer/citrace.h
+++ b/src/core/tracer/citrace.h
@@ -61,8 +61,8 @@ struct CTHeader {
 };
 
 enum CTStreamElementType : u32 {
-    FrameMarker   = 0xE1,
-    MemoryLoad    = 0xE2,
+    FrameMarker = 0xE1,
+    MemoryLoad = 0xE2,
     RegisterWrite = 0xE3,
 };
 
@@ -77,10 +77,10 @@ struct CTRegisterWrite {
     u32 physical_address;
 
     enum : u32 {
-        SIZE_8  = 0xD1,
+        SIZE_8 = 0xD1,
         SIZE_16 = 0xD2,
         SIZE_32 = 0xD3,
-        SIZE_64 = 0xD4
+        SIZE_64 = 0xD4,
     } size;
 
     // TODO: Make it clearer which bits of this member are used for sizes other than 32 bits
@@ -97,5 +97,4 @@ struct CTStreamElement {
 };
 
 #pragma pack()
-
 }
diff --git a/src/core/tracer/recorder.cpp b/src/core/tracer/recorder.cpp
index 7abaacf70..276a5b288 100644
--- a/src/core/tracer/recorder.cpp
+++ b/src/core/tracer/recorder.cpp
@@ -3,18 +3,14 @@
 // Refer to the license.txt file included.
 
 #include <cstring>
-
 #include "common/assert.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
-
 #include "recorder.h"
 
 namespace CiTrace {
 
-Recorder::Recorder(const InitialState& initial_state) : initial_state(initial_state) {
-
-}
+Recorder::Recorder(const InitialState& initial_state) : initial_state(initial_state) {}
 
 void Recorder::Finish(const std::string& filename) {
     // Setup CiTrace header
@@ -26,35 +22,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.lcd_registers_size      = static_cast<u32>(initial_state.lcd_registers.size());
-    initial.pica_registers_size     = static_cast<u32>(initial_state.pica_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.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_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.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_float_uniforms_size  = static_cast<u32>(initial_state.gs_float_uniforms.size());
-    header.stream_size              = static_cast<u32>(stream.size());
-
-    initial.gpu_registers      = sizeof(header);
-    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.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.vs_swizzle_data    = initial.vs_program_binary  + initial.vs_program_binary_size * sizeof(u32);
-    initial.vs_float_uniforms  = 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);
+    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_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_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());
+    header.stream_size = static_cast<u32>(stream.size());
+
+    initial.gpu_registers = sizeof(header);
+    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.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.vs_swizzle_data =
+        initial.vs_program_binary + initial.vs_program_binary_size * sizeof(u32);
+    initial.vs_float_uniforms =
+        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 +81,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());
-        if (written != initial_state.pica_registers.size() || file.Tell() != initial.default_attributes)
+        written = file.WriteArray(initial_state.pica_registers.data(),
+                                  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());
-        if (written != initial_state.default_attributes.size() || file.Tell() != initial.vs_program_binary)
+        written = file.WriteArray(initial_state.default_attributes.data(),
+                                  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());
-        if (written != initial_state.vs_program_binary.size() || file.Tell() != initial.vs_swizzle_data)
+        written = file.WriteArray(initial_state.vs_program_binary.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());
-        if (written != initial_state.vs_swizzle_data.size() || file.Tell() != initial.vs_float_uniforms)
+        written = file.WriteArray(initial_state.vs_swizzle_data.data(),
+                                  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());
-        if (written != initial_state.vs_float_uniforms.size() || file.Tell() != initial.gs_program_binary)
+        written = file.WriteArray(initial_state.vs_float_uniforms.data(),
+                                  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());
-        if (written != initial_state.gs_program_binary.size() || file.Tell() != initial.gs_swizzle_data)
+        written = file.WriteArray(initial_state.gs_program_binary.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());
-        if (written != initial_state.gs_swizzle_data.size() || file.Tell() != initial.gs_float_uniforms)
+        written = file.WriteArray(initial_state.gs_swizzle_data.data(),
+                                  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());
-        if (written != initial_state.gs_float_uniforms.size() || file.Tell() != initial.gs_float_uniforms + sizeof(u32) * initial.gs_float_uniforms_size)
+        written = file.WriteArray(initial_state.gs_float_uniforms.data(),
+                                  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 +144,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 +158,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 +187,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 } };
-    element.data.register_write.size = (sizeof(T) == 1) ? CTRegisterWrite::SIZE_8
-                                     : (sizeof(T) == 2) ? CTRegisterWrite::SIZE_16
-                                     : (sizeof(T) == 4) ? CTRegisterWrite::SIZE_32
-                                     :                    CTRegisterWrite::SIZE_64;
+    StreamElement element = {{RegisterWrite}};
+    element.data.register_write.size =
+        (sizeof(T) == 1) ? CTRegisterWrite::SIZE_8
+                         : (sizeof(T) == 2) ? CTRegisterWrite::SIZE_16
+                                            : (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,u16);
-template void Recorder::RegisterWritten(u32,u32);
-template void Recorder::RegisterWritten(u32,u64);
-
+template void Recorder::RegisterWritten(u32, u8);
+template void Recorder::RegisterWritten(u32, u16);
+template void Recorder::RegisterWritten(u32, u32);
+template void Recorder::RegisterWritten(u32, u64);
 }
diff --git a/src/core/tracer/recorder.h b/src/core/tracer/recorder.h
index febf883c8..aea363b95 100644
--- a/src/core/tracer/recorder.h
+++ b/src/core/tracer/recorder.h
@@ -7,12 +7,9 @@
 #include <string>
 #include <unordered_map>
 #include <vector>
-
 #include <boost/crc.hpp>
-
-#include "common/common_types.h"
-
 #include "citrace.h"
+#include "common/common_types.h"
 
 namespace CiTrace {
 
@@ -54,7 +51,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: