18 files changed, 1890 insertions, 1784 deletions

diff --git a/src/core/hle/kernel/k_page_table_base.cpp b/src/core/hle/kernel/k_page_table_base.cpp
index 6691586ed..4c416d809 100644
--- a/src/core/hle/kernel/k_page_table_base.cpp
+++ b/src/core/hle/kernel/k_page_table_base.cpp
@@ -69,8 +69,16 @@ public:
 };
 
 template <typename AddressType>
-void InvalidateInstructionCache(Core::System& system, AddressType addr, u64 size) {
-    system.InvalidateCpuInstructionCacheRange(GetInteger(addr), size);
+void InvalidateInstructionCache(KernelCore& kernel, AddressType addr, u64 size) {
+    // TODO: lock the process list
+    for (auto& process : kernel.GetProcessList()) {
+        for (size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) {
+            auto* interface = process->GetArmInterface(i);
+            if (interface) {
+                interface->InvalidateCacheRange(GetInteger(addr), size);
+            }
+        }
+    }
 }
 
 template <typename AddressType>
@@ -1261,7 +1269,7 @@ Result KPageTableBase::UnmapCodeMemory(KProcessAddress dst_address, KProcessAddr
     bool reprotected_pages = false;
     SCOPE_EXIT({
         if (reprotected_pages && any_code_pages) {
-            InvalidateInstructionCache(m_system, dst_address, size);
+            InvalidateInstructionCache(m_kernel, dst_address, size);
         }
     });
 
@@ -1997,7 +2005,7 @@ Result KPageTableBase::SetProcessMemoryPermission(KProcessAddress addr, size_t s
         for (const auto& block : pg) {
             StoreDataCache(GetHeapVirtualPointer(m_kernel, block.GetAddress()), block.GetSize());
         }
-        InvalidateInstructionCache(m_system, addr, size);
+        InvalidateInstructionCache(m_kernel, addr, size);
     }
 
     R_SUCCEED();
@@ -3239,7 +3247,7 @@ Result KPageTableBase::WriteDebugMemory(KProcessAddress dst_address, KProcessAdd
     R_TRY(PerformCopy());
 
     // Invalidate the instruction cache, as this svc allows modifying executable pages.
-    InvalidateInstructionCache(m_system, dst_address, size);
+    InvalidateInstructionCache(m_kernel, dst_address, size);
 
     R_SUCCEED();
 }
diff --git a/src/core/hle/kernel/k_process.cpp b/src/core/hle/kernel/k_process.cpp
index 6c29eb72c..3a2635e1f 100644
--- a/src/core/hle/kernel/k_process.cpp
+++ b/src/core/hle/kernel/k_process.cpp
@@ -13,6 +13,12 @@
 #include "core/hle/kernel/k_thread_queue.h"
 #include "core/hle/kernel/k_worker_task_manager.h"
 
+#include "core/arm/dynarmic/arm_dynarmic_32.h"
+#include "core/arm/dynarmic/arm_dynarmic_64.h"
+#ifdef HAS_NCE
+#include "core/arm/nce/arm_nce.h"
+#endif
+
 namespace Kernel {
 
 namespace {
@@ -957,10 +963,8 @@ Result KProcess::Run(s32 priority, size_t stack_size) {
     R_TRY(m_handle_table.Add(std::addressof(thread_handle), main_thread));
 
     // Set the thread arguments.
-    main_thread->GetContext32().cpu_registers[0] = 0;
-    main_thread->GetContext64().cpu_registers[0] = 0;
-    main_thread->GetContext32().cpu_registers[1] = thread_handle;
-    main_thread->GetContext64().cpu_registers[1] = thread_handle;
+    main_thread->GetContext().r[0] = 0;
+    main_thread->GetContext().r[1] = thread_handle;
 
     // Update our state.
     this->ChangeState((state == State::Created) ? State::Running : State::RunningAttached);
@@ -1199,6 +1203,9 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std:
     m_is_hbl = is_hbl;
     m_ideal_core_id = metadata.GetMainThreadCore();
 
+    // Set up emulation context.
+    this->InitializeInterfaces();
+
     // We succeeded.
     R_SUCCEED();
 }
@@ -1227,6 +1234,31 @@ void KProcess::LoadModule(CodeSet code_set, KProcessAddress base_addr) {
 #endif
 }
 
+void KProcess::InitializeInterfaces() {
+    this->GetMemory().SetCurrentPageTable(*this);
+
+#ifdef HAS_NCE
+    if (this->Is64Bit() && Settings::IsNceEnabled()) {
+        for (size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) {
+            m_arm_interfaces[i] = std::make_unique<Core::ArmNce>(m_kernel.System(), true, i);
+        }
+    } else
+#endif
+        if (this->Is64Bit()) {
+        for (size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) {
+            m_arm_interfaces[i] = std::make_unique<Core::ArmDynarmic64>(
+                m_kernel.System(), m_kernel.IsMulticore(), this,
+                static_cast<Core::DynarmicExclusiveMonitor&>(m_kernel.GetExclusiveMonitor()), i);
+        }
+    } else {
+        for (size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) {
+            m_arm_interfaces[i] = std::make_unique<Core::ArmDynarmic32>(
+                m_kernel.System(), m_kernel.IsMulticore(), this,
+                static_cast<Core::DynarmicExclusiveMonitor&>(m_kernel.GetExclusiveMonitor()), i);
+        }
+    }
+}
+
 bool KProcess::InsertWatchpoint(KProcessAddress addr, u64 size, DebugWatchpointType type) {
     const auto watch{std::find_if(m_watchpoints.begin(), m_watchpoints.end(), [&](const auto& wp) {
         return wp.type == DebugWatchpointType::None;
diff --git a/src/core/hle/kernel/k_process.h b/src/core/hle/kernel/k_process.h
index d8cd0fdde..4b114e39b 100644
--- a/src/core/hle/kernel/k_process.h
+++ b/src/core/hle/kernel/k_process.h
@@ -5,6 +5,7 @@
 
 #include <map>
 
+#include "core/arm/arm_interface.h"
 #include "core/file_sys/program_metadata.h"
 #include "core/hle/kernel/code_set.h"
 #include "core/hle/kernel/k_address_arbiter.h"
@@ -106,6 +107,8 @@ private:
     bool m_is_suspended{};
     bool m_is_immortal{};
     bool m_is_handle_table_initialized{};
+    std::array<std::unique_ptr<Core::ArmInterface>, Core::Hardware::NUM_CPU_CORES>
+        m_arm_interfaces{};
     std::array<KThread*, Core::Hardware::NUM_CPU_CORES> m_running_threads{};
     std::array<u64, Core::Hardware::NUM_CPU_CORES> m_running_thread_idle_counts{};
     std::array<u64, Core::Hardware::NUM_CPU_CORES> m_running_thread_switch_counts{};
@@ -476,6 +479,10 @@ public:
     }
 #endif
 
+    Core::ArmInterface* GetArmInterface(size_t core_index) const {
+        return m_arm_interfaces[core_index].get();
+    }
+
 public:
     // Attempts to insert a watchpoint into a free slot. Returns false if none are available.
     bool InsertWatchpoint(KProcessAddress addr, u64 size, DebugWatchpointType type);
@@ -493,6 +500,8 @@ public:
 
     void LoadModule(CodeSet code_set, KProcessAddress base_addr);
 
+    void InitializeInterfaces();
+
     Core::Memory::Memory& GetMemory() const;
 
 public:
diff --git a/src/core/hle/kernel/k_process_page_table.h b/src/core/hle/kernel/k_process_page_table.h
index 9e40f68bc..346d7ca08 100644
--- a/src/core/hle/kernel/k_process_page_table.h
+++ b/src/core/hle/kernel/k_process_page_table.h
@@ -7,10 +7,6 @@
 #include "core/hle/kernel/k_scoped_lock.h"
 #include "core/hle/kernel/svc_types.h"
 
-namespace Core {
-class ARM_Interface;
-}
-
 namespace Kernel {
 
 class KProcessPageTable {
diff --git a/src/core/hle/kernel/k_scheduler.cpp b/src/core/hle/kernel/k_scheduler.cpp
index 1bce63a56..27d1c3846 100644
--- a/src/core/hle/kernel/k_scheduler.cpp
+++ b/src/core/hle/kernel/k_scheduler.cpp
@@ -494,12 +494,7 @@ void KScheduler::ScheduleImplFiber() {
 }
 
 void KScheduler::Unload(KThread* thread) {
-    auto& cpu_core = m_kernel.System().ArmInterface(m_core_id);
-    cpu_core.SaveContext(thread->GetContext32());
-    cpu_core.SaveContext(thread->GetContext64());
-    // Save the TPIDR_EL0 system register in case it was modified.
-    thread->SetTpidrEl0(cpu_core.GetTPIDR_EL0());
-    cpu_core.ClearExclusiveState();
+    m_kernel.PhysicalCore(m_core_id).SaveContext(thread);
 
     // Check if the thread is terminated by checking the DPC flags.
     if ((thread->GetStackParameters().dpc_flags & static_cast<u32>(DpcFlag::Terminated)) == 0) {
@@ -509,14 +504,7 @@ void KScheduler::Unload(KThread* thread) {
 }
 
 void KScheduler::Reload(KThread* thread) {
-    auto& cpu_core = m_kernel.System().ArmInterface(m_core_id);
-    auto* process = thread->GetOwnerProcess();
-    cpu_core.LoadContext(thread->GetContext32());
-    cpu_core.LoadContext(thread->GetContext64());
-    cpu_core.SetTlsAddress(GetInteger(thread->GetTlsAddress()));
-    cpu_core.SetTPIDR_EL0(thread->GetTpidrEl0());
-    cpu_core.LoadWatchpointArray(process ? &process->GetWatchpoints() : nullptr);
-    cpu_core.ClearExclusiveState();
+    m_kernel.PhysicalCore(m_core_id).LoadContext(thread);
 }
 
 void KScheduler::ClearPreviousThread(KernelCore& kernel, KThread* thread) {
diff --git a/src/core/hle/kernel/k_thread.cpp b/src/core/hle/kernel/k_thread.cpp
index a6deb50ec..7d9a6e9cf 100644
--- a/src/core/hle/kernel/k_thread.cpp
+++ b/src/core/hle/kernel/k_thread.cpp
@@ -41,24 +41,25 @@ namespace {
 
 constexpr inline s32 TerminatingThreadPriority = Kernel::Svc::SystemThreadPriorityHighest - 1;
 
-static void ResetThreadContext32(Kernel::KThread::ThreadContext32& context, u32 stack_top,
-                                 u32 entry_point, u32 arg) {
-    context = {};
-    context.cpu_registers[0] = arg;
-    context.cpu_registers[15] = entry_point;
-    context.cpu_registers[13] = stack_top;
-    context.fpscr = 0;
-}
-
-static void ResetThreadContext64(Kernel::KThread::ThreadContext64& context, u64 stack_top,
-                                 u64 entry_point, u64 arg) {
-    context = {};
-    context.cpu_registers[0] = arg;
-    context.cpu_registers[18] = Kernel::KSystemControl::GenerateRandomU64() | 1;
-    context.pc = entry_point;
-    context.sp = stack_top;
-    context.fpcr = 0;
-    context.fpsr = 0;
+static void ResetThreadContext32(Kernel::Svc::ThreadContext& ctx, u64 stack_top, u64 entry_point,
+                                 u64 arg) {
+    ctx = {};
+    ctx.r[0] = arg;
+    ctx.r[15] = entry_point;
+    ctx.r[13] = stack_top;
+    ctx.fpcr = 0;
+    ctx.fpsr = 0;
+}
+
+static void ResetThreadContext64(Kernel::Svc::ThreadContext& ctx, u64 stack_top, u64 entry_point,
+                                 u64 arg) {
+    ctx = {};
+    ctx.r[0] = arg;
+    ctx.r[18] = Kernel::KSystemControl::GenerateRandomU64() | 1;
+    ctx.pc = entry_point;
+    ctx.sp = stack_top;
+    ctx.fpcr = 0;
+    ctx.fpsr = 0;
 }
 } // namespace
 
@@ -223,9 +224,11 @@ Result KThread::Initialize(KThreadFunction func, uintptr_t arg, KProcessAddress
     }
 
     // Initialize thread context.
-    ResetThreadContext64(m_thread_context_64, GetInteger(user_stack_top), GetInteger(func), arg);
-    ResetThreadContext32(m_thread_context_32, static_cast<u32>(GetInteger(user_stack_top)),
-                         static_cast<u32>(GetInteger(func)), static_cast<u32>(arg));
+    if (m_parent != nullptr && !m_parent->Is64Bit()) {
+        ResetThreadContext32(m_thread_context, GetInteger(user_stack_top), GetInteger(func), arg);
+    } else {
+        ResetThreadContext64(m_thread_context, GetInteger(user_stack_top), GetInteger(func), arg);
+    }
 
     // Setup the stack parameters.
     StackParameters& sp = this->GetStackParameters();
@@ -823,20 +826,7 @@ void KThread::CloneFpuStatus() {
     ASSERT(this->GetOwnerProcess() != nullptr);
     ASSERT(this->GetOwnerProcess() == GetCurrentProcessPointer(m_kernel));
 
-    if (this->GetOwnerProcess()->Is64Bit()) {
-        // Clone FPSR and FPCR.
-        ThreadContext64 cur_ctx{};
-        m_kernel.System().CurrentArmInterface().SaveContext(cur_ctx);
-
-        this->GetContext64().fpcr = cur_ctx.fpcr;
-        this->GetContext64().fpsr = cur_ctx.fpsr;
-    } else {
-        // Clone FPSCR.
-        ThreadContext32 cur_ctx{};
-        m_kernel.System().CurrentArmInterface().SaveContext(cur_ctx);
-
-        this->GetContext32().fpscr = cur_ctx.fpscr;
-    }
+    m_kernel.CurrentPhysicalCore().CloneFpuStatus(this);
 }
 
 Result KThread::SetActivity(Svc::ThreadActivity activity) {
@@ -912,7 +902,7 @@ Result KThread::SetActivity(Svc::ThreadActivity activity) {
     R_SUCCEED();
 }
 
-Result KThread::GetThreadContext3(Common::ScratchBuffer<u8>& out) {
+Result KThread::GetThreadContext3(Svc::ThreadContext* out) {
     // Lock ourselves.
     KScopedLightLock lk{m_activity_pause_lock};
 
@@ -926,18 +916,16 @@ Result KThread::GetThreadContext3(Common::ScratchBuffer<u8>& out) {
 
         // If we're not terminating, get the thread's user context.
         if (!this->IsTerminationRequested()) {
+            *out = m_thread_context;
+
+            // Mask away mode bits, interrupt bits, IL bit, and other reserved bits.
+            constexpr u32 El0Aarch64PsrMask = 0xF0000000;
+            constexpr u32 El0Aarch32PsrMask = 0xFE0FFE20;
+
             if (m_parent->Is64Bit()) {
-                // Mask away mode bits, interrupt bits, IL bit, and other reserved bits.
-                auto context = GetContext64();
-                context.pstate &= 0xFF0FFE20;
-                out.resize_destructive(sizeof(context));
-                std::memcpy(out.data(), std::addressof(context), sizeof(context));
+                out->pstate &= El0Aarch64PsrMask;
             } else {
-                // Mask away mode bits, interrupt bits, IL bit, and other reserved bits.
-                auto context = GetContext32();
-                context.cpsr &= 0xFF0FFE20;
-                out.resize_destructive(sizeof(context));
-                std::memcpy(out.data(), std::addressof(context), sizeof(context));
+                out->pstate &= El0Aarch32PsrMask;
             }
         }
     }
diff --git a/src/core/hle/kernel/k_thread.h b/src/core/hle/kernel/k_thread.h
index e9ca5dfca..390db2409 100644
--- a/src/core/hle/kernel/k_thread.h
+++ b/src/core/hle/kernel/k_thread.h
@@ -38,7 +38,6 @@ namespace Core {
 namespace Memory {
 class Memory;
 }
-class ARM_Interface;
 class System;
 } // namespace Core
 
@@ -137,8 +136,6 @@ public:
     ~KThread() override;
 
 public:
-    using ThreadContext32 = Core::ARM_Interface::ThreadContext32;
-    using ThreadContext64 = Core::ARM_Interface::ThreadContext64;
     using WaiterList = Common::IntrusiveListBaseTraits<KThread>::ListType;
 
     /**
@@ -246,31 +243,22 @@ public:
      * @returns The value of the TPIDR_EL0 register.
      */
     u64 GetTpidrEl0() const {
-        return m_thread_context_64.tpidr;
+        return m_thread_context.tpidr;
     }
 
     /// Sets the value of the TPIDR_EL0 Read/Write system register for this thread.
     void SetTpidrEl0(u64 value) {
-        m_thread_context_64.tpidr = value;
-        m_thread_context_32.tpidr = static_cast<u32>(value);
+        m_thread_context.tpidr = value;
     }
 
     void CloneFpuStatus();
 
-    ThreadContext32& GetContext32() {
-        return m_thread_context_32;
+    Svc::ThreadContext& GetContext() {
+        return m_thread_context;
     }
 
-    const ThreadContext32& GetContext32() const {
-        return m_thread_context_32;
-    }
-
-    ThreadContext64& GetContext64() {
-        return m_thread_context_64;
-    }
-
-    const ThreadContext64& GetContext64() const {
-        return m_thread_context_64;
+    const Svc::ThreadContext& GetContext() const {
+        return m_thread_context;
     }
 
     std::shared_ptr<Common::Fiber>& GetHostContext();
@@ -577,7 +565,7 @@ public:
 
     void RemoveWaiter(KThread* thread);
 
-    Result GetThreadContext3(Common::ScratchBuffer<u8>& out);
+    Result GetThreadContext3(Svc::ThreadContext* out);
 
     KThread* RemoveUserWaiterByKey(bool* out_has_waiters, KProcessAddress key) {
         return this->RemoveWaiterByKey(out_has_waiters, key, false);
@@ -734,8 +722,7 @@ private:
                                    std::function<void()>&& init_func);
 
     // For core KThread implementation
-    ThreadContext32 m_thread_context_32{};
-    ThreadContext64 m_thread_context_64{};
+    Svc::ThreadContext m_thread_context{};
     Common::IntrusiveListNode m_process_list_node;
     Common::IntrusiveRedBlackTreeNode m_condvar_arbiter_tree_node{};
     s32 m_priority{};
diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index 4a1559291..032c4e093 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -99,13 +99,6 @@ struct KernelCore::Impl {
         RegisterHostThread(nullptr);
     }
 
-    void InitializeCores() {
-        for (u32 core_id = 0; core_id < Core::Hardware::NUM_CPU_CORES; core_id++) {
-            cores[core_id]->Initialize((*application_process).Is64Bit());
-            system.ApplicationMemory().SetCurrentPageTable(*application_process, core_id);
-        }
-    }
-
     void TerminateApplicationProcess() {
         application_process.load()->Terminate();
     }
@@ -205,7 +198,7 @@ struct KernelCore::Impl {
             const s32 core{static_cast<s32>(i)};
 
             schedulers[i] = std::make_unique<Kernel::KScheduler>(system.Kernel());
-            cores[i] = std::make_unique<Kernel::PhysicalCore>(i, system, *schedulers[i]);
+            cores[i] = std::make_unique<Kernel::PhysicalCore>(system.Kernel(), i);
 
             auto* main_thread{Kernel::KThread::Create(system.Kernel())};
             main_thread->SetCurrentCore(core);
@@ -880,10 +873,6 @@ void KernelCore::Initialize() {
     impl->Initialize(*this);
 }
 
-void KernelCore::InitializeCores() {
-    impl->InitializeCores();
-}
-
 void KernelCore::Shutdown() {
     impl->Shutdown();
 }
@@ -993,21 +982,6 @@ const KAutoObjectWithListContainer& KernelCore::ObjectListContainer() const {
     return *impl->global_object_list_container;
 }
 
-void KernelCore::InvalidateAllInstructionCaches() {
-    for (auto& physical_core : impl->cores) {
-        physical_core->ArmInterface().ClearInstructionCache();
-    }
-}
-
-void KernelCore::InvalidateCpuInstructionCacheRange(KProcessAddress addr, std::size_t size) {
-    for (auto& physical_core : impl->cores) {
-        if (!physical_core->IsInitialized()) {
-            continue;
-        }
-        physical_core->ArmInterface().InvalidateCacheRange(GetInteger(addr), size);
-    }
-}
-
 void KernelCore::PrepareReschedule(std::size_t id) {
     // TODO: Reimplement, this
 }
diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h
index d8086c0ea..69b5bbd6c 100644
--- a/src/core/hle/kernel/kernel.h
+++ b/src/core/hle/kernel/kernel.h
@@ -104,9 +104,6 @@ public:
     /// Resets the kernel to a clean slate for use.
     void Initialize();
 
-    /// Initializes the CPU cores.
-    void InitializeCores();
-
     /// Clears all resources in use by the kernel instance.
     void Shutdown();
 
@@ -181,10 +178,6 @@ public:
 
     const KAutoObjectWithListContainer& ObjectListContainer() const;
 
-    void InvalidateAllInstructionCaches();
-
-    void InvalidateCpuInstructionCacheRange(KProcessAddress addr, std::size_t size);
-
     /// Registers all kernel objects with the global emulation state, this is purely for tracking
     /// leaks after emulation has been shutdown.
     void RegisterKernelObject(KAutoObject* object);
diff --git a/src/core/hle/kernel/physical_core.cpp b/src/core/hle/kernel/physical_core.cpp
index 073039825..7fa8e2a85 100644
--- a/src/core/hle/kernel/physical_core.cpp
+++ b/src/core/hle/kernel/physical_core.cpp
@@ -1,62 +1,206 @@
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "common/scope_exit.h"
 #include "common/settings.h"
-#include "core/arm/dynarmic/arm_dynarmic_32.h"
-#include "core/arm/dynarmic/arm_dynarmic_64.h"
-#ifdef HAS_NCE
-#include "core/arm/nce/arm_nce.h"
-#endif
 #include "core/core.h"
-#include "core/hle/kernel/k_scheduler.h"
+#include "core/debugger/debugger.h"
+#include "core/hle/kernel/k_process.h"
+#include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/physical_core.h"
+#include "core/hle/kernel/svc.h"
 
 namespace Kernel {
 
-PhysicalCore::PhysicalCore(std::size_t core_index, Core::System& system, KScheduler& scheduler)
-    : m_core_index{core_index}, m_system{system}, m_scheduler{scheduler} {
-#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64)
-    // TODO(bunnei): Initialization relies on a core being available. We may later replace this with
-    // an NCE interface or a 32-bit instance of Dynarmic. This should be abstracted out to a CPU
-    // manager.
-    auto& kernel = system.Kernel();
-    m_arm_interface = std::make_unique<Core::ARM_Dynarmic_64>(
-        system, kernel.IsMulticore(),
-        reinterpret_cast<Core::DynarmicExclusiveMonitor&>(kernel.GetExclusiveMonitor()),
-        m_core_index);
-#else
-#error Platform not supported yet.
-#endif
+PhysicalCore::PhysicalCore(KernelCore& kernel, std::size_t core_index)
+    : m_kernel{kernel}, m_core_index{core_index} {
+    m_is_single_core = !kernel.IsMulticore();
 }
-
 PhysicalCore::~PhysicalCore() = default;
 
-void PhysicalCore::Initialize(bool is_64_bit) {
-#if defined(HAS_NCE)
-    if (Settings::IsNceEnabled()) {
-        m_arm_interface = std::make_unique<Core::ARM_NCE>(m_system, m_system.Kernel().IsMulticore(),
-                                                          m_core_index);
+void PhysicalCore::RunThread(Kernel::KThread* thread) {
+    auto* process = thread->GetOwnerProcess();
+    auto& system = m_kernel.System();
+    auto* interface = process->GetArmInterface(m_core_index);
+
+    interface->Initialize();
+
+    const auto EnterContext = [&]() {
+        system.EnterCPUProfile();
+
+        // Lock the core context.
+        std::scoped_lock lk{m_guard};
+
+        // Check if we are already interrupted. If we are, we can just stop immediately.
+        if (m_is_interrupted) {
+            return false;
+        }
+
+        // Mark that we are running.
+        m_arm_interface = interface;
+        m_current_thread = thread;
+
+        // Acquire the lock on the thread parameters.
+        // This allows us to force synchronization with Interrupt.
+        interface->LockThread(thread);
+
+        return true;
+    };
+
+    const auto ExitContext = [&]() {
+        // Unlock the thread.
+        interface->UnlockThread(thread);
+
+        // Lock the core context.
+        std::scoped_lock lk{m_guard};
+
+        // On exit, we no longer are running.
+        m_arm_interface = nullptr;
+        m_current_thread = nullptr;
+
+        system.ExitCPUProfile();
+    };
+
+    while (true) {
+        // If the thread is scheduled for termination, exit.
+        if (thread->HasDpc() && thread->IsTerminationRequested()) {
+            thread->Exit();
+        }
+
+        // Notify the debugger and go to sleep if a step was performed
+        // and this thread has been scheduled again.
+        if (thread->GetStepState() == StepState::StepPerformed) {
+            system.GetDebugger().NotifyThreadStopped(thread);
+            thread->RequestSuspend(SuspendType::Debug);
+            return;
+        }
+
+        // Otherwise, run the thread.
+        Core::HaltReason hr{};
+        {
+            // If we were interrupted, exit immediately.
+            if (!EnterContext()) {
+                return;
+            }
+
+            if (thread->GetStepState() == StepState::StepPending) {
+                hr = interface->StepThread(thread);
+
+                if (True(hr & Core::HaltReason::StepThread)) {
+                    thread->SetStepState(StepState::StepPerformed);
+                }
+            } else {
+                hr = interface->RunThread(thread);
+            }
+
+            ExitContext();
+        }
+
+        // Determine why we stopped.
+        const bool supervisor_call = True(hr & Core::HaltReason::SupervisorCall);
+        const bool prefetch_abort = True(hr & Core::HaltReason::PrefetchAbort);
+        const bool breakpoint = True(hr & Core::HaltReason::InstructionBreakpoint);
+        const bool data_abort = True(hr & Core::HaltReason::DataAbort);
+        const bool interrupt = True(hr & Core::HaltReason::BreakLoop);
+
+        // Since scheduling may occur here, we cannot use any cached
+        // state after returning from calls we make.
+
+        // Notify the debugger and go to sleep if a breakpoint was hit,
+        // or if the thread is unable to continue for any reason.
+        if (breakpoint || prefetch_abort) {
+            if (breakpoint) {
+                interface->RewindBreakpointInstruction();
+            }
+            if (system.DebuggerEnabled()) {
+                system.GetDebugger().NotifyThreadStopped(thread);
+            } else {
+                interface->LogBacktrace(process);
+            }
+            thread->RequestSuspend(SuspendType::Debug);
+            return;
+        }
+
+        // Notify the debugger and go to sleep on data abort.
+        if (data_abort) {
+            if (system.DebuggerEnabled()) {
+                system.GetDebugger().NotifyThreadWatchpoint(thread, *interface->HaltedWatchpoint());
+            }
+            thread->RequestSuspend(SuspendType::Debug);
+            return;
+        }
+
+        // Handle system calls.
+        if (supervisor_call) {
+            // Perform call.
+            Svc::Call(system, interface->GetSvcNumber());
+            return;
+        }
+
+        // Handle external interrupt sources.
+        if (interrupt || !m_is_single_core) {
+            return;
+        }
+    }
+}
+
+void PhysicalCore::LoadContext(const KThread* thread) {
+    auto* const process = thread->GetOwnerProcess();
+    if (!process) {
+        // Kernel threads do not run on emulated CPU cores.
         return;
     }
-#endif
-#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64)
-    auto& kernel = m_system.Kernel();
-    if (!is_64_bit) {
-        // We already initialized a 64-bit core, replace with a 32-bit one.
-        m_arm_interface = std::make_unique<Core::ARM_Dynarmic_32>(
-            m_system, kernel.IsMulticore(),
-            reinterpret_cast<Core::DynarmicExclusiveMonitor&>(kernel.GetExclusiveMonitor()),
-            m_core_index);
+
+    auto* interface = process->GetArmInterface(m_core_index);
+    if (interface) {
+        interface->SetContext(thread->GetContext());
+        interface->SetTpidrroEl0(GetInteger(thread->GetTlsAddress()));
+        interface->SetWatchpointArray(&process->GetWatchpoints());
     }
-#else
-#error Platform not supported yet.
-#endif
 }
 
-void PhysicalCore::Run() {
-    m_arm_interface->Run();
-    m_arm_interface->ClearExclusiveState();
+void PhysicalCore::LoadSvcArguments(const KProcess& process, std::span<const uint64_t, 8> args) {
+    process.GetArmInterface(m_core_index)->SetSvcArguments(args);
+}
+
+void PhysicalCore::SaveContext(KThread* thread) const {
+    auto* const process = thread->GetOwnerProcess();
+    if (!process) {
+        // Kernel threads do not run on emulated CPU cores.
+        return;
+    }
+
+    auto* interface = process->GetArmInterface(m_core_index);
+    if (interface) {
+        interface->GetContext(thread->GetContext());
+    }
+}
+
+void PhysicalCore::SaveSvcArguments(KProcess& process, std::span<uint64_t, 8> args) const {
+    process.GetArmInterface(m_core_index)->GetSvcArguments(args);
+}
+
+void PhysicalCore::CloneFpuStatus(KThread* dst) const {
+    auto* process = dst->GetOwnerProcess();
+
+    Svc::ThreadContext ctx{};
+    process->GetArmInterface(m_core_index)->GetContext(ctx);
+
+    dst->GetContext().fpcr = ctx.fpcr;
+    dst->GetContext().fpsr = ctx.fpsr;
+}
+
+void PhysicalCore::LogBacktrace() {
+    auto* process = GetCurrentProcessPointer(m_kernel);
+    if (!process) {
+        return;
+    }
+
+    auto* interface = process->GetArmInterface(m_core_index);
+    if (interface) {
+        interface->LogBacktrace(process);
+    }
 }
 
 void PhysicalCore::Idle() {
@@ -69,16 +213,31 @@ bool PhysicalCore::IsInterrupted() const {
 }
 
 void PhysicalCore::Interrupt() {
-    std::unique_lock lk{m_guard};
+    // Lock core context.
+    std::scoped_lock lk{m_guard};
+
+    // Load members.
+    auto* arm_interface = m_arm_interface;
+    auto* thread = m_current_thread;
+
+    // Add interrupt flag.
     m_is_interrupted = true;
-    m_arm_interface->SignalInterrupt();
-    m_on_interrupt.notify_all();
+
+    // Interrupt ourselves.
+    m_on_interrupt.notify_one();
+
+    // If there is no thread running, we are done.
+    if (arm_interface == nullptr) {
+        return;
+    }
+
+    // Interrupt the CPU.
+    arm_interface->SignalInterrupt(thread);
 }
 
 void PhysicalCore::ClearInterrupt() {
-    std::unique_lock lk{m_guard};
+    std::scoped_lock lk{m_guard};
     m_is_interrupted = false;
-    m_arm_interface->ClearInterrupt();
 }
 
 } // namespace Kernel
diff --git a/src/core/hle/kernel/physical_core.h b/src/core/hle/kernel/physical_core.h
index 5cb398fdc..bae4fe5b8 100644
--- a/src/core/hle/kernel/physical_core.h
+++ b/src/core/hle/kernel/physical_core.h
@@ -11,7 +11,7 @@
 #include "core/arm/arm_interface.h"
 
 namespace Kernel {
-class KScheduler;
+class KernelCore;
 } // namespace Kernel
 
 namespace Core {
@@ -23,62 +23,55 @@ namespace Kernel {
 
 class PhysicalCore {
 public:
-    PhysicalCore(std::size_t core_index_, Core::System& system_, KScheduler& scheduler_);
+    PhysicalCore(KernelCore& kernel, std::size_t core_index);
     ~PhysicalCore();
 
     YUZU_NON_COPYABLE(PhysicalCore);
     YUZU_NON_MOVEABLE(PhysicalCore);
 
-    /// Initialize the core for the specified parameters.
-    void Initialize(bool is_64_bit);
+    // Execute guest code running on the given thread.
+    void RunThread(KThread* thread);
 
-    /// Execute current jit state
-    void Run();
+    // Copy context from thread to current core.
+    void LoadContext(const KThread* thread);
+    void LoadSvcArguments(const KProcess& process, std::span<const uint64_t, 8> args);
 
+    // Copy context from current core to thread.
+    void SaveContext(KThread* thread) const;
+    void SaveSvcArguments(KProcess& process, std::span<uint64_t, 8> args) const;
+
+    // Copy floating point status registers to the target thread.
+    void CloneFpuStatus(KThread* dst) const;
+
+    // Log backtrace of current processor state.
+    void LogBacktrace();
+
+    // Wait for an interrupt.
     void Idle();
 
-    /// Interrupt this physical core.
+    // Interrupt this core.
     void Interrupt();
 
-    /// Clear this core's interrupt
+    // Clear this core's interrupt.
     void ClearInterrupt();
 
-    /// Check if this core is interrupted
+    // Check if this core is interrupted.
     bool IsInterrupted() const;
 
-    bool IsInitialized() const {
-        return m_arm_interface != nullptr;
-    }
-
-    Core::ARM_Interface& ArmInterface() {
-        return *m_arm_interface;
-    }
-
-    const Core::ARM_Interface& ArmInterface() const {
-        return *m_arm_interface;
-    }
-
     std::size_t CoreIndex() const {
         return m_core_index;
     }
 
-    Kernel::KScheduler& Scheduler() {
-        return m_scheduler;
-    }
-
-    const Kernel::KScheduler& Scheduler() const {
-        return m_scheduler;
-    }
-
 private:
+    KernelCore& m_kernel;
     const std::size_t m_core_index;
-    Core::System& m_system;
-    Kernel::KScheduler& m_scheduler;
 
     std::mutex m_guard;
     std::condition_variable m_on_interrupt;
-    std::unique_ptr<Core::ARM_Interface> m_arm_interface;
+    Core::ArmInterface* m_arm_interface{};
+    KThread* m_current_thread{};
     bool m_is_interrupted{};
+    bool m_is_single_core{};
 };
 
 } // namespace Kernel
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index b76683969..c55dc0c8a 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -12,20 +12,20 @@
 
 namespace Kernel::Svc {
 
-static uint32_t GetReg32(Core::System& system, int n) {
-    return static_cast<uint32_t>(system.CurrentArmInterface().GetReg(n));
+static uint32_t GetArg32(std::span<uint64_t, 8> args, int n) {
+    return static_cast<uint32_t>(args[n]);
 }
 
-static void SetReg32(Core::System& system, int n, uint32_t result) {
-    system.CurrentArmInterface().SetReg(n, static_cast<uint64_t>(result));
+static void SetArg32(std::span<uint64_t, 8> args, int n, uint32_t result) {
+    args[n] = result;
 }
 
-static uint64_t GetReg64(Core::System& system, int n) {
-    return system.CurrentArmInterface().GetReg(n);
+static uint64_t GetArg64(std::span<uint64_t, 8> args, int n) {
+    return args[n];
 }
 
-static void SetReg64(Core::System& system, int n, uint64_t result) {
-    system.CurrentArmInterface().SetReg(n, result);
+static void SetArg64(std::span<uint64_t, 8> args, int n, uint64_t result) {
+    args[n] = result;
 }
 
 // Like bit_cast, but handles the case when the source and dest
@@ -79,37 +79,37 @@ static_assert(sizeof(int64_t) == 8);
 static_assert(sizeof(uint32_t) == 4);
 static_assert(sizeof(uint64_t) == 8);
 
-static void SvcWrap_SetHeapSize64From32(Core::System& system) {
+static void SvcWrap_SetHeapSize64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t out_address{};
     uint32_t size{};
 
-    size = Convert<uint32_t>(GetReg32(system, 1));
+    size = Convert<uint32_t>(GetArg32(args, 1));
 
     ret = SetHeapSize64From32(system, std::addressof(out_address), size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_address));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_address));
 }
 
-static void SvcWrap_SetMemoryPermission64From32(Core::System& system) {
+static void SvcWrap_SetMemoryPermission64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t address{};
     uint32_t size{};
     MemoryPermission perm{};
 
-    address = Convert<uint32_t>(GetReg32(system, 0));
-    size = Convert<uint32_t>(GetReg32(system, 1));
-    perm = Convert<MemoryPermission>(GetReg32(system, 2));
+    address = Convert<uint32_t>(GetArg32(args, 0));
+    size = Convert<uint32_t>(GetArg32(args, 1));
+    perm = Convert<MemoryPermission>(GetArg32(args, 2));
 
     ret = SetMemoryPermission64From32(system, address, size, perm);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_SetMemoryAttribute64From32(Core::System& system) {
+static void SvcWrap_SetMemoryAttribute64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t address{};
@@ -117,69 +117,69 @@ static void SvcWrap_SetMemoryAttribute64From32(Core::System& system) {
     uint32_t mask{};
     uint32_t attr{};
 
-    address = Convert<uint32_t>(GetReg32(system, 0));
-    size = Convert<uint32_t>(GetReg32(system, 1));
-    mask = Convert<uint32_t>(GetReg32(system, 2));
-    attr = Convert<uint32_t>(GetReg32(system, 3));
+    address = Convert<uint32_t>(GetArg32(args, 0));
+    size = Convert<uint32_t>(GetArg32(args, 1));
+    mask = Convert<uint32_t>(GetArg32(args, 2));
+    attr = Convert<uint32_t>(GetArg32(args, 3));
 
     ret = SetMemoryAttribute64From32(system, address, size, mask, attr);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_MapMemory64From32(Core::System& system) {
+static void SvcWrap_MapMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t dst_address{};
     uint32_t src_address{};
     uint32_t size{};
 
-    dst_address = Convert<uint32_t>(GetReg32(system, 0));
-    src_address = Convert<uint32_t>(GetReg32(system, 1));
-    size = Convert<uint32_t>(GetReg32(system, 2));
+    dst_address = Convert<uint32_t>(GetArg32(args, 0));
+    src_address = Convert<uint32_t>(GetArg32(args, 1));
+    size = Convert<uint32_t>(GetArg32(args, 2));
 
     ret = MapMemory64From32(system, dst_address, src_address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_UnmapMemory64From32(Core::System& system) {
+static void SvcWrap_UnmapMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t dst_address{};
     uint32_t src_address{};
     uint32_t size{};
 
-    dst_address = Convert<uint32_t>(GetReg32(system, 0));
-    src_address = Convert<uint32_t>(GetReg32(system, 1));
-    size = Convert<uint32_t>(GetReg32(system, 2));
+    dst_address = Convert<uint32_t>(GetArg32(args, 0));
+    src_address = Convert<uint32_t>(GetArg32(args, 1));
+    size = Convert<uint32_t>(GetArg32(args, 2));
 
     ret = UnmapMemory64From32(system, dst_address, src_address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_QueryMemory64From32(Core::System& system) {
+static void SvcWrap_QueryMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     PageInfo out_page_info{};
     uint32_t out_memory_info{};
     uint32_t address{};
 
-    out_memory_info = Convert<uint32_t>(GetReg32(system, 0));
-    address = Convert<uint32_t>(GetReg32(system, 2));
+    out_memory_info = Convert<uint32_t>(GetArg32(args, 0));
+    address = Convert<uint32_t>(GetArg32(args, 2));
 
     ret = QueryMemory64From32(system, out_memory_info, std::addressof(out_page_info), address);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_page_info));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_page_info));
 }
 
-static void SvcWrap_ExitProcess64From32(Core::System& system) {
+static void SvcWrap_ExitProcess64From32(Core::System& system, std::span<uint64_t, 8> args) {
     ExitProcess64From32(system);
 }
 
-static void SvcWrap_CreateThread64From32(Core::System& system) {
+static void SvcWrap_CreateThread64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
@@ -189,143 +189,143 @@ static void SvcWrap_CreateThread64From32(Core::System& system) {
     int32_t priority{};
     int32_t core_id{};
 
-    func = Convert<uint32_t>(GetReg32(system, 1));
-    arg = Convert<uint32_t>(GetReg32(system, 2));
-    stack_bottom = Convert<uint32_t>(GetReg32(system, 3));
-    priority = Convert<int32_t>(GetReg32(system, 0));
-    core_id = Convert<int32_t>(GetReg32(system, 4));
+    func = Convert<uint32_t>(GetArg32(args, 1));
+    arg = Convert<uint32_t>(GetArg32(args, 2));
+    stack_bottom = Convert<uint32_t>(GetArg32(args, 3));
+    priority = Convert<int32_t>(GetArg32(args, 0));
+    core_id = Convert<int32_t>(GetArg32(args, 4));
 
     ret = CreateThread64From32(system, std::addressof(out_handle), func, arg, stack_bottom, priority, core_id);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_handle));
 }
 
-static void SvcWrap_StartThread64From32(Core::System& system) {
+static void SvcWrap_StartThread64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle thread_handle{};
 
-    thread_handle = Convert<Handle>(GetReg32(system, 0));
+    thread_handle = Convert<Handle>(GetArg32(args, 0));
 
     ret = StartThread64From32(system, thread_handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_ExitThread64From32(Core::System& system) {
+static void SvcWrap_ExitThread64From32(Core::System& system, std::span<uint64_t, 8> args) {
     ExitThread64From32(system);
 }
 
-static void SvcWrap_SleepThread64From32(Core::System& system) {
+static void SvcWrap_SleepThread64From32(Core::System& system, std::span<uint64_t, 8> args) {
     int64_t ns{};
 
     std::array<uint32_t, 2> ns_gather{};
-    ns_gather[0] = GetReg32(system, 0);
-    ns_gather[1] = GetReg32(system, 1);
+    ns_gather[0] = GetArg32(args, 0);
+    ns_gather[1] = GetArg32(args, 1);
     ns = Convert<int64_t>(ns_gather);
 
     SleepThread64From32(system, ns);
 }
 
-static void SvcWrap_GetThreadPriority64From32(Core::System& system) {
+static void SvcWrap_GetThreadPriority64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int32_t out_priority{};
     Handle thread_handle{};
 
-    thread_handle = Convert<Handle>(GetReg32(system, 1));
+    thread_handle = Convert<Handle>(GetArg32(args, 1));
 
     ret = GetThreadPriority64From32(system, std::addressof(out_priority), thread_handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_priority));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_priority));
 }
 
-static void SvcWrap_SetThreadPriority64From32(Core::System& system) {
+static void SvcWrap_SetThreadPriority64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle thread_handle{};
     int32_t priority{};
 
-    thread_handle = Convert<Handle>(GetReg32(system, 0));
-    priority = Convert<int32_t>(GetReg32(system, 1));
+    thread_handle = Convert<Handle>(GetArg32(args, 0));
+    priority = Convert<int32_t>(GetArg32(args, 1));
 
     ret = SetThreadPriority64From32(system, thread_handle, priority);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_GetThreadCoreMask64From32(Core::System& system) {
+static void SvcWrap_GetThreadCoreMask64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int32_t out_core_id{};
     uint64_t out_affinity_mask{};
     Handle thread_handle{};
 
-    thread_handle = Convert<Handle>(GetReg32(system, 2));
+    thread_handle = Convert<Handle>(GetArg32(args, 2));
 
     ret = GetThreadCoreMask64From32(system, std::addressof(out_core_id), std::addressof(out_affinity_mask), thread_handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_core_id));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_core_id));
     auto out_affinity_mask_scatter = Convert<std::array<uint32_t, 2>>(out_affinity_mask);
-    SetReg32(system, 2, out_affinity_mask_scatter[0]);
-    SetReg32(system, 3, out_affinity_mask_scatter[1]);
+    SetArg32(args, 2, out_affinity_mask_scatter[0]);
+    SetArg32(args, 3, out_affinity_mask_scatter[1]);
 }
 
-static void SvcWrap_SetThreadCoreMask64From32(Core::System& system) {
+static void SvcWrap_SetThreadCoreMask64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle thread_handle{};
     int32_t core_id{};
     uint64_t affinity_mask{};
 
-    thread_handle = Convert<Handle>(GetReg32(system, 0));
-    core_id = Convert<int32_t>(GetReg32(system, 1));
+    thread_handle = Convert<Handle>(GetArg32(args, 0));
+    core_id = Convert<int32_t>(GetArg32(args, 1));
     std::array<uint32_t, 2> affinity_mask_gather{};
-    affinity_mask_gather[0] = GetReg32(system, 2);
-    affinity_mask_gather[1] = GetReg32(system, 3);
+    affinity_mask_gather[0] = GetArg32(args, 2);
+    affinity_mask_gather[1] = GetArg32(args, 3);
     affinity_mask = Convert<uint64_t>(affinity_mask_gather);
 
     ret = SetThreadCoreMask64From32(system, thread_handle, core_id, affinity_mask);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_GetCurrentProcessorNumber64From32(Core::System& system) {
+static void SvcWrap_GetCurrentProcessorNumber64From32(Core::System& system, std::span<uint64_t, 8> args) {
     int32_t ret{};
 
     ret = GetCurrentProcessorNumber64From32(system);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_SignalEvent64From32(Core::System& system) {
+static void SvcWrap_SignalEvent64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle event_handle{};
 
-    event_handle = Convert<Handle>(GetReg32(system, 0));
+    event_handle = Convert<Handle>(GetArg32(args, 0));
 
     ret = SignalEvent64From32(system, event_handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_ClearEvent64From32(Core::System& system) {
+static void SvcWrap_ClearEvent64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle event_handle{};
 
-    event_handle = Convert<Handle>(GetReg32(system, 0));
+    event_handle = Convert<Handle>(GetArg32(args, 0));
 
     ret = ClearEvent64From32(system, event_handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_MapSharedMemory64From32(Core::System& system) {
+static void SvcWrap_MapSharedMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle shmem_handle{};
@@ -333,33 +333,33 @@ static void SvcWrap_MapSharedMemory64From32(Core::System& system) {
     uint32_t size{};
     MemoryPermission map_perm{};
 
-    shmem_handle = Convert<Handle>(GetReg32(system, 0));
-    address = Convert<uint32_t>(GetReg32(system, 1));
-    size = Convert<uint32_t>(GetReg32(system, 2));
-    map_perm = Convert<MemoryPermission>(GetReg32(system, 3));
+    shmem_handle = Convert<Handle>(GetArg32(args, 0));
+    address = Convert<uint32_t>(GetArg32(args, 1));
+    size = Convert<uint32_t>(GetArg32(args, 2));
+    map_perm = Convert<MemoryPermission>(GetArg32(args, 3));
 
     ret = MapSharedMemory64From32(system, shmem_handle, address, size, map_perm);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_UnmapSharedMemory64From32(Core::System& system) {
+static void SvcWrap_UnmapSharedMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle shmem_handle{};
     uint32_t address{};
     uint32_t size{};
 
-    shmem_handle = Convert<Handle>(GetReg32(system, 0));
-    address = Convert<uint32_t>(GetReg32(system, 1));
-    size = Convert<uint32_t>(GetReg32(system, 2));
+    shmem_handle = Convert<Handle>(GetArg32(args, 0));
+    address = Convert<uint32_t>(GetArg32(args, 1));
+    size = Convert<uint32_t>(GetArg32(args, 2));
 
     ret = UnmapSharedMemory64From32(system, shmem_handle, address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_CreateTransferMemory64From32(Core::System& system) {
+static void SvcWrap_CreateTransferMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
@@ -367,41 +367,41 @@ static void SvcWrap_CreateTransferMemory64From32(Core::System& system) {
     uint32_t size{};
     MemoryPermission map_perm{};
 
-    address = Convert<uint32_t>(GetReg32(system, 1));
-    size = Convert<uint32_t>(GetReg32(system, 2));
-    map_perm = Convert<MemoryPermission>(GetReg32(system, 3));
+    address = Convert<uint32_t>(GetArg32(args, 1));
+    size = Convert<uint32_t>(GetArg32(args, 2));
+    map_perm = Convert<MemoryPermission>(GetArg32(args, 3));
 
     ret = CreateTransferMemory64From32(system, std::addressof(out_handle), address, size, map_perm);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_handle));
 }
 
-static void SvcWrap_CloseHandle64From32(Core::System& system) {
+static void SvcWrap_CloseHandle64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle handle{};
 
-    handle = Convert<Handle>(GetReg32(system, 0));
+    handle = Convert<Handle>(GetArg32(args, 0));
 
     ret = CloseHandle64From32(system, handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_ResetSignal64From32(Core::System& system) {
+static void SvcWrap_ResetSignal64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle handle{};
 
-    handle = Convert<Handle>(GetReg32(system, 0));
+    handle = Convert<Handle>(GetArg32(args, 0));
 
     ret = ResetSignal64From32(system, handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_WaitSynchronization64From32(Core::System& system) {
+static void SvcWrap_WaitSynchronization64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int32_t out_index{};
@@ -409,60 +409,60 @@ static void SvcWrap_WaitSynchronization64From32(Core::System& system) {
     int32_t num_handles{};
     int64_t timeout_ns{};
 
-    handles = Convert<uint32_t>(GetReg32(system, 1));
-    num_handles = Convert<int32_t>(GetReg32(system, 2));
+    handles = Convert<uint32_t>(GetArg32(args, 1));
+    num_handles = Convert<int32_t>(GetArg32(args, 2));
     std::array<uint32_t, 2> timeout_ns_gather{};
-    timeout_ns_gather[0] = GetReg32(system, 0);
-    timeout_ns_gather[1] = GetReg32(system, 3);
+    timeout_ns_gather[0] = GetArg32(args, 0);
+    timeout_ns_gather[1] = GetArg32(args, 3);
     timeout_ns = Convert<int64_t>(timeout_ns_gather);
 
     ret = WaitSynchronization64From32(system, std::addressof(out_index), handles, num_handles, timeout_ns);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_index));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_index));
 }
 
-static void SvcWrap_CancelSynchronization64From32(Core::System& system) {
+static void SvcWrap_CancelSynchronization64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle handle{};
 
-    handle = Convert<Handle>(GetReg32(system, 0));
+    handle = Convert<Handle>(GetArg32(args, 0));
 
     ret = CancelSynchronization64From32(system, handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_ArbitrateLock64From32(Core::System& system) {
+static void SvcWrap_ArbitrateLock64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle thread_handle{};
     uint32_t address{};
     uint32_t tag{};
 
-    thread_handle = Convert<Handle>(GetReg32(system, 0));
-    address = Convert<uint32_t>(GetReg32(system, 1));
-    tag = Convert<uint32_t>(GetReg32(system, 2));
+    thread_handle = Convert<Handle>(GetArg32(args, 0));
+    address = Convert<uint32_t>(GetArg32(args, 1));
+    tag = Convert<uint32_t>(GetArg32(args, 2));
 
     ret = ArbitrateLock64From32(system, thread_handle, address, tag);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_ArbitrateUnlock64From32(Core::System& system) {
+static void SvcWrap_ArbitrateUnlock64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t address{};
 
-    address = Convert<uint32_t>(GetReg32(system, 0));
+    address = Convert<uint32_t>(GetArg32(args, 0));
 
     ret = ArbitrateUnlock64From32(system, address);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_WaitProcessWideKeyAtomic64From32(Core::System& system) {
+static void SvcWrap_WaitProcessWideKeyAtomic64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t address{};
@@ -470,82 +470,82 @@ static void SvcWrap_WaitProcessWideKeyAtomic64From32(Core::System& system) {
     uint32_t tag{};
     int64_t timeout_ns{};
 
-    address = Convert<uint32_t>(GetReg32(system, 0));
-    cv_key = Convert<uint32_t>(GetReg32(system, 1));
-    tag = Convert<uint32_t>(GetReg32(system, 2));
+    address = Convert<uint32_t>(GetArg32(args, 0));
+    cv_key = Convert<uint32_t>(GetArg32(args, 1));
+    tag = Convert<uint32_t>(GetArg32(args, 2));
     std::array<uint32_t, 2> timeout_ns_gather{};
-    timeout_ns_gather[0] = GetReg32(system, 3);
-    timeout_ns_gather[1] = GetReg32(system, 4);
+    timeout_ns_gather[0] = GetArg32(args, 3);
+    timeout_ns_gather[1] = GetArg32(args, 4);
     timeout_ns = Convert<int64_t>(timeout_ns_gather);
 
     ret = WaitProcessWideKeyAtomic64From32(system, address, cv_key, tag, timeout_ns);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_SignalProcessWideKey64From32(Core::System& system) {
+static void SvcWrap_SignalProcessWideKey64From32(Core::System& system, std::span<uint64_t, 8> args) {
     uint32_t cv_key{};
     int32_t count{};
 
-    cv_key = Convert<uint32_t>(GetReg32(system, 0));
-    count = Convert<int32_t>(GetReg32(system, 1));
+    cv_key = Convert<uint32_t>(GetArg32(args, 0));
+    count = Convert<int32_t>(GetArg32(args, 1));
 
     SignalProcessWideKey64From32(system, cv_key, count);
 }
 
-static void SvcWrap_GetSystemTick64From32(Core::System& system) {
+static void SvcWrap_GetSystemTick64From32(Core::System& system, std::span<uint64_t, 8> args) {
     int64_t ret{};
 
     ret = GetSystemTick64From32(system);
 
     auto ret_scatter = Convert<std::array<uint32_t, 2>>(ret);
-    SetReg32(system, 0, ret_scatter[0]);
-    SetReg32(system, 1, ret_scatter[1]);
+    SetArg32(args, 0, ret_scatter[0]);
+    SetArg32(args, 1, ret_scatter[1]);
 }
 
-static void SvcWrap_ConnectToNamedPort64From32(Core::System& system) {
+static void SvcWrap_ConnectToNamedPort64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
     uint32_t name{};
 
-    name = Convert<uint32_t>(GetReg32(system, 1));
+    name = Convert<uint32_t>(GetArg32(args, 1));
 
     ret = ConnectToNamedPort64From32(system, std::addressof(out_handle), name);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_handle));
 }
 
-static void SvcWrap_SendSyncRequest64From32(Core::System& system) {
+static void SvcWrap_SendSyncRequest64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle session_handle{};
 
-    session_handle = Convert<Handle>(GetReg32(system, 0));
+    session_handle = Convert<Handle>(GetArg32(args, 0));
 
     ret = SendSyncRequest64From32(system, session_handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_SendSyncRequestWithUserBuffer64From32(Core::System& system) {
+static void SvcWrap_SendSyncRequestWithUserBuffer64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t message_buffer{};
     uint32_t message_buffer_size{};
     Handle session_handle{};
 
-    message_buffer = Convert<uint32_t>(GetReg32(system, 0));
-    message_buffer_size = Convert<uint32_t>(GetReg32(system, 1));
-    session_handle = Convert<Handle>(GetReg32(system, 2));
+    message_buffer = Convert<uint32_t>(GetArg32(args, 0));
+    message_buffer_size = Convert<uint32_t>(GetArg32(args, 1));
+    session_handle = Convert<Handle>(GetArg32(args, 2));
 
     ret = SendSyncRequestWithUserBuffer64From32(system, message_buffer, message_buffer_size, session_handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_SendAsyncRequestWithUserBuffer64From32(Core::System& system) {
+static void SvcWrap_SendAsyncRequestWithUserBuffer64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_event_handle{};
@@ -553,83 +553,83 @@ static void SvcWrap_SendAsyncRequestWithUserBuffer64From32(Core::System& system)
     uint32_t message_buffer_size{};
     Handle session_handle{};
 
-    message_buffer = Convert<uint32_t>(GetReg32(system, 1));
-    message_buffer_size = Convert<uint32_t>(GetReg32(system, 2));
-    session_handle = Convert<Handle>(GetReg32(system, 3));
+    message_buffer = Convert<uint32_t>(GetArg32(args, 1));
+    message_buffer_size = Convert<uint32_t>(GetArg32(args, 2));
+    session_handle = Convert<Handle>(GetArg32(args, 3));
 
     ret = SendAsyncRequestWithUserBuffer64From32(system, std::addressof(out_event_handle), message_buffer, message_buffer_size, session_handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_event_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_event_handle));
 }
 
-static void SvcWrap_GetProcessId64From32(Core::System& system) {
+static void SvcWrap_GetProcessId64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t out_process_id{};
     Handle process_handle{};
 
-    process_handle = Convert<Handle>(GetReg32(system, 1));
+    process_handle = Convert<Handle>(GetArg32(args, 1));
 
     ret = GetProcessId64From32(system, std::addressof(out_process_id), process_handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
     auto out_process_id_scatter = Convert<std::array<uint32_t, 2>>(out_process_id);
-    SetReg32(system, 1, out_process_id_scatter[0]);
-    SetReg32(system, 2, out_process_id_scatter[1]);
+    SetArg32(args, 1, out_process_id_scatter[0]);
+    SetArg32(args, 2, out_process_id_scatter[1]);
 }
 
-static void SvcWrap_GetThreadId64From32(Core::System& system) {
+static void SvcWrap_GetThreadId64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t out_thread_id{};
     Handle thread_handle{};
 
-    thread_handle = Convert<Handle>(GetReg32(system, 1));
+    thread_handle = Convert<Handle>(GetArg32(args, 1));
 
     ret = GetThreadId64From32(system, std::addressof(out_thread_id), thread_handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
     auto out_thread_id_scatter = Convert<std::array<uint32_t, 2>>(out_thread_id);
-    SetReg32(system, 1, out_thread_id_scatter[0]);
-    SetReg32(system, 2, out_thread_id_scatter[1]);
+    SetArg32(args, 1, out_thread_id_scatter[0]);
+    SetArg32(args, 2, out_thread_id_scatter[1]);
 }
 
-static void SvcWrap_Break64From32(Core::System& system) {
+static void SvcWrap_Break64From32(Core::System& system, std::span<uint64_t, 8> args) {
     BreakReason break_reason{};
     uint32_t arg{};
     uint32_t size{};
 
-    break_reason = Convert<BreakReason>(GetReg32(system, 0));
-    arg = Convert<uint32_t>(GetReg32(system, 1));
-    size = Convert<uint32_t>(GetReg32(system, 2));
+    break_reason = Convert<BreakReason>(GetArg32(args, 0));
+    arg = Convert<uint32_t>(GetArg32(args, 1));
+    size = Convert<uint32_t>(GetArg32(args, 2));
 
     Break64From32(system, break_reason, arg, size);
 }
 
-static void SvcWrap_OutputDebugString64From32(Core::System& system) {
+static void SvcWrap_OutputDebugString64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t debug_str{};
     uint32_t len{};
 
-    debug_str = Convert<uint32_t>(GetReg32(system, 0));
-    len = Convert<uint32_t>(GetReg32(system, 1));
+    debug_str = Convert<uint32_t>(GetArg32(args, 0));
+    len = Convert<uint32_t>(GetArg32(args, 1));
 
     ret = OutputDebugString64From32(system, debug_str, len);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_ReturnFromException64From32(Core::System& system) {
+static void SvcWrap_ReturnFromException64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result result{};
 
-    result = Convert<Result>(GetReg32(system, 0));
+    result = Convert<Result>(GetArg32(args, 0));
 
     ReturnFromException64From32(system, result);
 }
 
-static void SvcWrap_GetInfo64From32(Core::System& system) {
+static void SvcWrap_GetInfo64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t out{};
@@ -637,68 +637,68 @@ static void SvcWrap_GetInfo64From32(Core::System& system) {
     Handle handle{};
     uint64_t info_subtype{};
 
-    info_type = Convert<InfoType>(GetReg32(system, 1));
-    handle = Convert<Handle>(GetReg32(system, 2));
+    info_type = Convert<InfoType>(GetArg32(args, 1));
+    handle = Convert<Handle>(GetArg32(args, 2));
     std::array<uint32_t, 2> info_subtype_gather{};
-    info_subtype_gather[0] = GetReg32(system, 0);
-    info_subtype_gather[1] = GetReg32(system, 3);
+    info_subtype_gather[0] = GetArg32(args, 0);
+    info_subtype_gather[1] = GetArg32(args, 3);
     info_subtype = Convert<uint64_t>(info_subtype_gather);
 
     ret = GetInfo64From32(system, std::addressof(out), info_type, handle, info_subtype);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
     auto out_scatter = Convert<std::array<uint32_t, 2>>(out);
-    SetReg32(system, 1, out_scatter[0]);
-    SetReg32(system, 2, out_scatter[1]);
+    SetArg32(args, 1, out_scatter[0]);
+    SetArg32(args, 2, out_scatter[1]);
 }
 
-static void SvcWrap_FlushEntireDataCache64From32(Core::System& system) {
+static void SvcWrap_FlushEntireDataCache64From32(Core::System& system, std::span<uint64_t, 8> args) {
     FlushEntireDataCache64From32(system);
 }
 
-static void SvcWrap_FlushDataCache64From32(Core::System& system) {
+static void SvcWrap_FlushDataCache64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t address{};
     uint32_t size{};
 
-    address = Convert<uint32_t>(GetReg32(system, 0));
-    size = Convert<uint32_t>(GetReg32(system, 1));
+    address = Convert<uint32_t>(GetArg32(args, 0));
+    size = Convert<uint32_t>(GetArg32(args, 1));
 
     ret = FlushDataCache64From32(system, address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_MapPhysicalMemory64From32(Core::System& system) {
+static void SvcWrap_MapPhysicalMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t address{};
     uint32_t size{};
 
-    address = Convert<uint32_t>(GetReg32(system, 0));
-    size = Convert<uint32_t>(GetReg32(system, 1));
+    address = Convert<uint32_t>(GetArg32(args, 0));
+    size = Convert<uint32_t>(GetArg32(args, 1));
 
     ret = MapPhysicalMemory64From32(system, address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_UnmapPhysicalMemory64From32(Core::System& system) {
+static void SvcWrap_UnmapPhysicalMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t address{};
     uint32_t size{};
 
-    address = Convert<uint32_t>(GetReg32(system, 0));
-    size = Convert<uint32_t>(GetReg32(system, 1));
+    address = Convert<uint32_t>(GetArg32(args, 0));
+    size = Convert<uint32_t>(GetArg32(args, 1));
 
     ret = UnmapPhysicalMemory64From32(system, address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_GetDebugFutureThreadInfo64From32(Core::System& system) {
+static void SvcWrap_GetDebugFutureThreadInfo64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     ilp32::LastThreadContext out_context{};
@@ -706,26 +706,26 @@ static void SvcWrap_GetDebugFutureThreadInfo64From32(Core::System& system) {
     Handle debug_handle{};
     int64_t ns{};
 
-    debug_handle = Convert<Handle>(GetReg32(system, 2));
+    debug_handle = Convert<Handle>(GetArg32(args, 2));
     std::array<uint32_t, 2> ns_gather{};
-    ns_gather[0] = GetReg32(system, 0);
-    ns_gather[1] = GetReg32(system, 1);
+    ns_gather[0] = GetArg32(args, 0);
+    ns_gather[1] = GetArg32(args, 1);
     ns = Convert<int64_t>(ns_gather);
 
     ret = GetDebugFutureThreadInfo64From32(system, std::addressof(out_context), std::addressof(out_thread_id), debug_handle, ns);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
     auto out_context_scatter = Convert<std::array<uint32_t, 4>>(out_context);
-    SetReg32(system, 1, out_context_scatter[0]);
-    SetReg32(system, 2, out_context_scatter[1]);
-    SetReg32(system, 3, out_context_scatter[2]);
-    SetReg32(system, 4, out_context_scatter[3]);
+    SetArg32(args, 1, out_context_scatter[0]);
+    SetArg32(args, 2, out_context_scatter[1]);
+    SetArg32(args, 3, out_context_scatter[2]);
+    SetArg32(args, 4, out_context_scatter[3]);
     auto out_thread_id_scatter = Convert<std::array<uint32_t, 2>>(out_thread_id);
-    SetReg32(system, 5, out_thread_id_scatter[0]);
-    SetReg32(system, 6, out_thread_id_scatter[1]);
+    SetArg32(args, 5, out_thread_id_scatter[0]);
+    SetArg32(args, 6, out_thread_id_scatter[1]);
 }
 
-static void SvcWrap_GetLastThreadInfo64From32(Core::System& system) {
+static void SvcWrap_GetLastThreadInfo64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     ilp32::LastThreadContext out_context{};
@@ -734,81 +734,81 @@ static void SvcWrap_GetLastThreadInfo64From32(Core::System& system) {
 
     ret = GetLastThreadInfo64From32(system, std::addressof(out_context), std::addressof(out_tls_address), std::addressof(out_flags));
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
     auto out_context_scatter = Convert<std::array<uint32_t, 4>>(out_context);
-    SetReg32(system, 1, out_context_scatter[0]);
-    SetReg32(system, 2, out_context_scatter[1]);
-    SetReg32(system, 3, out_context_scatter[2]);
-    SetReg32(system, 4, out_context_scatter[3]);
-    SetReg32(system, 5, Convert<uint32_t>(out_tls_address));
-    SetReg32(system, 6, Convert<uint32_t>(out_flags));
+    SetArg32(args, 1, out_context_scatter[0]);
+    SetArg32(args, 2, out_context_scatter[1]);
+    SetArg32(args, 3, out_context_scatter[2]);
+    SetArg32(args, 4, out_context_scatter[3]);
+    SetArg32(args, 5, Convert<uint32_t>(out_tls_address));
+    SetArg32(args, 6, Convert<uint32_t>(out_flags));
 }
 
-static void SvcWrap_GetResourceLimitLimitValue64From32(Core::System& system) {
+static void SvcWrap_GetResourceLimitLimitValue64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int64_t out_limit_value{};
     Handle resource_limit_handle{};
     LimitableResource which{};
 
-    resource_limit_handle = Convert<Handle>(GetReg32(system, 1));
-    which = Convert<LimitableResource>(GetReg32(system, 2));
+    resource_limit_handle = Convert<Handle>(GetArg32(args, 1));
+    which = Convert<LimitableResource>(GetArg32(args, 2));
 
     ret = GetResourceLimitLimitValue64From32(system, std::addressof(out_limit_value), resource_limit_handle, which);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
     auto out_limit_value_scatter = Convert<std::array<uint32_t, 2>>(out_limit_value);
-    SetReg32(system, 1, out_limit_value_scatter[0]);
-    SetReg32(system, 2, out_limit_value_scatter[1]);
+    SetArg32(args, 1, out_limit_value_scatter[0]);
+    SetArg32(args, 2, out_limit_value_scatter[1]);
 }
 
-static void SvcWrap_GetResourceLimitCurrentValue64From32(Core::System& system) {
+static void SvcWrap_GetResourceLimitCurrentValue64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int64_t out_current_value{};
     Handle resource_limit_handle{};
     LimitableResource which{};
 
-    resource_limit_handle = Convert<Handle>(GetReg32(system, 1));
-    which = Convert<LimitableResource>(GetReg32(system, 2));
+    resource_limit_handle = Convert<Handle>(GetArg32(args, 1));
+    which = Convert<LimitableResource>(GetArg32(args, 2));
 
     ret = GetResourceLimitCurrentValue64From32(system, std::addressof(out_current_value), resource_limit_handle, which);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
     auto out_current_value_scatter = Convert<std::array<uint32_t, 2>>(out_current_value);
-    SetReg32(system, 1, out_current_value_scatter[0]);
-    SetReg32(system, 2, out_current_value_scatter[1]);
+    SetArg32(args, 1, out_current_value_scatter[0]);
+    SetArg32(args, 2, out_current_value_scatter[1]);
 }
 
-static void SvcWrap_SetThreadActivity64From32(Core::System& system) {
+static void SvcWrap_SetThreadActivity64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle thread_handle{};
     ThreadActivity thread_activity{};
 
-    thread_handle = Convert<Handle>(GetReg32(system, 0));
-    thread_activity = Convert<ThreadActivity>(GetReg32(system, 1));
+    thread_handle = Convert<Handle>(GetArg32(args, 0));
+    thread_activity = Convert<ThreadActivity>(GetArg32(args, 1));
 
     ret = SetThreadActivity64From32(system, thread_handle, thread_activity);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_GetThreadContext364From32(Core::System& system) {
+static void SvcWrap_GetThreadContext364From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t out_context{};
     Handle thread_handle{};
 
-    out_context = Convert<uint32_t>(GetReg32(system, 0));
-    thread_handle = Convert<Handle>(GetReg32(system, 1));
+    out_context = Convert<uint32_t>(GetArg32(args, 0));
+    thread_handle = Convert<Handle>(GetArg32(args, 1));
 
     ret = GetThreadContext364From32(system, out_context, thread_handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_WaitForAddress64From32(Core::System& system) {
+static void SvcWrap_WaitForAddress64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t address{};
@@ -816,20 +816,20 @@ static void SvcWrap_WaitForAddress64From32(Core::System& system) {
     int32_t value{};
     int64_t timeout_ns{};
 
-    address = Convert<uint32_t>(GetReg32(system, 0));
-    arb_type = Convert<ArbitrationType>(GetReg32(system, 1));
-    value = Convert<int32_t>(GetReg32(system, 2));
+    address = Convert<uint32_t>(GetArg32(args, 0));
+    arb_type = Convert<ArbitrationType>(GetArg32(args, 1));
+    value = Convert<int32_t>(GetArg32(args, 2));
     std::array<uint32_t, 2> timeout_ns_gather{};
-    timeout_ns_gather[0] = GetReg32(system, 3);
-    timeout_ns_gather[1] = GetReg32(system, 4);
+    timeout_ns_gather[0] = GetArg32(args, 3);
+    timeout_ns_gather[1] = GetArg32(args, 4);
     timeout_ns = Convert<int64_t>(timeout_ns_gather);
 
     ret = WaitForAddress64From32(system, address, arb_type, value, timeout_ns);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_SignalToAddress64From32(Core::System& system) {
+static void SvcWrap_SignalToAddress64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t address{};
@@ -837,53 +837,53 @@ static void SvcWrap_SignalToAddress64From32(Core::System& system) {
     int32_t value{};
     int32_t count{};
 
-    address = Convert<uint32_t>(GetReg32(system, 0));
-    signal_type = Convert<SignalType>(GetReg32(system, 1));
-    value = Convert<int32_t>(GetReg32(system, 2));
-    count = Convert<int32_t>(GetReg32(system, 3));
+    address = Convert<uint32_t>(GetArg32(args, 0));
+    signal_type = Convert<SignalType>(GetArg32(args, 1));
+    value = Convert<int32_t>(GetArg32(args, 2));
+    count = Convert<int32_t>(GetArg32(args, 3));
 
     ret = SignalToAddress64From32(system, address, signal_type, value, count);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_SynchronizePreemptionState64From32(Core::System& system) {
+static void SvcWrap_SynchronizePreemptionState64From32(Core::System& system, std::span<uint64_t, 8> args) {
     SynchronizePreemptionState64From32(system);
 }
 
-static void SvcWrap_GetResourceLimitPeakValue64From32(Core::System& system) {
+static void SvcWrap_GetResourceLimitPeakValue64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int64_t out_peak_value{};
     Handle resource_limit_handle{};
     LimitableResource which{};
 
-    resource_limit_handle = Convert<Handle>(GetReg32(system, 1));
-    which = Convert<LimitableResource>(GetReg32(system, 2));
+    resource_limit_handle = Convert<Handle>(GetArg32(args, 1));
+    which = Convert<LimitableResource>(GetArg32(args, 2));
 
     ret = GetResourceLimitPeakValue64From32(system, std::addressof(out_peak_value), resource_limit_handle, which);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
     auto out_peak_value_scatter = Convert<std::array<uint32_t, 2>>(out_peak_value);
-    SetReg32(system, 1, out_peak_value_scatter[0]);
-    SetReg32(system, 2, out_peak_value_scatter[1]);
+    SetArg32(args, 1, out_peak_value_scatter[0]);
+    SetArg32(args, 2, out_peak_value_scatter[1]);
 }
 
-static void SvcWrap_CreateIoPool64From32(Core::System& system) {
+static void SvcWrap_CreateIoPool64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
     IoPoolType which{};
 
-    which = Convert<IoPoolType>(GetReg32(system, 1));
+    which = Convert<IoPoolType>(GetArg32(args, 1));
 
     ret = CreateIoPool64From32(system, std::addressof(out_handle), which);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_handle));
 }
 
-static void SvcWrap_CreateIoRegion64From32(Core::System& system) {
+static void SvcWrap_CreateIoRegion64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
@@ -893,53 +893,53 @@ static void SvcWrap_CreateIoRegion64From32(Core::System& system) {
     MemoryMapping mapping{};
     MemoryPermission perm{};
 
-    io_pool = Convert<Handle>(GetReg32(system, 1));
+    io_pool = Convert<Handle>(GetArg32(args, 1));
     std::array<uint32_t, 2> physical_address_gather{};
-    physical_address_gather[0] = GetReg32(system, 2);
-    physical_address_gather[1] = GetReg32(system, 3);
+    physical_address_gather[0] = GetArg32(args, 2);
+    physical_address_gather[1] = GetArg32(args, 3);
     physical_address = Convert<uint64_t>(physical_address_gather);
-    size = Convert<uint32_t>(GetReg32(system, 0));
-    mapping = Convert<MemoryMapping>(GetReg32(system, 4));
-    perm = Convert<MemoryPermission>(GetReg32(system, 5));
+    size = Convert<uint32_t>(GetArg32(args, 0));
+    mapping = Convert<MemoryMapping>(GetArg32(args, 4));
+    perm = Convert<MemoryPermission>(GetArg32(args, 5));
 
     ret = CreateIoRegion64From32(system, std::addressof(out_handle), io_pool, physical_address, size, mapping, perm);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_handle));
 }
 
-static void SvcWrap_KernelDebug64From32(Core::System& system) {
+static void SvcWrap_KernelDebug64From32(Core::System& system, std::span<uint64_t, 8> args) {
     KernelDebugType kern_debug_type{};
     uint64_t arg0{};
     uint64_t arg1{};
     uint64_t arg2{};
 
-    kern_debug_type = Convert<KernelDebugType>(GetReg32(system, 0));
+    kern_debug_type = Convert<KernelDebugType>(GetArg32(args, 0));
     std::array<uint32_t, 2> arg0_gather{};
-    arg0_gather[0] = GetReg32(system, 2);
-    arg0_gather[1] = GetReg32(system, 3);
+    arg0_gather[0] = GetArg32(args, 2);
+    arg0_gather[1] = GetArg32(args, 3);
     arg0 = Convert<uint64_t>(arg0_gather);
     std::array<uint32_t, 2> arg1_gather{};
-    arg1_gather[0] = GetReg32(system, 1);
-    arg1_gather[1] = GetReg32(system, 4);
+    arg1_gather[0] = GetArg32(args, 1);
+    arg1_gather[1] = GetArg32(args, 4);
     arg1 = Convert<uint64_t>(arg1_gather);
     std::array<uint32_t, 2> arg2_gather{};
-    arg2_gather[0] = GetReg32(system, 5);
-    arg2_gather[1] = GetReg32(system, 6);
+    arg2_gather[0] = GetArg32(args, 5);
+    arg2_gather[1] = GetArg32(args, 6);
     arg2 = Convert<uint64_t>(arg2_gather);
 
     KernelDebug64From32(system, kern_debug_type, arg0, arg1, arg2);
 }
 
-static void SvcWrap_ChangeKernelTraceState64From32(Core::System& system) {
+static void SvcWrap_ChangeKernelTraceState64From32(Core::System& system, std::span<uint64_t, 8> args) {
     KernelTraceState kern_trace_state{};
 
-    kern_trace_state = Convert<KernelTraceState>(GetReg32(system, 0));
+    kern_trace_state = Convert<KernelTraceState>(GetArg32(args, 0));
 
     ChangeKernelTraceState64From32(system, kern_trace_state);
 }
 
-static void SvcWrap_CreateSession64From32(Core::System& system) {
+static void SvcWrap_CreateSession64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_server_session_handle{};
@@ -947,31 +947,31 @@ static void SvcWrap_CreateSession64From32(Core::System& system) {
     bool is_light{};
     uint32_t name{};
 
-    is_light = Convert<bool>(GetReg32(system, 2));
-    name = Convert<uint32_t>(GetReg32(system, 3));
+    is_light = Convert<bool>(GetArg32(args, 2));
+    name = Convert<uint32_t>(GetArg32(args, 3));
 
     ret = CreateSession64From32(system, std::addressof(out_server_session_handle), std::addressof(out_client_session_handle), is_light, name);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_server_session_handle));
-    SetReg32(system, 2, Convert<uint32_t>(out_client_session_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_server_session_handle));
+    SetArg32(args, 2, Convert<uint32_t>(out_client_session_handle));
 }
 
-static void SvcWrap_AcceptSession64From32(Core::System& system) {
+static void SvcWrap_AcceptSession64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
     Handle port{};
 
-    port = Convert<Handle>(GetReg32(system, 1));
+    port = Convert<Handle>(GetArg32(args, 1));
 
     ret = AcceptSession64From32(system, std::addressof(out_handle), port);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_handle));
 }
 
-static void SvcWrap_ReplyAndReceive64From32(Core::System& system) {
+static void SvcWrap_ReplyAndReceive64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int32_t out_index{};
@@ -980,21 +980,21 @@ static void SvcWrap_ReplyAndReceive64From32(Core::System& system) {
     Handle reply_target{};
     int64_t timeout_ns{};
 
-    handles = Convert<uint32_t>(GetReg32(system, 1));
-    num_handles = Convert<int32_t>(GetReg32(system, 2));
-    reply_target = Convert<Handle>(GetReg32(system, 3));
+    handles = Convert<uint32_t>(GetArg32(args, 1));
+    num_handles = Convert<int32_t>(GetArg32(args, 2));
+    reply_target = Convert<Handle>(GetArg32(args, 3));
     std::array<uint32_t, 2> timeout_ns_gather{};
-    timeout_ns_gather[0] = GetReg32(system, 0);
-    timeout_ns_gather[1] = GetReg32(system, 4);
+    timeout_ns_gather[0] = GetArg32(args, 0);
+    timeout_ns_gather[1] = GetArg32(args, 4);
     timeout_ns = Convert<int64_t>(timeout_ns_gather);
 
     ret = ReplyAndReceive64From32(system, std::addressof(out_index), handles, num_handles, reply_target, timeout_ns);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_index));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_index));
 }
 
-static void SvcWrap_ReplyAndReceiveWithUserBuffer64From32(Core::System& system) {
+static void SvcWrap_ReplyAndReceiveWithUserBuffer64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int32_t out_index{};
@@ -1005,23 +1005,23 @@ static void SvcWrap_ReplyAndReceiveWithUserBuffer64From32(Core::System& system)
     Handle reply_target{};
     int64_t timeout_ns{};
 
-    message_buffer = Convert<uint32_t>(GetReg32(system, 1));
-    message_buffer_size = Convert<uint32_t>(GetReg32(system, 2));
-    handles = Convert<uint32_t>(GetReg32(system, 3));
-    num_handles = Convert<int32_t>(GetReg32(system, 0));
-    reply_target = Convert<Handle>(GetReg32(system, 4));
+    message_buffer = Convert<uint32_t>(GetArg32(args, 1));
+    message_buffer_size = Convert<uint32_t>(GetArg32(args, 2));
+    handles = Convert<uint32_t>(GetArg32(args, 3));
+    num_handles = Convert<int32_t>(GetArg32(args, 0));
+    reply_target = Convert<Handle>(GetArg32(args, 4));
     std::array<uint32_t, 2> timeout_ns_gather{};
-    timeout_ns_gather[0] = GetReg32(system, 5);
-    timeout_ns_gather[1] = GetReg32(system, 6);
+    timeout_ns_gather[0] = GetArg32(args, 5);
+    timeout_ns_gather[1] = GetArg32(args, 6);
     timeout_ns = Convert<int64_t>(timeout_ns_gather);
 
     ret = ReplyAndReceiveWithUserBuffer64From32(system, std::addressof(out_index), message_buffer, message_buffer_size, handles, num_handles, reply_target, timeout_ns);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_index));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_index));
 }
 
-static void SvcWrap_CreateEvent64From32(Core::System& system) {
+static void SvcWrap_CreateEvent64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_write_handle{};
@@ -1029,12 +1029,12 @@ static void SvcWrap_CreateEvent64From32(Core::System& system) {
 
     ret = CreateEvent64From32(system, std::addressof(out_write_handle), std::addressof(out_read_handle));
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_write_handle));
-    SetReg32(system, 2, Convert<uint32_t>(out_read_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_write_handle));
+    SetArg32(args, 2, Convert<uint32_t>(out_read_handle));
 }
 
-static void SvcWrap_MapIoRegion64From32(Core::System& system) {
+static void SvcWrap_MapIoRegion64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle io_region{};
@@ -1042,89 +1042,89 @@ static void SvcWrap_MapIoRegion64From32(Core::System& system) {
     uint32_t size{};
     MemoryPermission perm{};
 
-    io_region = Convert<Handle>(GetReg32(system, 0));
-    address = Convert<uint32_t>(GetReg32(system, 1));
-    size = Convert<uint32_t>(GetReg32(system, 2));
-    perm = Convert<MemoryPermission>(GetReg32(system, 3));
+    io_region = Convert<Handle>(GetArg32(args, 0));
+    address = Convert<uint32_t>(GetArg32(args, 1));
+    size = Convert<uint32_t>(GetArg32(args, 2));
+    perm = Convert<MemoryPermission>(GetArg32(args, 3));
 
     ret = MapIoRegion64From32(system, io_region, address, size, perm);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_UnmapIoRegion64From32(Core::System& system) {
+static void SvcWrap_UnmapIoRegion64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle io_region{};
     uint32_t address{};
     uint32_t size{};
 
-    io_region = Convert<Handle>(GetReg32(system, 0));
-    address = Convert<uint32_t>(GetReg32(system, 1));
-    size = Convert<uint32_t>(GetReg32(system, 2));
+    io_region = Convert<Handle>(GetArg32(args, 0));
+    address = Convert<uint32_t>(GetArg32(args, 1));
+    size = Convert<uint32_t>(GetArg32(args, 2));
 
     ret = UnmapIoRegion64From32(system, io_region, address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_MapPhysicalMemoryUnsafe64From32(Core::System& system) {
+static void SvcWrap_MapPhysicalMemoryUnsafe64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t address{};
     uint32_t size{};
 
-    address = Convert<uint32_t>(GetReg32(system, 0));
-    size = Convert<uint32_t>(GetReg32(system, 1));
+    address = Convert<uint32_t>(GetArg32(args, 0));
+    size = Convert<uint32_t>(GetArg32(args, 1));
 
     ret = MapPhysicalMemoryUnsafe64From32(system, address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_UnmapPhysicalMemoryUnsafe64From32(Core::System& system) {
+static void SvcWrap_UnmapPhysicalMemoryUnsafe64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t address{};
     uint32_t size{};
 
-    address = Convert<uint32_t>(GetReg32(system, 0));
-    size = Convert<uint32_t>(GetReg32(system, 1));
+    address = Convert<uint32_t>(GetArg32(args, 0));
+    size = Convert<uint32_t>(GetArg32(args, 1));
 
     ret = UnmapPhysicalMemoryUnsafe64From32(system, address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_SetUnsafeLimit64From32(Core::System& system) {
+static void SvcWrap_SetUnsafeLimit64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t limit{};
 
-    limit = Convert<uint32_t>(GetReg32(system, 0));
+    limit = Convert<uint32_t>(GetArg32(args, 0));
 
     ret = SetUnsafeLimit64From32(system, limit);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_CreateCodeMemory64From32(Core::System& system) {
+static void SvcWrap_CreateCodeMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
     uint32_t address{};
     uint32_t size{};
 
-    address = Convert<uint32_t>(GetReg32(system, 1));
-    size = Convert<uint32_t>(GetReg32(system, 2));
+    address = Convert<uint32_t>(GetArg32(args, 1));
+    size = Convert<uint32_t>(GetArg32(args, 2));
 
     ret = CreateCodeMemory64From32(system, std::addressof(out_handle), address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_handle));
 }
 
-static void SvcWrap_ControlCodeMemory64From32(Core::System& system) {
+static void SvcWrap_ControlCodeMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle code_memory_handle{};
@@ -1133,28 +1133,28 @@ static void SvcWrap_ControlCodeMemory64From32(Core::System& system) {
     uint64_t size{};
     MemoryPermission perm{};
 
-    code_memory_handle = Convert<Handle>(GetReg32(system, 0));
-    operation = Convert<CodeMemoryOperation>(GetReg32(system, 1));
+    code_memory_handle = Convert<Handle>(GetArg32(args, 0));
+    operation = Convert<CodeMemoryOperation>(GetArg32(args, 1));
     std::array<uint32_t, 2> address_gather{};
-    address_gather[0] = GetReg32(system, 2);
-    address_gather[1] = GetReg32(system, 3);
+    address_gather[0] = GetArg32(args, 2);
+    address_gather[1] = GetArg32(args, 3);
     address = Convert<uint64_t>(address_gather);
     std::array<uint32_t, 2> size_gather{};
-    size_gather[0] = GetReg32(system, 4);
-    size_gather[1] = GetReg32(system, 5);
+    size_gather[0] = GetArg32(args, 4);
+    size_gather[1] = GetArg32(args, 5);
     size = Convert<uint64_t>(size_gather);
-    perm = Convert<MemoryPermission>(GetReg32(system, 6));
+    perm = Convert<MemoryPermission>(GetArg32(args, 6));
 
     ret = ControlCodeMemory64From32(system, code_memory_handle, operation, address, size, perm);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_SleepSystem64From32(Core::System& system) {
+static void SvcWrap_SleepSystem64From32(Core::System& system, std::span<uint64_t, 8> args) {
     SleepSystem64From32(system);
 }
 
-static void SvcWrap_ReadWriteRegister64From32(Core::System& system) {
+static void SvcWrap_ReadWriteRegister64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t out_value{};
@@ -1163,33 +1163,33 @@ static void SvcWrap_ReadWriteRegister64From32(Core::System& system) {
     uint32_t value{};
 
     std::array<uint32_t, 2> address_gather{};
-    address_gather[0] = GetReg32(system, 2);
-    address_gather[1] = GetReg32(system, 3);
+    address_gather[0] = GetArg32(args, 2);
+    address_gather[1] = GetArg32(args, 3);
     address = Convert<uint64_t>(address_gather);
-    mask = Convert<uint32_t>(GetReg32(system, 0));
-    value = Convert<uint32_t>(GetReg32(system, 1));
+    mask = Convert<uint32_t>(GetArg32(args, 0));
+    value = Convert<uint32_t>(GetArg32(args, 1));
 
     ret = ReadWriteRegister64From32(system, std::addressof(out_value), address, mask, value);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_value));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_value));
 }
 
-static void SvcWrap_SetProcessActivity64From32(Core::System& system) {
+static void SvcWrap_SetProcessActivity64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle process_handle{};
     ProcessActivity process_activity{};
 
-    process_handle = Convert<Handle>(GetReg32(system, 0));
-    process_activity = Convert<ProcessActivity>(GetReg32(system, 1));
+    process_handle = Convert<Handle>(GetArg32(args, 0));
+    process_activity = Convert<ProcessActivity>(GetArg32(args, 1));
 
     ret = SetProcessActivity64From32(system, process_handle, process_activity);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_CreateSharedMemory64From32(Core::System& system) {
+static void SvcWrap_CreateSharedMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
@@ -1197,17 +1197,17 @@ static void SvcWrap_CreateSharedMemory64From32(Core::System& system) {
     MemoryPermission owner_perm{};
     MemoryPermission remote_perm{};
 
-    size = Convert<uint32_t>(GetReg32(system, 1));
-    owner_perm = Convert<MemoryPermission>(GetReg32(system, 2));
-    remote_perm = Convert<MemoryPermission>(GetReg32(system, 3));
+    size = Convert<uint32_t>(GetArg32(args, 1));
+    owner_perm = Convert<MemoryPermission>(GetArg32(args, 2));
+    remote_perm = Convert<MemoryPermission>(GetArg32(args, 3));
 
     ret = CreateSharedMemory64From32(system, std::addressof(out_handle), size, owner_perm, remote_perm);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_handle));
 }
 
-static void SvcWrap_MapTransferMemory64From32(Core::System& system) {
+static void SvcWrap_MapTransferMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle trmem_handle{};
@@ -1215,67 +1215,67 @@ static void SvcWrap_MapTransferMemory64From32(Core::System& system) {
     uint32_t size{};
     MemoryPermission owner_perm{};
 
-    trmem_handle = Convert<Handle>(GetReg32(system, 0));
-    address = Convert<uint32_t>(GetReg32(system, 1));
-    size = Convert<uint32_t>(GetReg32(system, 2));
-    owner_perm = Convert<MemoryPermission>(GetReg32(system, 3));
+    trmem_handle = Convert<Handle>(GetArg32(args, 0));
+    address = Convert<uint32_t>(GetArg32(args, 1));
+    size = Convert<uint32_t>(GetArg32(args, 2));
+    owner_perm = Convert<MemoryPermission>(GetArg32(args, 3));
 
     ret = MapTransferMemory64From32(system, trmem_handle, address, size, owner_perm);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_UnmapTransferMemory64From32(Core::System& system) {
+static void SvcWrap_UnmapTransferMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle trmem_handle{};
     uint32_t address{};
     uint32_t size{};
 
-    trmem_handle = Convert<Handle>(GetReg32(system, 0));
-    address = Convert<uint32_t>(GetReg32(system, 1));
-    size = Convert<uint32_t>(GetReg32(system, 2));
+    trmem_handle = Convert<Handle>(GetArg32(args, 0));
+    address = Convert<uint32_t>(GetArg32(args, 1));
+    size = Convert<uint32_t>(GetArg32(args, 2));
 
     ret = UnmapTransferMemory64From32(system, trmem_handle, address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_CreateInterruptEvent64From32(Core::System& system) {
+static void SvcWrap_CreateInterruptEvent64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_read_handle{};
     int32_t interrupt_id{};
     InterruptType interrupt_type{};
 
-    interrupt_id = Convert<int32_t>(GetReg32(system, 1));
-    interrupt_type = Convert<InterruptType>(GetReg32(system, 2));
+    interrupt_id = Convert<int32_t>(GetArg32(args, 1));
+    interrupt_type = Convert<InterruptType>(GetArg32(args, 2));
 
     ret = CreateInterruptEvent64From32(system, std::addressof(out_read_handle), interrupt_id, interrupt_type);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_read_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_read_handle));
 }
 
-static void SvcWrap_QueryPhysicalAddress64From32(Core::System& system) {
+static void SvcWrap_QueryPhysicalAddress64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     ilp32::PhysicalMemoryInfo out_info{};
     uint32_t address{};
 
-    address = Convert<uint32_t>(GetReg32(system, 1));
+    address = Convert<uint32_t>(GetArg32(args, 1));
 
     ret = QueryPhysicalAddress64From32(system, std::addressof(out_info), address);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
     auto out_info_scatter = Convert<std::array<uint32_t, 4>>(out_info);
-    SetReg32(system, 1, out_info_scatter[0]);
-    SetReg32(system, 2, out_info_scatter[1]);
-    SetReg32(system, 3, out_info_scatter[2]);
-    SetReg32(system, 4, out_info_scatter[3]);
+    SetArg32(args, 1, out_info_scatter[0]);
+    SetArg32(args, 2, out_info_scatter[1]);
+    SetArg32(args, 3, out_info_scatter[2]);
+    SetArg32(args, 4, out_info_scatter[3]);
 }
 
-static void SvcWrap_QueryIoMapping64From32(Core::System& system) {
+static void SvcWrap_QueryIoMapping64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t out_address{};
@@ -1284,19 +1284,19 @@ static void SvcWrap_QueryIoMapping64From32(Core::System& system) {
     uint32_t size{};
 
     std::array<uint32_t, 2> physical_address_gather{};
-    physical_address_gather[0] = GetReg32(system, 2);
-    physical_address_gather[1] = GetReg32(system, 3);
+    physical_address_gather[0] = GetArg32(args, 2);
+    physical_address_gather[1] = GetArg32(args, 3);
     physical_address = Convert<uint64_t>(physical_address_gather);
-    size = Convert<uint32_t>(GetReg32(system, 0));
+    size = Convert<uint32_t>(GetArg32(args, 0));
 
     ret = QueryIoMapping64From32(system, std::addressof(out_address), std::addressof(out_size), physical_address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_address));
-    SetReg32(system, 2, Convert<uint32_t>(out_size));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_address));
+    SetArg32(args, 2, Convert<uint32_t>(out_size));
 }
 
-static void SvcWrap_CreateDeviceAddressSpace64From32(Core::System& system) {
+static void SvcWrap_CreateDeviceAddressSpace64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
@@ -1304,49 +1304,49 @@ static void SvcWrap_CreateDeviceAddressSpace64From32(Core::System& system) {
     uint64_t das_size{};
 
     std::array<uint32_t, 2> das_address_gather{};
-    das_address_gather[0] = GetReg32(system, 2);
-    das_address_gather[1] = GetReg32(system, 3);
+    das_address_gather[0] = GetArg32(args, 2);
+    das_address_gather[1] = GetArg32(args, 3);
     das_address = Convert<uint64_t>(das_address_gather);
     std::array<uint32_t, 2> das_size_gather{};
-    das_size_gather[0] = GetReg32(system, 0);
-    das_size_gather[1] = GetReg32(system, 1);
+    das_size_gather[0] = GetArg32(args, 0);
+    das_size_gather[1] = GetArg32(args, 1);
     das_size = Convert<uint64_t>(das_size_gather);
 
     ret = CreateDeviceAddressSpace64From32(system, std::addressof(out_handle), das_address, das_size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_handle));
 }
 
-static void SvcWrap_AttachDeviceAddressSpace64From32(Core::System& system) {
+static void SvcWrap_AttachDeviceAddressSpace64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     DeviceName device_name{};
     Handle das_handle{};
 
-    device_name = Convert<DeviceName>(GetReg32(system, 0));
-    das_handle = Convert<Handle>(GetReg32(system, 1));
+    device_name = Convert<DeviceName>(GetArg32(args, 0));
+    das_handle = Convert<Handle>(GetArg32(args, 1));
 
     ret = AttachDeviceAddressSpace64From32(system, device_name, das_handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_DetachDeviceAddressSpace64From32(Core::System& system) {
+static void SvcWrap_DetachDeviceAddressSpace64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     DeviceName device_name{};
     Handle das_handle{};
 
-    device_name = Convert<DeviceName>(GetReg32(system, 0));
-    das_handle = Convert<Handle>(GetReg32(system, 1));
+    device_name = Convert<DeviceName>(GetArg32(args, 0));
+    das_handle = Convert<Handle>(GetArg32(args, 1));
 
     ret = DetachDeviceAddressSpace64From32(system, device_name, das_handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_MapDeviceAddressSpaceByForce64From32(Core::System& system) {
+static void SvcWrap_MapDeviceAddressSpaceByForce64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle das_handle{};
@@ -1356,25 +1356,25 @@ static void SvcWrap_MapDeviceAddressSpaceByForce64From32(Core::System& system) {
     uint64_t device_address{};
     uint32_t option{};
 
-    das_handle = Convert<Handle>(GetReg32(system, 0));
-    process_handle = Convert<Handle>(GetReg32(system, 1));
+    das_handle = Convert<Handle>(GetArg32(args, 0));
+    process_handle = Convert<Handle>(GetArg32(args, 1));
     std::array<uint32_t, 2> process_address_gather{};
-    process_address_gather[0] = GetReg32(system, 2);
-    process_address_gather[1] = GetReg32(system, 3);
+    process_address_gather[0] = GetArg32(args, 2);
+    process_address_gather[1] = GetArg32(args, 3);
     process_address = Convert<uint64_t>(process_address_gather);
-    size = Convert<uint32_t>(GetReg32(system, 4));
+    size = Convert<uint32_t>(GetArg32(args, 4));
     std::array<uint32_t, 2> device_address_gather{};
-    device_address_gather[0] = GetReg32(system, 5);
-    device_address_gather[1] = GetReg32(system, 6);
+    device_address_gather[0] = GetArg32(args, 5);
+    device_address_gather[1] = GetArg32(args, 6);
     device_address = Convert<uint64_t>(device_address_gather);
-    option = Convert<uint32_t>(GetReg32(system, 7));
+    option = Convert<uint32_t>(GetArg32(args, 7));
 
     ret = MapDeviceAddressSpaceByForce64From32(system, das_handle, process_handle, process_address, size, device_address, option);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_MapDeviceAddressSpaceAligned64From32(Core::System& system) {
+static void SvcWrap_MapDeviceAddressSpaceAligned64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle das_handle{};
@@ -1384,25 +1384,25 @@ static void SvcWrap_MapDeviceAddressSpaceAligned64From32(Core::System& system) {
     uint64_t device_address{};
     uint32_t option{};
 
-    das_handle = Convert<Handle>(GetReg32(system, 0));
-    process_handle = Convert<Handle>(GetReg32(system, 1));
+    das_handle = Convert<Handle>(GetArg32(args, 0));
+    process_handle = Convert<Handle>(GetArg32(args, 1));
     std::array<uint32_t, 2> process_address_gather{};
-    process_address_gather[0] = GetReg32(system, 2);
-    process_address_gather[1] = GetReg32(system, 3);
+    process_address_gather[0] = GetArg32(args, 2);
+    process_address_gather[1] = GetArg32(args, 3);
     process_address = Convert<uint64_t>(process_address_gather);
-    size = Convert<uint32_t>(GetReg32(system, 4));
+    size = Convert<uint32_t>(GetArg32(args, 4));
     std::array<uint32_t, 2> device_address_gather{};
-    device_address_gather[0] = GetReg32(system, 5);
-    device_address_gather[1] = GetReg32(system, 6);
+    device_address_gather[0] = GetArg32(args, 5);
+    device_address_gather[1] = GetArg32(args, 6);
     device_address = Convert<uint64_t>(device_address_gather);
-    option = Convert<uint32_t>(GetReg32(system, 7));
+    option = Convert<uint32_t>(GetArg32(args, 7));
 
     ret = MapDeviceAddressSpaceAligned64From32(system, das_handle, process_handle, process_address, size, device_address, option);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_UnmapDeviceAddressSpace64From32(Core::System& system) {
+static void SvcWrap_UnmapDeviceAddressSpace64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle das_handle{};
@@ -1411,145 +1411,145 @@ static void SvcWrap_UnmapDeviceAddressSpace64From32(Core::System& system) {
     uint32_t size{};
     uint64_t device_address{};
 
-    das_handle = Convert<Handle>(GetReg32(system, 0));
-    process_handle = Convert<Handle>(GetReg32(system, 1));
+    das_handle = Convert<Handle>(GetArg32(args, 0));
+    process_handle = Convert<Handle>(GetArg32(args, 1));
     std::array<uint32_t, 2> process_address_gather{};
-    process_address_gather[0] = GetReg32(system, 2);
-    process_address_gather[1] = GetReg32(system, 3);
+    process_address_gather[0] = GetArg32(args, 2);
+    process_address_gather[1] = GetArg32(args, 3);
     process_address = Convert<uint64_t>(process_address_gather);
-    size = Convert<uint32_t>(GetReg32(system, 4));
+    size = Convert<uint32_t>(GetArg32(args, 4));
     std::array<uint32_t, 2> device_address_gather{};
-    device_address_gather[0] = GetReg32(system, 5);
-    device_address_gather[1] = GetReg32(system, 6);
+    device_address_gather[0] = GetArg32(args, 5);
+    device_address_gather[1] = GetArg32(args, 6);
     device_address = Convert<uint64_t>(device_address_gather);
 
     ret = UnmapDeviceAddressSpace64From32(system, das_handle, process_handle, process_address, size, device_address);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_InvalidateProcessDataCache64From32(Core::System& system) {
+static void SvcWrap_InvalidateProcessDataCache64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle process_handle{};
     uint64_t address{};
     uint64_t size{};
 
-    process_handle = Convert<Handle>(GetReg32(system, 0));
+    process_handle = Convert<Handle>(GetArg32(args, 0));
     std::array<uint32_t, 2> address_gather{};
-    address_gather[0] = GetReg32(system, 2);
-    address_gather[1] = GetReg32(system, 3);
+    address_gather[0] = GetArg32(args, 2);
+    address_gather[1] = GetArg32(args, 3);
     address = Convert<uint64_t>(address_gather);
     std::array<uint32_t, 2> size_gather{};
-    size_gather[0] = GetReg32(system, 1);
-    size_gather[1] = GetReg32(system, 4);
+    size_gather[0] = GetArg32(args, 1);
+    size_gather[1] = GetArg32(args, 4);
     size = Convert<uint64_t>(size_gather);
 
     ret = InvalidateProcessDataCache64From32(system, process_handle, address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_StoreProcessDataCache64From32(Core::System& system) {
+static void SvcWrap_StoreProcessDataCache64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle process_handle{};
     uint64_t address{};
     uint64_t size{};
 
-    process_handle = Convert<Handle>(GetReg32(system, 0));
+    process_handle = Convert<Handle>(GetArg32(args, 0));
     std::array<uint32_t, 2> address_gather{};
-    address_gather[0] = GetReg32(system, 2);
-    address_gather[1] = GetReg32(system, 3);
+    address_gather[0] = GetArg32(args, 2);
+    address_gather[1] = GetArg32(args, 3);
     address = Convert<uint64_t>(address_gather);
     std::array<uint32_t, 2> size_gather{};
-    size_gather[0] = GetReg32(system, 1);
-    size_gather[1] = GetReg32(system, 4);
+    size_gather[0] = GetArg32(args, 1);
+    size_gather[1] = GetArg32(args, 4);
     size = Convert<uint64_t>(size_gather);
 
     ret = StoreProcessDataCache64From32(system, process_handle, address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_FlushProcessDataCache64From32(Core::System& system) {
+static void SvcWrap_FlushProcessDataCache64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle process_handle{};
     uint64_t address{};
     uint64_t size{};
 
-    process_handle = Convert<Handle>(GetReg32(system, 0));
+    process_handle = Convert<Handle>(GetArg32(args, 0));
     std::array<uint32_t, 2> address_gather{};
-    address_gather[0] = GetReg32(system, 2);
-    address_gather[1] = GetReg32(system, 3);
+    address_gather[0] = GetArg32(args, 2);
+    address_gather[1] = GetArg32(args, 3);
     address = Convert<uint64_t>(address_gather);
     std::array<uint32_t, 2> size_gather{};
-    size_gather[0] = GetReg32(system, 1);
-    size_gather[1] = GetReg32(system, 4);
+    size_gather[0] = GetArg32(args, 1);
+    size_gather[1] = GetArg32(args, 4);
     size = Convert<uint64_t>(size_gather);
 
     ret = FlushProcessDataCache64From32(system, process_handle, address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_DebugActiveProcess64From32(Core::System& system) {
+static void SvcWrap_DebugActiveProcess64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
     uint64_t process_id{};
 
     std::array<uint32_t, 2> process_id_gather{};
-    process_id_gather[0] = GetReg32(system, 2);
-    process_id_gather[1] = GetReg32(system, 3);
+    process_id_gather[0] = GetArg32(args, 2);
+    process_id_gather[1] = GetArg32(args, 3);
     process_id = Convert<uint64_t>(process_id_gather);
 
     ret = DebugActiveProcess64From32(system, std::addressof(out_handle), process_id);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_handle));
 }
 
-static void SvcWrap_BreakDebugProcess64From32(Core::System& system) {
+static void SvcWrap_BreakDebugProcess64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle debug_handle{};
 
-    debug_handle = Convert<Handle>(GetReg32(system, 0));
+    debug_handle = Convert<Handle>(GetArg32(args, 0));
 
     ret = BreakDebugProcess64From32(system, debug_handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_TerminateDebugProcess64From32(Core::System& system) {
+static void SvcWrap_TerminateDebugProcess64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle debug_handle{};
 
-    debug_handle = Convert<Handle>(GetReg32(system, 0));
+    debug_handle = Convert<Handle>(GetArg32(args, 0));
 
     ret = TerminateDebugProcess64From32(system, debug_handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_GetDebugEvent64From32(Core::System& system) {
+static void SvcWrap_GetDebugEvent64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t out_info{};
     Handle debug_handle{};
 
-    out_info = Convert<uint32_t>(GetReg32(system, 0));
-    debug_handle = Convert<Handle>(GetReg32(system, 1));
+    out_info = Convert<uint32_t>(GetArg32(args, 0));
+    debug_handle = Convert<Handle>(GetArg32(args, 1));
 
     ret = GetDebugEvent64From32(system, out_info, debug_handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_ContinueDebugEvent64From32(Core::System& system) {
+static void SvcWrap_ContinueDebugEvent64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle debug_handle{};
@@ -1557,33 +1557,33 @@ static void SvcWrap_ContinueDebugEvent64From32(Core::System& system) {
     uint32_t thread_ids{};
     int32_t num_thread_ids{};
 
-    debug_handle = Convert<Handle>(GetReg32(system, 0));
-    flags = Convert<uint32_t>(GetReg32(system, 1));
-    thread_ids = Convert<uint32_t>(GetReg32(system, 2));
-    num_thread_ids = Convert<int32_t>(GetReg32(system, 3));
+    debug_handle = Convert<Handle>(GetArg32(args, 0));
+    flags = Convert<uint32_t>(GetArg32(args, 1));
+    thread_ids = Convert<uint32_t>(GetArg32(args, 2));
+    num_thread_ids = Convert<int32_t>(GetArg32(args, 3));
 
     ret = ContinueDebugEvent64From32(system, debug_handle, flags, thread_ids, num_thread_ids);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_GetProcessList64From32(Core::System& system) {
+static void SvcWrap_GetProcessList64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int32_t out_num_processes{};
     uint32_t out_process_ids{};
     int32_t max_out_count{};
 
-    out_process_ids = Convert<uint32_t>(GetReg32(system, 1));
-    max_out_count = Convert<int32_t>(GetReg32(system, 2));
+    out_process_ids = Convert<uint32_t>(GetArg32(args, 1));
+    max_out_count = Convert<int32_t>(GetArg32(args, 2));
 
     ret = GetProcessList64From32(system, std::addressof(out_num_processes), out_process_ids, max_out_count);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_num_processes));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_num_processes));
 }
 
-static void SvcWrap_GetThreadList64From32(Core::System& system) {
+static void SvcWrap_GetThreadList64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int32_t out_num_threads{};
@@ -1591,17 +1591,17 @@ static void SvcWrap_GetThreadList64From32(Core::System& system) {
     int32_t max_out_count{};
     Handle debug_handle{};
 
-    out_thread_ids = Convert<uint32_t>(GetReg32(system, 1));
-    max_out_count = Convert<int32_t>(GetReg32(system, 2));
-    debug_handle = Convert<Handle>(GetReg32(system, 3));
+    out_thread_ids = Convert<uint32_t>(GetArg32(args, 1));
+    max_out_count = Convert<int32_t>(GetArg32(args, 2));
+    debug_handle = Convert<Handle>(GetArg32(args, 3));
 
     ret = GetThreadList64From32(system, std::addressof(out_num_threads), out_thread_ids, max_out_count, debug_handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_num_threads));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_num_threads));
 }
 
-static void SvcWrap_GetDebugThreadContext64From32(Core::System& system) {
+static void SvcWrap_GetDebugThreadContext64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t out_context{};
@@ -1609,20 +1609,20 @@ static void SvcWrap_GetDebugThreadContext64From32(Core::System& system) {
     uint64_t thread_id{};
     uint32_t context_flags{};
 
-    out_context = Convert<uint32_t>(GetReg32(system, 0));
-    debug_handle = Convert<Handle>(GetReg32(system, 1));
+    out_context = Convert<uint32_t>(GetArg32(args, 0));
+    debug_handle = Convert<Handle>(GetArg32(args, 1));
     std::array<uint32_t, 2> thread_id_gather{};
-    thread_id_gather[0] = GetReg32(system, 2);
-    thread_id_gather[1] = GetReg32(system, 3);
+    thread_id_gather[0] = GetArg32(args, 2);
+    thread_id_gather[1] = GetArg32(args, 3);
     thread_id = Convert<uint64_t>(thread_id_gather);
-    context_flags = Convert<uint32_t>(GetReg32(system, 4));
+    context_flags = Convert<uint32_t>(GetArg32(args, 4));
 
     ret = GetDebugThreadContext64From32(system, out_context, debug_handle, thread_id, context_flags);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_SetDebugThreadContext64From32(Core::System& system) {
+static void SvcWrap_SetDebugThreadContext64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle debug_handle{};
@@ -1630,20 +1630,20 @@ static void SvcWrap_SetDebugThreadContext64From32(Core::System& system) {
     uint32_t context{};
     uint32_t context_flags{};
 
-    debug_handle = Convert<Handle>(GetReg32(system, 0));
+    debug_handle = Convert<Handle>(GetArg32(args, 0));
     std::array<uint32_t, 2> thread_id_gather{};
-    thread_id_gather[0] = GetReg32(system, 2);
-    thread_id_gather[1] = GetReg32(system, 3);
+    thread_id_gather[0] = GetArg32(args, 2);
+    thread_id_gather[1] = GetArg32(args, 3);
     thread_id = Convert<uint64_t>(thread_id_gather);
-    context = Convert<uint32_t>(GetReg32(system, 1));
-    context_flags = Convert<uint32_t>(GetReg32(system, 4));
+    context = Convert<uint32_t>(GetArg32(args, 1));
+    context_flags = Convert<uint32_t>(GetArg32(args, 4));
 
     ret = SetDebugThreadContext64From32(system, debug_handle, thread_id, context, context_flags);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_QueryDebugProcessMemory64From32(Core::System& system) {
+static void SvcWrap_QueryDebugProcessMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     PageInfo out_page_info{};
@@ -1651,17 +1651,17 @@ static void SvcWrap_QueryDebugProcessMemory64From32(Core::System& system) {
     Handle process_handle{};
     uint32_t address{};
 
-    out_memory_info = Convert<uint32_t>(GetReg32(system, 0));
-    process_handle = Convert<Handle>(GetReg32(system, 2));
-    address = Convert<uint32_t>(GetReg32(system, 3));
+    out_memory_info = Convert<uint32_t>(GetArg32(args, 0));
+    process_handle = Convert<Handle>(GetArg32(args, 2));
+    address = Convert<uint32_t>(GetArg32(args, 3));
 
     ret = QueryDebugProcessMemory64From32(system, out_memory_info, std::addressof(out_page_info), process_handle, address);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_page_info));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_page_info));
 }
 
-static void SvcWrap_ReadDebugProcessMemory64From32(Core::System& system) {
+static void SvcWrap_ReadDebugProcessMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t buffer{};
@@ -1669,17 +1669,17 @@ static void SvcWrap_ReadDebugProcessMemory64From32(Core::System& system) {
     uint32_t address{};
     uint32_t size{};
 
-    buffer = Convert<uint32_t>(GetReg32(system, 0));
-    debug_handle = Convert<Handle>(GetReg32(system, 1));
-    address = Convert<uint32_t>(GetReg32(system, 2));
-    size = Convert<uint32_t>(GetReg32(system, 3));
+    buffer = Convert<uint32_t>(GetArg32(args, 0));
+    debug_handle = Convert<Handle>(GetArg32(args, 1));
+    address = Convert<uint32_t>(GetArg32(args, 2));
+    size = Convert<uint32_t>(GetArg32(args, 3));
 
     ret = ReadDebugProcessMemory64From32(system, buffer, debug_handle, address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_WriteDebugProcessMemory64From32(Core::System& system) {
+static void SvcWrap_WriteDebugProcessMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle debug_handle{};
@@ -1687,39 +1687,39 @@ static void SvcWrap_WriteDebugProcessMemory64From32(Core::System& system) {
     uint32_t address{};
     uint32_t size{};
 
-    debug_handle = Convert<Handle>(GetReg32(system, 0));
-    buffer = Convert<uint32_t>(GetReg32(system, 1));
-    address = Convert<uint32_t>(GetReg32(system, 2));
-    size = Convert<uint32_t>(GetReg32(system, 3));
+    debug_handle = Convert<Handle>(GetArg32(args, 0));
+    buffer = Convert<uint32_t>(GetArg32(args, 1));
+    address = Convert<uint32_t>(GetArg32(args, 2));
+    size = Convert<uint32_t>(GetArg32(args, 3));
 
     ret = WriteDebugProcessMemory64From32(system, debug_handle, buffer, address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_SetHardwareBreakPoint64From32(Core::System& system) {
+static void SvcWrap_SetHardwareBreakPoint64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     HardwareBreakPointRegisterName name{};
     uint64_t flags{};
     uint64_t value{};
 
-    name = Convert<HardwareBreakPointRegisterName>(GetReg32(system, 0));
+    name = Convert<HardwareBreakPointRegisterName>(GetArg32(args, 0));
     std::array<uint32_t, 2> flags_gather{};
-    flags_gather[0] = GetReg32(system, 2);
-    flags_gather[1] = GetReg32(system, 3);
+    flags_gather[0] = GetArg32(args, 2);
+    flags_gather[1] = GetArg32(args, 3);
     flags = Convert<uint64_t>(flags_gather);
     std::array<uint32_t, 2> value_gather{};
-    value_gather[0] = GetReg32(system, 1);
-    value_gather[1] = GetReg32(system, 4);
+    value_gather[0] = GetArg32(args, 1);
+    value_gather[1] = GetArg32(args, 4);
     value = Convert<uint64_t>(value_gather);
 
     ret = SetHardwareBreakPoint64From32(system, name, flags, value);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_GetDebugThreadParam64From32(Core::System& system) {
+static void SvcWrap_GetDebugThreadParam64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t out_64{};
@@ -1728,23 +1728,23 @@ static void SvcWrap_GetDebugThreadParam64From32(Core::System& system) {
     uint64_t thread_id{};
     DebugThreadParam param{};
 
-    debug_handle = Convert<Handle>(GetReg32(system, 2));
+    debug_handle = Convert<Handle>(GetArg32(args, 2));
     std::array<uint32_t, 2> thread_id_gather{};
-    thread_id_gather[0] = GetReg32(system, 0);
-    thread_id_gather[1] = GetReg32(system, 1);
+    thread_id_gather[0] = GetArg32(args, 0);
+    thread_id_gather[1] = GetArg32(args, 1);
     thread_id = Convert<uint64_t>(thread_id_gather);
-    param = Convert<DebugThreadParam>(GetReg32(system, 3));
+    param = Convert<DebugThreadParam>(GetArg32(args, 3));
 
     ret = GetDebugThreadParam64From32(system, std::addressof(out_64), std::addressof(out_32), debug_handle, thread_id, param);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
     auto out_64_scatter = Convert<std::array<uint32_t, 2>>(out_64);
-    SetReg32(system, 1, out_64_scatter[0]);
-    SetReg32(system, 2, out_64_scatter[1]);
-    SetReg32(system, 3, Convert<uint32_t>(out_32));
+    SetArg32(args, 1, out_64_scatter[0]);
+    SetArg32(args, 2, out_64_scatter[1]);
+    SetArg32(args, 3, Convert<uint32_t>(out_32));
 }
 
-static void SvcWrap_GetSystemInfo64From32(Core::System& system) {
+static void SvcWrap_GetSystemInfo64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t out{};
@@ -1752,22 +1752,22 @@ static void SvcWrap_GetSystemInfo64From32(Core::System& system) {
     Handle handle{};
     uint64_t info_subtype{};
 
-    info_type = Convert<SystemInfoType>(GetReg32(system, 1));
-    handle = Convert<Handle>(GetReg32(system, 2));
+    info_type = Convert<SystemInfoType>(GetArg32(args, 1));
+    handle = Convert<Handle>(GetArg32(args, 2));
     std::array<uint32_t, 2> info_subtype_gather{};
-    info_subtype_gather[0] = GetReg32(system, 0);
-    info_subtype_gather[1] = GetReg32(system, 3);
+    info_subtype_gather[0] = GetArg32(args, 0);
+    info_subtype_gather[1] = GetArg32(args, 3);
     info_subtype = Convert<uint64_t>(info_subtype_gather);
 
     ret = GetSystemInfo64From32(system, std::addressof(out), info_type, handle, info_subtype);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
     auto out_scatter = Convert<std::array<uint32_t, 2>>(out);
-    SetReg32(system, 1, out_scatter[0]);
-    SetReg32(system, 2, out_scatter[1]);
+    SetArg32(args, 1, out_scatter[0]);
+    SetArg32(args, 2, out_scatter[1]);
 }
 
-static void SvcWrap_CreatePort64From32(Core::System& system) {
+static void SvcWrap_CreatePort64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_server_handle{};
@@ -1776,48 +1776,48 @@ static void SvcWrap_CreatePort64From32(Core::System& system) {
     bool is_light{};
     uint32_t name{};
 
-    max_sessions = Convert<int32_t>(GetReg32(system, 2));
-    is_light = Convert<bool>(GetReg32(system, 3));
-    name = Convert<uint32_t>(GetReg32(system, 0));
+    max_sessions = Convert<int32_t>(GetArg32(args, 2));
+    is_light = Convert<bool>(GetArg32(args, 3));
+    name = Convert<uint32_t>(GetArg32(args, 0));
 
     ret = CreatePort64From32(system, std::addressof(out_server_handle), std::addressof(out_client_handle), max_sessions, is_light, name);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_server_handle));
-    SetReg32(system, 2, Convert<uint32_t>(out_client_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_server_handle));
+    SetArg32(args, 2, Convert<uint32_t>(out_client_handle));
 }
 
-static void SvcWrap_ManageNamedPort64From32(Core::System& system) {
+static void SvcWrap_ManageNamedPort64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_server_handle{};
     uint32_t name{};
     int32_t max_sessions{};
 
-    name = Convert<uint32_t>(GetReg32(system, 1));
-    max_sessions = Convert<int32_t>(GetReg32(system, 2));
+    name = Convert<uint32_t>(GetArg32(args, 1));
+    max_sessions = Convert<int32_t>(GetArg32(args, 2));
 
     ret = ManageNamedPort64From32(system, std::addressof(out_server_handle), name, max_sessions);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_server_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_server_handle));
 }
 
-static void SvcWrap_ConnectToPort64From32(Core::System& system) {
+static void SvcWrap_ConnectToPort64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
     Handle port{};
 
-    port = Convert<Handle>(GetReg32(system, 1));
+    port = Convert<Handle>(GetArg32(args, 1));
 
     ret = ConnectToPort64From32(system, std::addressof(out_handle), port);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_handle));
 }
 
-static void SvcWrap_SetProcessMemoryPermission64From32(Core::System& system) {
+static void SvcWrap_SetProcessMemoryPermission64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle process_handle{};
@@ -1825,23 +1825,23 @@ static void SvcWrap_SetProcessMemoryPermission64From32(Core::System& system) {
     uint64_t size{};
     MemoryPermission perm{};
 
-    process_handle = Convert<Handle>(GetReg32(system, 0));
+    process_handle = Convert<Handle>(GetArg32(args, 0));
     std::array<uint32_t, 2> address_gather{};
-    address_gather[0] = GetReg32(system, 2);
-    address_gather[1] = GetReg32(system, 3);
+    address_gather[0] = GetArg32(args, 2);
+    address_gather[1] = GetArg32(args, 3);
     address = Convert<uint64_t>(address_gather);
     std::array<uint32_t, 2> size_gather{};
-    size_gather[0] = GetReg32(system, 1);
-    size_gather[1] = GetReg32(system, 4);
+    size_gather[0] = GetArg32(args, 1);
+    size_gather[1] = GetArg32(args, 4);
     size = Convert<uint64_t>(size_gather);
-    perm = Convert<MemoryPermission>(GetReg32(system, 5));
+    perm = Convert<MemoryPermission>(GetArg32(args, 5));
 
     ret = SetProcessMemoryPermission64From32(system, process_handle, address, size, perm);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_MapProcessMemory64From32(Core::System& system) {
+static void SvcWrap_MapProcessMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t dst_address{};
@@ -1849,20 +1849,20 @@ static void SvcWrap_MapProcessMemory64From32(Core::System& system) {
     uint64_t src_address{};
     uint32_t size{};
 
-    dst_address = Convert<uint32_t>(GetReg32(system, 0));
-    process_handle = Convert<Handle>(GetReg32(system, 1));
+    dst_address = Convert<uint32_t>(GetArg32(args, 0));
+    process_handle = Convert<Handle>(GetArg32(args, 1));
     std::array<uint32_t, 2> src_address_gather{};
-    src_address_gather[0] = GetReg32(system, 2);
-    src_address_gather[1] = GetReg32(system, 3);
+    src_address_gather[0] = GetArg32(args, 2);
+    src_address_gather[1] = GetArg32(args, 3);
     src_address = Convert<uint64_t>(src_address_gather);
-    size = Convert<uint32_t>(GetReg32(system, 4));
+    size = Convert<uint32_t>(GetArg32(args, 4));
 
     ret = MapProcessMemory64From32(system, dst_address, process_handle, src_address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_UnmapProcessMemory64From32(Core::System& system) {
+static void SvcWrap_UnmapProcessMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t dst_address{};
@@ -1870,20 +1870,20 @@ static void SvcWrap_UnmapProcessMemory64From32(Core::System& system) {
     uint64_t src_address{};
     uint32_t size{};
 
-    dst_address = Convert<uint32_t>(GetReg32(system, 0));
-    process_handle = Convert<Handle>(GetReg32(system, 1));
+    dst_address = Convert<uint32_t>(GetArg32(args, 0));
+    process_handle = Convert<Handle>(GetArg32(args, 1));
     std::array<uint32_t, 2> src_address_gather{};
-    src_address_gather[0] = GetReg32(system, 2);
-    src_address_gather[1] = GetReg32(system, 3);
+    src_address_gather[0] = GetArg32(args, 2);
+    src_address_gather[1] = GetArg32(args, 3);
     src_address = Convert<uint64_t>(src_address_gather);
-    size = Convert<uint32_t>(GetReg32(system, 4));
+    size = Convert<uint32_t>(GetArg32(args, 4));
 
     ret = UnmapProcessMemory64From32(system, dst_address, process_handle, src_address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_QueryProcessMemory64From32(Core::System& system) {
+static void SvcWrap_QueryProcessMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     PageInfo out_page_info{};
@@ -1891,20 +1891,20 @@ static void SvcWrap_QueryProcessMemory64From32(Core::System& system) {
     Handle process_handle{};
     uint64_t address{};
 
-    out_memory_info = Convert<uint32_t>(GetReg32(system, 0));
-    process_handle = Convert<Handle>(GetReg32(system, 2));
+    out_memory_info = Convert<uint32_t>(GetArg32(args, 0));
+    process_handle = Convert<Handle>(GetArg32(args, 2));
     std::array<uint32_t, 2> address_gather{};
-    address_gather[0] = GetReg32(system, 1);
-    address_gather[1] = GetReg32(system, 3);
+    address_gather[0] = GetArg32(args, 1);
+    address_gather[1] = GetArg32(args, 3);
     address = Convert<uint64_t>(address_gather);
 
     ret = QueryProcessMemory64From32(system, out_memory_info, std::addressof(out_page_info), process_handle, address);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_page_info));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_page_info));
 }
 
-static void SvcWrap_MapProcessCodeMemory64From32(Core::System& system) {
+static void SvcWrap_MapProcessCodeMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle process_handle{};
@@ -1912,26 +1912,26 @@ static void SvcWrap_MapProcessCodeMemory64From32(Core::System& system) {
     uint64_t src_address{};
     uint64_t size{};
 
-    process_handle = Convert<Handle>(GetReg32(system, 0));
+    process_handle = Convert<Handle>(GetArg32(args, 0));
     std::array<uint32_t, 2> dst_address_gather{};
-    dst_address_gather[0] = GetReg32(system, 2);
-    dst_address_gather[1] = GetReg32(system, 3);
+    dst_address_gather[0] = GetArg32(args, 2);
+    dst_address_gather[1] = GetArg32(args, 3);
     dst_address = Convert<uint64_t>(dst_address_gather);
     std::array<uint32_t, 2> src_address_gather{};
-    src_address_gather[0] = GetReg32(system, 1);
-    src_address_gather[1] = GetReg32(system, 4);
+    src_address_gather[0] = GetArg32(args, 1);
+    src_address_gather[1] = GetArg32(args, 4);
     src_address = Convert<uint64_t>(src_address_gather);
     std::array<uint32_t, 2> size_gather{};
-    size_gather[0] = GetReg32(system, 5);
-    size_gather[1] = GetReg32(system, 6);
+    size_gather[0] = GetArg32(args, 5);
+    size_gather[1] = GetArg32(args, 6);
     size = Convert<uint64_t>(size_gather);
 
     ret = MapProcessCodeMemory64From32(system, process_handle, dst_address, src_address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_UnmapProcessCodeMemory64From32(Core::System& system) {
+static void SvcWrap_UnmapProcessCodeMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle process_handle{};
@@ -1939,26 +1939,26 @@ static void SvcWrap_UnmapProcessCodeMemory64From32(Core::System& system) {
     uint64_t src_address{};
     uint64_t size{};
 
-    process_handle = Convert<Handle>(GetReg32(system, 0));
+    process_handle = Convert<Handle>(GetArg32(args, 0));
     std::array<uint32_t, 2> dst_address_gather{};
-    dst_address_gather[0] = GetReg32(system, 2);
-    dst_address_gather[1] = GetReg32(system, 3);
+    dst_address_gather[0] = GetArg32(args, 2);
+    dst_address_gather[1] = GetArg32(args, 3);
     dst_address = Convert<uint64_t>(dst_address_gather);
     std::array<uint32_t, 2> src_address_gather{};
-    src_address_gather[0] = GetReg32(system, 1);
-    src_address_gather[1] = GetReg32(system, 4);
+    src_address_gather[0] = GetArg32(args, 1);
+    src_address_gather[1] = GetArg32(args, 4);
     src_address = Convert<uint64_t>(src_address_gather);
     std::array<uint32_t, 2> size_gather{};
-    size_gather[0] = GetReg32(system, 5);
-    size_gather[1] = GetReg32(system, 6);
+    size_gather[0] = GetArg32(args, 5);
+    size_gather[1] = GetArg32(args, 6);
     size = Convert<uint64_t>(size_gather);
 
     ret = UnmapProcessCodeMemory64From32(system, process_handle, dst_address, src_address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_CreateProcess64From32(Core::System& system) {
+static void SvcWrap_CreateProcess64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
@@ -1966,17 +1966,17 @@ static void SvcWrap_CreateProcess64From32(Core::System& system) {
     uint32_t caps{};
     int32_t num_caps{};
 
-    parameters = Convert<uint32_t>(GetReg32(system, 1));
-    caps = Convert<uint32_t>(GetReg32(system, 2));
-    num_caps = Convert<int32_t>(GetReg32(system, 3));
+    parameters = Convert<uint32_t>(GetArg32(args, 1));
+    caps = Convert<uint32_t>(GetArg32(args, 2));
+    num_caps = Convert<int32_t>(GetArg32(args, 3));
 
     ret = CreateProcess64From32(system, std::addressof(out_handle), parameters, caps, num_caps);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_handle));
 }
 
-static void SvcWrap_StartProcess64From32(Core::System& system) {
+static void SvcWrap_StartProcess64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle process_handle{};
@@ -1984,138 +1984,138 @@ static void SvcWrap_StartProcess64From32(Core::System& system) {
     int32_t core_id{};
     uint64_t main_thread_stack_size{};
 
-    process_handle = Convert<Handle>(GetReg32(system, 0));
-    priority = Convert<int32_t>(GetReg32(system, 1));
-    core_id = Convert<int32_t>(GetReg32(system, 2));
+    process_handle = Convert<Handle>(GetArg32(args, 0));
+    priority = Convert<int32_t>(GetArg32(args, 1));
+    core_id = Convert<int32_t>(GetArg32(args, 2));
     std::array<uint32_t, 2> main_thread_stack_size_gather{};
-    main_thread_stack_size_gather[0] = GetReg32(system, 3);
-    main_thread_stack_size_gather[1] = GetReg32(system, 4);
+    main_thread_stack_size_gather[0] = GetArg32(args, 3);
+    main_thread_stack_size_gather[1] = GetArg32(args, 4);
     main_thread_stack_size = Convert<uint64_t>(main_thread_stack_size_gather);
 
     ret = StartProcess64From32(system, process_handle, priority, core_id, main_thread_stack_size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_TerminateProcess64From32(Core::System& system) {
+static void SvcWrap_TerminateProcess64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle process_handle{};
 
-    process_handle = Convert<Handle>(GetReg32(system, 0));
+    process_handle = Convert<Handle>(GetArg32(args, 0));
 
     ret = TerminateProcess64From32(system, process_handle);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_GetProcessInfo64From32(Core::System& system) {
+static void SvcWrap_GetProcessInfo64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int64_t out_info{};
     Handle process_handle{};
     ProcessInfoType info_type{};
 
-    process_handle = Convert<Handle>(GetReg32(system, 1));
-    info_type = Convert<ProcessInfoType>(GetReg32(system, 2));
+    process_handle = Convert<Handle>(GetArg32(args, 1));
+    info_type = Convert<ProcessInfoType>(GetArg32(args, 2));
 
     ret = GetProcessInfo64From32(system, std::addressof(out_info), process_handle, info_type);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
     auto out_info_scatter = Convert<std::array<uint32_t, 2>>(out_info);
-    SetReg32(system, 1, out_info_scatter[0]);
-    SetReg32(system, 2, out_info_scatter[1]);
+    SetArg32(args, 1, out_info_scatter[0]);
+    SetArg32(args, 2, out_info_scatter[1]);
 }
 
-static void SvcWrap_CreateResourceLimit64From32(Core::System& system) {
+static void SvcWrap_CreateResourceLimit64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
 
     ret = CreateResourceLimit64From32(system, std::addressof(out_handle));
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
-    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 1, Convert<uint32_t>(out_handle));
 }
 
-static void SvcWrap_SetResourceLimitLimitValue64From32(Core::System& system) {
+static void SvcWrap_SetResourceLimitLimitValue64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle resource_limit_handle{};
     LimitableResource which{};
     int64_t limit_value{};
 
-    resource_limit_handle = Convert<Handle>(GetReg32(system, 0));
-    which = Convert<LimitableResource>(GetReg32(system, 1));
+    resource_limit_handle = Convert<Handle>(GetArg32(args, 0));
+    which = Convert<LimitableResource>(GetArg32(args, 1));
     std::array<uint32_t, 2> limit_value_gather{};
-    limit_value_gather[0] = GetReg32(system, 2);
-    limit_value_gather[1] = GetReg32(system, 3);
+    limit_value_gather[0] = GetArg32(args, 2);
+    limit_value_gather[1] = GetArg32(args, 3);
     limit_value = Convert<int64_t>(limit_value_gather);
 
     ret = SetResourceLimitLimitValue64From32(system, resource_limit_handle, which, limit_value);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_MapInsecureMemory64From32(Core::System& system) {
+static void SvcWrap_MapInsecureMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t address{};
     uint32_t size{};
 
-    address = Convert<uint32_t>(GetReg32(system, 0));
-    size = Convert<uint32_t>(GetReg32(system, 1));
+    address = Convert<uint32_t>(GetArg32(args, 0));
+    size = Convert<uint32_t>(GetArg32(args, 1));
 
     ret = MapInsecureMemory64From32(system, address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_UnmapInsecureMemory64From32(Core::System& system) {
+static void SvcWrap_UnmapInsecureMemory64From32(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t address{};
     uint32_t size{};
 
-    address = Convert<uint32_t>(GetReg32(system, 0));
-    size = Convert<uint32_t>(GetReg32(system, 1));
+    address = Convert<uint32_t>(GetArg32(args, 0));
+    size = Convert<uint32_t>(GetArg32(args, 1));
 
     ret = UnmapInsecureMemory64From32(system, address, size);
 
-    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetArg32(args, 0, Convert<uint32_t>(ret));
 }
 
-static void SvcWrap_SetHeapSize64(Core::System& system) {
+static void SvcWrap_SetHeapSize64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t out_address{};
     uint64_t size{};
 
-    size = Convert<uint64_t>(GetReg64(system, 1));
+    size = Convert<uint64_t>(GetArg64(args, 1));
 
     ret = SetHeapSize64(system, std::addressof(out_address), size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_address));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_address));
 }
 
-static void SvcWrap_SetMemoryPermission64(Core::System& system) {
+static void SvcWrap_SetMemoryPermission64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t address{};
     uint64_t size{};
     MemoryPermission perm{};
 
-    address = Convert<uint64_t>(GetReg64(system, 0));
-    size = Convert<uint64_t>(GetReg64(system, 1));
-    perm = Convert<MemoryPermission>(GetReg64(system, 2));
+    address = Convert<uint64_t>(GetArg64(args, 0));
+    size = Convert<uint64_t>(GetArg64(args, 1));
+    perm = Convert<MemoryPermission>(GetArg64(args, 2));
 
     ret = SetMemoryPermission64(system, address, size, perm);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_SetMemoryAttribute64(Core::System& system) {
+static void SvcWrap_SetMemoryAttribute64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t address{};
@@ -2123,69 +2123,69 @@ static void SvcWrap_SetMemoryAttribute64(Core::System& system) {
     uint32_t mask{};
     uint32_t attr{};
 
-    address = Convert<uint64_t>(GetReg64(system, 0));
-    size = Convert<uint64_t>(GetReg64(system, 1));
-    mask = Convert<uint32_t>(GetReg64(system, 2));
-    attr = Convert<uint32_t>(GetReg64(system, 3));
+    address = Convert<uint64_t>(GetArg64(args, 0));
+    size = Convert<uint64_t>(GetArg64(args, 1));
+    mask = Convert<uint32_t>(GetArg64(args, 2));
+    attr = Convert<uint32_t>(GetArg64(args, 3));
 
     ret = SetMemoryAttribute64(system, address, size, mask, attr);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_MapMemory64(Core::System& system) {
+static void SvcWrap_MapMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t dst_address{};
     uint64_t src_address{};
     uint64_t size{};
 
-    dst_address = Convert<uint64_t>(GetReg64(system, 0));
-    src_address = Convert<uint64_t>(GetReg64(system, 1));
-    size = Convert<uint64_t>(GetReg64(system, 2));
+    dst_address = Convert<uint64_t>(GetArg64(args, 0));
+    src_address = Convert<uint64_t>(GetArg64(args, 1));
+    size = Convert<uint64_t>(GetArg64(args, 2));
 
     ret = MapMemory64(system, dst_address, src_address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_UnmapMemory64(Core::System& system) {
+static void SvcWrap_UnmapMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t dst_address{};
     uint64_t src_address{};
     uint64_t size{};
 
-    dst_address = Convert<uint64_t>(GetReg64(system, 0));
-    src_address = Convert<uint64_t>(GetReg64(system, 1));
-    size = Convert<uint64_t>(GetReg64(system, 2));
+    dst_address = Convert<uint64_t>(GetArg64(args, 0));
+    src_address = Convert<uint64_t>(GetArg64(args, 1));
+    size = Convert<uint64_t>(GetArg64(args, 2));
 
     ret = UnmapMemory64(system, dst_address, src_address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_QueryMemory64(Core::System& system) {
+static void SvcWrap_QueryMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     PageInfo out_page_info{};
     uint64_t out_memory_info{};
     uint64_t address{};
 
-    out_memory_info = Convert<uint64_t>(GetReg64(system, 0));
-    address = Convert<uint64_t>(GetReg64(system, 2));
+    out_memory_info = Convert<uint64_t>(GetArg64(args, 0));
+    address = Convert<uint64_t>(GetArg64(args, 2));
 
     ret = QueryMemory64(system, out_memory_info, std::addressof(out_page_info), address);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_page_info));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_page_info));
 }
 
-static void SvcWrap_ExitProcess64(Core::System& system) {
+static void SvcWrap_ExitProcess64(Core::System& system, std::span<uint64_t, 8> args) {
     ExitProcess64(system);
 }
 
-static void SvcWrap_CreateThread64(Core::System& system) {
+static void SvcWrap_CreateThread64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
@@ -2195,135 +2195,135 @@ static void SvcWrap_CreateThread64(Core::System& system) {
     int32_t priority{};
     int32_t core_id{};
 
-    func = Convert<uint64_t>(GetReg64(system, 1));
-    arg = Convert<uint64_t>(GetReg64(system, 2));
-    stack_bottom = Convert<uint64_t>(GetReg64(system, 3));
-    priority = Convert<int32_t>(GetReg64(system, 4));
-    core_id = Convert<int32_t>(GetReg64(system, 5));
+    func = Convert<uint64_t>(GetArg64(args, 1));
+    arg = Convert<uint64_t>(GetArg64(args, 2));
+    stack_bottom = Convert<uint64_t>(GetArg64(args, 3));
+    priority = Convert<int32_t>(GetArg64(args, 4));
+    core_id = Convert<int32_t>(GetArg64(args, 5));
 
     ret = CreateThread64(system, std::addressof(out_handle), func, arg, stack_bottom, priority, core_id);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_handle));
 }
 
-static void SvcWrap_StartThread64(Core::System& system) {
+static void SvcWrap_StartThread64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle thread_handle{};
 
-    thread_handle = Convert<Handle>(GetReg64(system, 0));
+    thread_handle = Convert<Handle>(GetArg64(args, 0));
 
     ret = StartThread64(system, thread_handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_ExitThread64(Core::System& system) {
+static void SvcWrap_ExitThread64(Core::System& system, std::span<uint64_t, 8> args) {
     ExitThread64(system);
 }
 
-static void SvcWrap_SleepThread64(Core::System& system) {
+static void SvcWrap_SleepThread64(Core::System& system, std::span<uint64_t, 8> args) {
     int64_t ns{};
 
-    ns = Convert<int64_t>(GetReg64(system, 0));
+    ns = Convert<int64_t>(GetArg64(args, 0));
 
     SleepThread64(system, ns);
 }
 
-static void SvcWrap_GetThreadPriority64(Core::System& system) {
+static void SvcWrap_GetThreadPriority64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int32_t out_priority{};
     Handle thread_handle{};
 
-    thread_handle = Convert<Handle>(GetReg64(system, 1));
+    thread_handle = Convert<Handle>(GetArg64(args, 1));
 
     ret = GetThreadPriority64(system, std::addressof(out_priority), thread_handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_priority));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_priority));
 }
 
-static void SvcWrap_SetThreadPriority64(Core::System& system) {
+static void SvcWrap_SetThreadPriority64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle thread_handle{};
     int32_t priority{};
 
-    thread_handle = Convert<Handle>(GetReg64(system, 0));
-    priority = Convert<int32_t>(GetReg64(system, 1));
+    thread_handle = Convert<Handle>(GetArg64(args, 0));
+    priority = Convert<int32_t>(GetArg64(args, 1));
 
     ret = SetThreadPriority64(system, thread_handle, priority);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_GetThreadCoreMask64(Core::System& system) {
+static void SvcWrap_GetThreadCoreMask64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int32_t out_core_id{};
     uint64_t out_affinity_mask{};
     Handle thread_handle{};
 
-    thread_handle = Convert<Handle>(GetReg64(system, 2));
+    thread_handle = Convert<Handle>(GetArg64(args, 2));
 
     ret = GetThreadCoreMask64(system, std::addressof(out_core_id), std::addressof(out_affinity_mask), thread_handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_core_id));
-    SetReg64(system, 2, Convert<uint64_t>(out_affinity_mask));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_core_id));
+    SetArg64(args, 2, Convert<uint64_t>(out_affinity_mask));
 }
 
-static void SvcWrap_SetThreadCoreMask64(Core::System& system) {
+static void SvcWrap_SetThreadCoreMask64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle thread_handle{};
     int32_t core_id{};
     uint64_t affinity_mask{};
 
-    thread_handle = Convert<Handle>(GetReg64(system, 0));
-    core_id = Convert<int32_t>(GetReg64(system, 1));
-    affinity_mask = Convert<uint64_t>(GetReg64(system, 2));
+    thread_handle = Convert<Handle>(GetArg64(args, 0));
+    core_id = Convert<int32_t>(GetArg64(args, 1));
+    affinity_mask = Convert<uint64_t>(GetArg64(args, 2));
 
     ret = SetThreadCoreMask64(system, thread_handle, core_id, affinity_mask);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_GetCurrentProcessorNumber64(Core::System& system) {
+static void SvcWrap_GetCurrentProcessorNumber64(Core::System& system, std::span<uint64_t, 8> args) {
     int32_t ret{};
 
     ret = GetCurrentProcessorNumber64(system);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_SignalEvent64(Core::System& system) {
+static void SvcWrap_SignalEvent64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle event_handle{};
 
-    event_handle = Convert<Handle>(GetReg64(system, 0));
+    event_handle = Convert<Handle>(GetArg64(args, 0));
 
     ret = SignalEvent64(system, event_handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_ClearEvent64(Core::System& system) {
+static void SvcWrap_ClearEvent64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle event_handle{};
 
-    event_handle = Convert<Handle>(GetReg64(system, 0));
+    event_handle = Convert<Handle>(GetArg64(args, 0));
 
     ret = ClearEvent64(system, event_handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_MapSharedMemory64(Core::System& system) {
+static void SvcWrap_MapSharedMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle shmem_handle{};
@@ -2331,33 +2331,33 @@ static void SvcWrap_MapSharedMemory64(Core::System& system) {
     uint64_t size{};
     MemoryPermission map_perm{};
 
-    shmem_handle = Convert<Handle>(GetReg64(system, 0));
-    address = Convert<uint64_t>(GetReg64(system, 1));
-    size = Convert<uint64_t>(GetReg64(system, 2));
-    map_perm = Convert<MemoryPermission>(GetReg64(system, 3));
+    shmem_handle = Convert<Handle>(GetArg64(args, 0));
+    address = Convert<uint64_t>(GetArg64(args, 1));
+    size = Convert<uint64_t>(GetArg64(args, 2));
+    map_perm = Convert<MemoryPermission>(GetArg64(args, 3));
 
     ret = MapSharedMemory64(system, shmem_handle, address, size, map_perm);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_UnmapSharedMemory64(Core::System& system) {
+static void SvcWrap_UnmapSharedMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle shmem_handle{};
     uint64_t address{};
     uint64_t size{};
 
-    shmem_handle = Convert<Handle>(GetReg64(system, 0));
-    address = Convert<uint64_t>(GetReg64(system, 1));
-    size = Convert<uint64_t>(GetReg64(system, 2));
+    shmem_handle = Convert<Handle>(GetArg64(args, 0));
+    address = Convert<uint64_t>(GetArg64(args, 1));
+    size = Convert<uint64_t>(GetArg64(args, 2));
 
     ret = UnmapSharedMemory64(system, shmem_handle, address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_CreateTransferMemory64(Core::System& system) {
+static void SvcWrap_CreateTransferMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
@@ -2365,41 +2365,41 @@ static void SvcWrap_CreateTransferMemory64(Core::System& system) {
     uint64_t size{};
     MemoryPermission map_perm{};
 
-    address = Convert<uint64_t>(GetReg64(system, 1));
-    size = Convert<uint64_t>(GetReg64(system, 2));
-    map_perm = Convert<MemoryPermission>(GetReg64(system, 3));
+    address = Convert<uint64_t>(GetArg64(args, 1));
+    size = Convert<uint64_t>(GetArg64(args, 2));
+    map_perm = Convert<MemoryPermission>(GetArg64(args, 3));
 
     ret = CreateTransferMemory64(system, std::addressof(out_handle), address, size, map_perm);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_handle));
 }
 
-static void SvcWrap_CloseHandle64(Core::System& system) {
+static void SvcWrap_CloseHandle64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle handle{};
 
-    handle = Convert<Handle>(GetReg64(system, 0));
+    handle = Convert<Handle>(GetArg64(args, 0));
 
     ret = CloseHandle64(system, handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_ResetSignal64(Core::System& system) {
+static void SvcWrap_ResetSignal64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle handle{};
 
-    handle = Convert<Handle>(GetReg64(system, 0));
+    handle = Convert<Handle>(GetArg64(args, 0));
 
     ret = ResetSignal64(system, handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_WaitSynchronization64(Core::System& system) {
+static void SvcWrap_WaitSynchronization64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int32_t out_index{};
@@ -2407,57 +2407,57 @@ static void SvcWrap_WaitSynchronization64(Core::System& system) {
     int32_t num_handles{};
     int64_t timeout_ns{};
 
-    handles = Convert<uint64_t>(GetReg64(system, 1));
-    num_handles = Convert<int32_t>(GetReg64(system, 2));
-    timeout_ns = Convert<int64_t>(GetReg64(system, 3));
+    handles = Convert<uint64_t>(GetArg64(args, 1));
+    num_handles = Convert<int32_t>(GetArg64(args, 2));
+    timeout_ns = Convert<int64_t>(GetArg64(args, 3));
 
     ret = WaitSynchronization64(system, std::addressof(out_index), handles, num_handles, timeout_ns);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_index));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_index));
 }
 
-static void SvcWrap_CancelSynchronization64(Core::System& system) {
+static void SvcWrap_CancelSynchronization64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle handle{};
 
-    handle = Convert<Handle>(GetReg64(system, 0));
+    handle = Convert<Handle>(GetArg64(args, 0));
 
     ret = CancelSynchronization64(system, handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_ArbitrateLock64(Core::System& system) {
+static void SvcWrap_ArbitrateLock64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle thread_handle{};
     uint64_t address{};
     uint32_t tag{};
 
-    thread_handle = Convert<Handle>(GetReg64(system, 0));
-    address = Convert<uint64_t>(GetReg64(system, 1));
-    tag = Convert<uint32_t>(GetReg64(system, 2));
+    thread_handle = Convert<Handle>(GetArg64(args, 0));
+    address = Convert<uint64_t>(GetArg64(args, 1));
+    tag = Convert<uint32_t>(GetArg64(args, 2));
 
     ret = ArbitrateLock64(system, thread_handle, address, tag);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_ArbitrateUnlock64(Core::System& system) {
+static void SvcWrap_ArbitrateUnlock64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t address{};
 
-    address = Convert<uint64_t>(GetReg64(system, 0));
+    address = Convert<uint64_t>(GetArg64(args, 0));
 
     ret = ArbitrateUnlock64(system, address);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_WaitProcessWideKeyAtomic64(Core::System& system) {
+static void SvcWrap_WaitProcessWideKeyAtomic64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t address{};
@@ -2465,77 +2465,77 @@ static void SvcWrap_WaitProcessWideKeyAtomic64(Core::System& system) {
     uint32_t tag{};
     int64_t timeout_ns{};
 
-    address = Convert<uint64_t>(GetReg64(system, 0));
-    cv_key = Convert<uint64_t>(GetReg64(system, 1));
-    tag = Convert<uint32_t>(GetReg64(system, 2));
-    timeout_ns = Convert<int64_t>(GetReg64(system, 3));
+    address = Convert<uint64_t>(GetArg64(args, 0));
+    cv_key = Convert<uint64_t>(GetArg64(args, 1));
+    tag = Convert<uint32_t>(GetArg64(args, 2));
+    timeout_ns = Convert<int64_t>(GetArg64(args, 3));
 
     ret = WaitProcessWideKeyAtomic64(system, address, cv_key, tag, timeout_ns);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_SignalProcessWideKey64(Core::System& system) {
+static void SvcWrap_SignalProcessWideKey64(Core::System& system, std::span<uint64_t, 8> args) {
     uint64_t cv_key{};
     int32_t count{};
 
-    cv_key = Convert<uint64_t>(GetReg64(system, 0));
-    count = Convert<int32_t>(GetReg64(system, 1));
+    cv_key = Convert<uint64_t>(GetArg64(args, 0));
+    count = Convert<int32_t>(GetArg64(args, 1));
 
     SignalProcessWideKey64(system, cv_key, count);
 }
 
-static void SvcWrap_GetSystemTick64(Core::System& system) {
+static void SvcWrap_GetSystemTick64(Core::System& system, std::span<uint64_t, 8> args) {
     int64_t ret{};
 
     ret = GetSystemTick64(system);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_ConnectToNamedPort64(Core::System& system) {
+static void SvcWrap_ConnectToNamedPort64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
     uint64_t name{};
 
-    name = Convert<uint64_t>(GetReg64(system, 1));
+    name = Convert<uint64_t>(GetArg64(args, 1));
 
     ret = ConnectToNamedPort64(system, std::addressof(out_handle), name);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_handle));
 }
 
-static void SvcWrap_SendSyncRequest64(Core::System& system) {
+static void SvcWrap_SendSyncRequest64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle session_handle{};
 
-    session_handle = Convert<Handle>(GetReg64(system, 0));
+    session_handle = Convert<Handle>(GetArg64(args, 0));
 
     ret = SendSyncRequest64(system, session_handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_SendSyncRequestWithUserBuffer64(Core::System& system) {
+static void SvcWrap_SendSyncRequestWithUserBuffer64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t message_buffer{};
     uint64_t message_buffer_size{};
     Handle session_handle{};
 
-    message_buffer = Convert<uint64_t>(GetReg64(system, 0));
-    message_buffer_size = Convert<uint64_t>(GetReg64(system, 1));
-    session_handle = Convert<Handle>(GetReg64(system, 2));
+    message_buffer = Convert<uint64_t>(GetArg64(args, 0));
+    message_buffer_size = Convert<uint64_t>(GetArg64(args, 1));
+    session_handle = Convert<Handle>(GetArg64(args, 2));
 
     ret = SendSyncRequestWithUserBuffer64(system, message_buffer, message_buffer_size, session_handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_SendAsyncRequestWithUserBuffer64(Core::System& system) {
+static void SvcWrap_SendAsyncRequestWithUserBuffer64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_event_handle{};
@@ -2543,79 +2543,79 @@ static void SvcWrap_SendAsyncRequestWithUserBuffer64(Core::System& system) {
     uint64_t message_buffer_size{};
     Handle session_handle{};
 
-    message_buffer = Convert<uint64_t>(GetReg64(system, 1));
-    message_buffer_size = Convert<uint64_t>(GetReg64(system, 2));
-    session_handle = Convert<Handle>(GetReg64(system, 3));
+    message_buffer = Convert<uint64_t>(GetArg64(args, 1));
+    message_buffer_size = Convert<uint64_t>(GetArg64(args, 2));
+    session_handle = Convert<Handle>(GetArg64(args, 3));
 
     ret = SendAsyncRequestWithUserBuffer64(system, std::addressof(out_event_handle), message_buffer, message_buffer_size, session_handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_event_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_event_handle));
 }
 
-static void SvcWrap_GetProcessId64(Core::System& system) {
+static void SvcWrap_GetProcessId64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t out_process_id{};
     Handle process_handle{};
 
-    process_handle = Convert<Handle>(GetReg64(system, 1));
+    process_handle = Convert<Handle>(GetArg64(args, 1));
 
     ret = GetProcessId64(system, std::addressof(out_process_id), process_handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_process_id));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_process_id));
 }
 
-static void SvcWrap_GetThreadId64(Core::System& system) {
+static void SvcWrap_GetThreadId64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t out_thread_id{};
     Handle thread_handle{};
 
-    thread_handle = Convert<Handle>(GetReg64(system, 1));
+    thread_handle = Convert<Handle>(GetArg64(args, 1));
 
     ret = GetThreadId64(system, std::addressof(out_thread_id), thread_handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_thread_id));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_thread_id));
 }
 
-static void SvcWrap_Break64(Core::System& system) {
+static void SvcWrap_Break64(Core::System& system, std::span<uint64_t, 8> args) {
     BreakReason break_reason{};
     uint64_t arg{};
     uint64_t size{};
 
-    break_reason = Convert<BreakReason>(GetReg64(system, 0));
-    arg = Convert<uint64_t>(GetReg64(system, 1));
-    size = Convert<uint64_t>(GetReg64(system, 2));
+    break_reason = Convert<BreakReason>(GetArg64(args, 0));
+    arg = Convert<uint64_t>(GetArg64(args, 1));
+    size = Convert<uint64_t>(GetArg64(args, 2));
 
     Break64(system, break_reason, arg, size);
 }
 
-static void SvcWrap_OutputDebugString64(Core::System& system) {
+static void SvcWrap_OutputDebugString64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t debug_str{};
     uint64_t len{};
 
-    debug_str = Convert<uint64_t>(GetReg64(system, 0));
-    len = Convert<uint64_t>(GetReg64(system, 1));
+    debug_str = Convert<uint64_t>(GetArg64(args, 0));
+    len = Convert<uint64_t>(GetArg64(args, 1));
 
     ret = OutputDebugString64(system, debug_str, len);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_ReturnFromException64(Core::System& system) {
+static void SvcWrap_ReturnFromException64(Core::System& system, std::span<uint64_t, 8> args) {
     Result result{};
 
-    result = Convert<Result>(GetReg64(system, 0));
+    result = Convert<Result>(GetArg64(args, 0));
 
     ReturnFromException64(system, result);
 }
 
-static void SvcWrap_GetInfo64(Core::System& system) {
+static void SvcWrap_GetInfo64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t out{};
@@ -2623,63 +2623,63 @@ static void SvcWrap_GetInfo64(Core::System& system) {
     Handle handle{};
     uint64_t info_subtype{};
 
-    info_type = Convert<InfoType>(GetReg64(system, 1));
-    handle = Convert<Handle>(GetReg64(system, 2));
-    info_subtype = Convert<uint64_t>(GetReg64(system, 3));
+    info_type = Convert<InfoType>(GetArg64(args, 1));
+    handle = Convert<Handle>(GetArg64(args, 2));
+    info_subtype = Convert<uint64_t>(GetArg64(args, 3));
 
     ret = GetInfo64(system, std::addressof(out), info_type, handle, info_subtype);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out));
 }
 
-static void SvcWrap_FlushEntireDataCache64(Core::System& system) {
+static void SvcWrap_FlushEntireDataCache64(Core::System& system, std::span<uint64_t, 8> args) {
     FlushEntireDataCache64(system);
 }
 
-static void SvcWrap_FlushDataCache64(Core::System& system) {
+static void SvcWrap_FlushDataCache64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t address{};
     uint64_t size{};
 
-    address = Convert<uint64_t>(GetReg64(system, 0));
-    size = Convert<uint64_t>(GetReg64(system, 1));
+    address = Convert<uint64_t>(GetArg64(args, 0));
+    size = Convert<uint64_t>(GetArg64(args, 1));
 
     ret = FlushDataCache64(system, address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_MapPhysicalMemory64(Core::System& system) {
+static void SvcWrap_MapPhysicalMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t address{};
     uint64_t size{};
 
-    address = Convert<uint64_t>(GetReg64(system, 0));
-    size = Convert<uint64_t>(GetReg64(system, 1));
+    address = Convert<uint64_t>(GetArg64(args, 0));
+    size = Convert<uint64_t>(GetArg64(args, 1));
 
     ret = MapPhysicalMemory64(system, address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_UnmapPhysicalMemory64(Core::System& system) {
+static void SvcWrap_UnmapPhysicalMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t address{};
     uint64_t size{};
 
-    address = Convert<uint64_t>(GetReg64(system, 0));
-    size = Convert<uint64_t>(GetReg64(system, 1));
+    address = Convert<uint64_t>(GetArg64(args, 0));
+    size = Convert<uint64_t>(GetArg64(args, 1));
 
     ret = UnmapPhysicalMemory64(system, address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_GetDebugFutureThreadInfo64(Core::System& system) {
+static void SvcWrap_GetDebugFutureThreadInfo64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     lp64::LastThreadContext out_context{};
@@ -2687,21 +2687,21 @@ static void SvcWrap_GetDebugFutureThreadInfo64(Core::System& system) {
     Handle debug_handle{};
     int64_t ns{};
 
-    debug_handle = Convert<Handle>(GetReg64(system, 2));
-    ns = Convert<int64_t>(GetReg64(system, 3));
+    debug_handle = Convert<Handle>(GetArg64(args, 2));
+    ns = Convert<int64_t>(GetArg64(args, 3));
 
     ret = GetDebugFutureThreadInfo64(system, std::addressof(out_context), std::addressof(out_thread_id), debug_handle, ns);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
     auto out_context_scatter = Convert<std::array<uint64_t, 4>>(out_context);
-    SetReg64(system, 1, out_context_scatter[0]);
-    SetReg64(system, 2, out_context_scatter[1]);
-    SetReg64(system, 3, out_context_scatter[2]);
-    SetReg64(system, 4, out_context_scatter[3]);
-    SetReg64(system, 5, Convert<uint64_t>(out_thread_id));
+    SetArg64(args, 1, out_context_scatter[0]);
+    SetArg64(args, 2, out_context_scatter[1]);
+    SetArg64(args, 3, out_context_scatter[2]);
+    SetArg64(args, 4, out_context_scatter[3]);
+    SetArg64(args, 5, Convert<uint64_t>(out_thread_id));
 }
 
-static void SvcWrap_GetLastThreadInfo64(Core::System& system) {
+static void SvcWrap_GetLastThreadInfo64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     lp64::LastThreadContext out_context{};
@@ -2710,77 +2710,77 @@ static void SvcWrap_GetLastThreadInfo64(Core::System& system) {
 
     ret = GetLastThreadInfo64(system, std::addressof(out_context), std::addressof(out_tls_address), std::addressof(out_flags));
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
     auto out_context_scatter = Convert<std::array<uint64_t, 4>>(out_context);
-    SetReg64(system, 1, out_context_scatter[0]);
-    SetReg64(system, 2, out_context_scatter[1]);
-    SetReg64(system, 3, out_context_scatter[2]);
-    SetReg64(system, 4, out_context_scatter[3]);
-    SetReg64(system, 5, Convert<uint64_t>(out_tls_address));
-    SetReg64(system, 6, Convert<uint64_t>(out_flags));
+    SetArg64(args, 1, out_context_scatter[0]);
+    SetArg64(args, 2, out_context_scatter[1]);
+    SetArg64(args, 3, out_context_scatter[2]);
+    SetArg64(args, 4, out_context_scatter[3]);
+    SetArg64(args, 5, Convert<uint64_t>(out_tls_address));
+    SetArg64(args, 6, Convert<uint64_t>(out_flags));
 }
 
-static void SvcWrap_GetResourceLimitLimitValue64(Core::System& system) {
+static void SvcWrap_GetResourceLimitLimitValue64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int64_t out_limit_value{};
     Handle resource_limit_handle{};
     LimitableResource which{};
 
-    resource_limit_handle = Convert<Handle>(GetReg64(system, 1));
-    which = Convert<LimitableResource>(GetReg64(system, 2));
+    resource_limit_handle = Convert<Handle>(GetArg64(args, 1));
+    which = Convert<LimitableResource>(GetArg64(args, 2));
 
     ret = GetResourceLimitLimitValue64(system, std::addressof(out_limit_value), resource_limit_handle, which);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_limit_value));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_limit_value));
 }
 
-static void SvcWrap_GetResourceLimitCurrentValue64(Core::System& system) {
+static void SvcWrap_GetResourceLimitCurrentValue64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int64_t out_current_value{};
     Handle resource_limit_handle{};
     LimitableResource which{};
 
-    resource_limit_handle = Convert<Handle>(GetReg64(system, 1));
-    which = Convert<LimitableResource>(GetReg64(system, 2));
+    resource_limit_handle = Convert<Handle>(GetArg64(args, 1));
+    which = Convert<LimitableResource>(GetArg64(args, 2));
 
     ret = GetResourceLimitCurrentValue64(system, std::addressof(out_current_value), resource_limit_handle, which);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_current_value));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_current_value));
 }
 
-static void SvcWrap_SetThreadActivity64(Core::System& system) {
+static void SvcWrap_SetThreadActivity64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle thread_handle{};
     ThreadActivity thread_activity{};
 
-    thread_handle = Convert<Handle>(GetReg64(system, 0));
-    thread_activity = Convert<ThreadActivity>(GetReg64(system, 1));
+    thread_handle = Convert<Handle>(GetArg64(args, 0));
+    thread_activity = Convert<ThreadActivity>(GetArg64(args, 1));
 
     ret = SetThreadActivity64(system, thread_handle, thread_activity);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_GetThreadContext364(Core::System& system) {
+static void SvcWrap_GetThreadContext364(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t out_context{};
     Handle thread_handle{};
 
-    out_context = Convert<uint64_t>(GetReg64(system, 0));
-    thread_handle = Convert<Handle>(GetReg64(system, 1));
+    out_context = Convert<uint64_t>(GetArg64(args, 0));
+    thread_handle = Convert<Handle>(GetArg64(args, 1));
 
     ret = GetThreadContext364(system, out_context, thread_handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_WaitForAddress64(Core::System& system) {
+static void SvcWrap_WaitForAddress64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t address{};
@@ -2788,17 +2788,17 @@ static void SvcWrap_WaitForAddress64(Core::System& system) {
     int32_t value{};
     int64_t timeout_ns{};
 
-    address = Convert<uint64_t>(GetReg64(system, 0));
-    arb_type = Convert<ArbitrationType>(GetReg64(system, 1));
-    value = Convert<int32_t>(GetReg64(system, 2));
-    timeout_ns = Convert<int64_t>(GetReg64(system, 3));
+    address = Convert<uint64_t>(GetArg64(args, 0));
+    arb_type = Convert<ArbitrationType>(GetArg64(args, 1));
+    value = Convert<int32_t>(GetArg64(args, 2));
+    timeout_ns = Convert<int64_t>(GetArg64(args, 3));
 
     ret = WaitForAddress64(system, address, arb_type, value, timeout_ns);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_SignalToAddress64(Core::System& system) {
+static void SvcWrap_SignalToAddress64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t address{};
@@ -2806,51 +2806,51 @@ static void SvcWrap_SignalToAddress64(Core::System& system) {
     int32_t value{};
     int32_t count{};
 
-    address = Convert<uint64_t>(GetReg64(system, 0));
-    signal_type = Convert<SignalType>(GetReg64(system, 1));
-    value = Convert<int32_t>(GetReg64(system, 2));
-    count = Convert<int32_t>(GetReg64(system, 3));
+    address = Convert<uint64_t>(GetArg64(args, 0));
+    signal_type = Convert<SignalType>(GetArg64(args, 1));
+    value = Convert<int32_t>(GetArg64(args, 2));
+    count = Convert<int32_t>(GetArg64(args, 3));
 
     ret = SignalToAddress64(system, address, signal_type, value, count);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_SynchronizePreemptionState64(Core::System& system) {
+static void SvcWrap_SynchronizePreemptionState64(Core::System& system, std::span<uint64_t, 8> args) {
     SynchronizePreemptionState64(system);
 }
 
-static void SvcWrap_GetResourceLimitPeakValue64(Core::System& system) {
+static void SvcWrap_GetResourceLimitPeakValue64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int64_t out_peak_value{};
     Handle resource_limit_handle{};
     LimitableResource which{};
 
-    resource_limit_handle = Convert<Handle>(GetReg64(system, 1));
-    which = Convert<LimitableResource>(GetReg64(system, 2));
+    resource_limit_handle = Convert<Handle>(GetArg64(args, 1));
+    which = Convert<LimitableResource>(GetArg64(args, 2));
 
     ret = GetResourceLimitPeakValue64(system, std::addressof(out_peak_value), resource_limit_handle, which);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_peak_value));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_peak_value));
 }
 
-static void SvcWrap_CreateIoPool64(Core::System& system) {
+static void SvcWrap_CreateIoPool64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
     IoPoolType which{};
 
-    which = Convert<IoPoolType>(GetReg64(system, 1));
+    which = Convert<IoPoolType>(GetArg64(args, 1));
 
     ret = CreateIoPool64(system, std::addressof(out_handle), which);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_handle));
 }
 
-static void SvcWrap_CreateIoRegion64(Core::System& system) {
+static void SvcWrap_CreateIoRegion64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
@@ -2860,41 +2860,41 @@ static void SvcWrap_CreateIoRegion64(Core::System& system) {
     MemoryMapping mapping{};
     MemoryPermission perm{};
 
-    io_pool = Convert<Handle>(GetReg64(system, 1));
-    physical_address = Convert<uint64_t>(GetReg64(system, 2));
-    size = Convert<uint64_t>(GetReg64(system, 3));
-    mapping = Convert<MemoryMapping>(GetReg64(system, 4));
-    perm = Convert<MemoryPermission>(GetReg64(system, 5));
+    io_pool = Convert<Handle>(GetArg64(args, 1));
+    physical_address = Convert<uint64_t>(GetArg64(args, 2));
+    size = Convert<uint64_t>(GetArg64(args, 3));
+    mapping = Convert<MemoryMapping>(GetArg64(args, 4));
+    perm = Convert<MemoryPermission>(GetArg64(args, 5));
 
     ret = CreateIoRegion64(system, std::addressof(out_handle), io_pool, physical_address, size, mapping, perm);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_handle));
 }
 
-static void SvcWrap_KernelDebug64(Core::System& system) {
+static void SvcWrap_KernelDebug64(Core::System& system, std::span<uint64_t, 8> args) {
     KernelDebugType kern_debug_type{};
     uint64_t arg0{};
     uint64_t arg1{};
     uint64_t arg2{};
 
-    kern_debug_type = Convert<KernelDebugType>(GetReg64(system, 0));
-    arg0 = Convert<uint64_t>(GetReg64(system, 1));
-    arg1 = Convert<uint64_t>(GetReg64(system, 2));
-    arg2 = Convert<uint64_t>(GetReg64(system, 3));
+    kern_debug_type = Convert<KernelDebugType>(GetArg64(args, 0));
+    arg0 = Convert<uint64_t>(GetArg64(args, 1));
+    arg1 = Convert<uint64_t>(GetArg64(args, 2));
+    arg2 = Convert<uint64_t>(GetArg64(args, 3));
 
     KernelDebug64(system, kern_debug_type, arg0, arg1, arg2);
 }
 
-static void SvcWrap_ChangeKernelTraceState64(Core::System& system) {
+static void SvcWrap_ChangeKernelTraceState64(Core::System& system, std::span<uint64_t, 8> args) {
     KernelTraceState kern_trace_state{};
 
-    kern_trace_state = Convert<KernelTraceState>(GetReg64(system, 0));
+    kern_trace_state = Convert<KernelTraceState>(GetArg64(args, 0));
 
     ChangeKernelTraceState64(system, kern_trace_state);
 }
 
-static void SvcWrap_CreateSession64(Core::System& system) {
+static void SvcWrap_CreateSession64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_server_session_handle{};
@@ -2902,31 +2902,31 @@ static void SvcWrap_CreateSession64(Core::System& system) {
     bool is_light{};
     uint64_t name{};
 
-    is_light = Convert<bool>(GetReg64(system, 2));
-    name = Convert<uint64_t>(GetReg64(system, 3));
+    is_light = Convert<bool>(GetArg64(args, 2));
+    name = Convert<uint64_t>(GetArg64(args, 3));
 
     ret = CreateSession64(system, std::addressof(out_server_session_handle), std::addressof(out_client_session_handle), is_light, name);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_server_session_handle));
-    SetReg64(system, 2, Convert<uint64_t>(out_client_session_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_server_session_handle));
+    SetArg64(args, 2, Convert<uint64_t>(out_client_session_handle));
 }
 
-static void SvcWrap_AcceptSession64(Core::System& system) {
+static void SvcWrap_AcceptSession64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
     Handle port{};
 
-    port = Convert<Handle>(GetReg64(system, 1));
+    port = Convert<Handle>(GetArg64(args, 1));
 
     ret = AcceptSession64(system, std::addressof(out_handle), port);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_handle));
 }
 
-static void SvcWrap_ReplyAndReceive64(Core::System& system) {
+static void SvcWrap_ReplyAndReceive64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int32_t out_index{};
@@ -2935,18 +2935,18 @@ static void SvcWrap_ReplyAndReceive64(Core::System& system) {
     Handle reply_target{};
     int64_t timeout_ns{};
 
-    handles = Convert<uint64_t>(GetReg64(system, 1));
-    num_handles = Convert<int32_t>(GetReg64(system, 2));
-    reply_target = Convert<Handle>(GetReg64(system, 3));
-    timeout_ns = Convert<int64_t>(GetReg64(system, 4));
+    handles = Convert<uint64_t>(GetArg64(args, 1));
+    num_handles = Convert<int32_t>(GetArg64(args, 2));
+    reply_target = Convert<Handle>(GetArg64(args, 3));
+    timeout_ns = Convert<int64_t>(GetArg64(args, 4));
 
     ret = ReplyAndReceive64(system, std::addressof(out_index), handles, num_handles, reply_target, timeout_ns);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_index));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_index));
 }
 
-static void SvcWrap_ReplyAndReceiveWithUserBuffer64(Core::System& system) {
+static void SvcWrap_ReplyAndReceiveWithUserBuffer64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int32_t out_index{};
@@ -2957,20 +2957,20 @@ static void SvcWrap_ReplyAndReceiveWithUserBuffer64(Core::System& system) {
     Handle reply_target{};
     int64_t timeout_ns{};
 
-    message_buffer = Convert<uint64_t>(GetReg64(system, 1));
-    message_buffer_size = Convert<uint64_t>(GetReg64(system, 2));
-    handles = Convert<uint64_t>(GetReg64(system, 3));
-    num_handles = Convert<int32_t>(GetReg64(system, 4));
-    reply_target = Convert<Handle>(GetReg64(system, 5));
-    timeout_ns = Convert<int64_t>(GetReg64(system, 6));
+    message_buffer = Convert<uint64_t>(GetArg64(args, 1));
+    message_buffer_size = Convert<uint64_t>(GetArg64(args, 2));
+    handles = Convert<uint64_t>(GetArg64(args, 3));
+    num_handles = Convert<int32_t>(GetArg64(args, 4));
+    reply_target = Convert<Handle>(GetArg64(args, 5));
+    timeout_ns = Convert<int64_t>(GetArg64(args, 6));
 
     ret = ReplyAndReceiveWithUserBuffer64(system, std::addressof(out_index), message_buffer, message_buffer_size, handles, num_handles, reply_target, timeout_ns);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_index));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_index));
 }
 
-static void SvcWrap_CreateEvent64(Core::System& system) {
+static void SvcWrap_CreateEvent64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_write_handle{};
@@ -2978,12 +2978,12 @@ static void SvcWrap_CreateEvent64(Core::System& system) {
 
     ret = CreateEvent64(system, std::addressof(out_write_handle), std::addressof(out_read_handle));
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_write_handle));
-    SetReg64(system, 2, Convert<uint64_t>(out_read_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_write_handle));
+    SetArg64(args, 2, Convert<uint64_t>(out_read_handle));
 }
 
-static void SvcWrap_MapIoRegion64(Core::System& system) {
+static void SvcWrap_MapIoRegion64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle io_region{};
@@ -2991,89 +2991,89 @@ static void SvcWrap_MapIoRegion64(Core::System& system) {
     uint64_t size{};
     MemoryPermission perm{};
 
-    io_region = Convert<Handle>(GetReg64(system, 0));
-    address = Convert<uint64_t>(GetReg64(system, 1));
-    size = Convert<uint64_t>(GetReg64(system, 2));
-    perm = Convert<MemoryPermission>(GetReg64(system, 3));
+    io_region = Convert<Handle>(GetArg64(args, 0));
+    address = Convert<uint64_t>(GetArg64(args, 1));
+    size = Convert<uint64_t>(GetArg64(args, 2));
+    perm = Convert<MemoryPermission>(GetArg64(args, 3));
 
     ret = MapIoRegion64(system, io_region, address, size, perm);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_UnmapIoRegion64(Core::System& system) {
+static void SvcWrap_UnmapIoRegion64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle io_region{};
     uint64_t address{};
     uint64_t size{};
 
-    io_region = Convert<Handle>(GetReg64(system, 0));
-    address = Convert<uint64_t>(GetReg64(system, 1));
-    size = Convert<uint64_t>(GetReg64(system, 2));
+    io_region = Convert<Handle>(GetArg64(args, 0));
+    address = Convert<uint64_t>(GetArg64(args, 1));
+    size = Convert<uint64_t>(GetArg64(args, 2));
 
     ret = UnmapIoRegion64(system, io_region, address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_MapPhysicalMemoryUnsafe64(Core::System& system) {
+static void SvcWrap_MapPhysicalMemoryUnsafe64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t address{};
     uint64_t size{};
 
-    address = Convert<uint64_t>(GetReg64(system, 0));
-    size = Convert<uint64_t>(GetReg64(system, 1));
+    address = Convert<uint64_t>(GetArg64(args, 0));
+    size = Convert<uint64_t>(GetArg64(args, 1));
 
     ret = MapPhysicalMemoryUnsafe64(system, address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_UnmapPhysicalMemoryUnsafe64(Core::System& system) {
+static void SvcWrap_UnmapPhysicalMemoryUnsafe64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t address{};
     uint64_t size{};
 
-    address = Convert<uint64_t>(GetReg64(system, 0));
-    size = Convert<uint64_t>(GetReg64(system, 1));
+    address = Convert<uint64_t>(GetArg64(args, 0));
+    size = Convert<uint64_t>(GetArg64(args, 1));
 
     ret = UnmapPhysicalMemoryUnsafe64(system, address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_SetUnsafeLimit64(Core::System& system) {
+static void SvcWrap_SetUnsafeLimit64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t limit{};
 
-    limit = Convert<uint64_t>(GetReg64(system, 0));
+    limit = Convert<uint64_t>(GetArg64(args, 0));
 
     ret = SetUnsafeLimit64(system, limit);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_CreateCodeMemory64(Core::System& system) {
+static void SvcWrap_CreateCodeMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
     uint64_t address{};
     uint64_t size{};
 
-    address = Convert<uint64_t>(GetReg64(system, 1));
-    size = Convert<uint64_t>(GetReg64(system, 2));
+    address = Convert<uint64_t>(GetArg64(args, 1));
+    size = Convert<uint64_t>(GetArg64(args, 2));
 
     ret = CreateCodeMemory64(system, std::addressof(out_handle), address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_handle));
 }
 
-static void SvcWrap_ControlCodeMemory64(Core::System& system) {
+static void SvcWrap_ControlCodeMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle code_memory_handle{};
@@ -3082,22 +3082,22 @@ static void SvcWrap_ControlCodeMemory64(Core::System& system) {
     uint64_t size{};
     MemoryPermission perm{};
 
-    code_memory_handle = Convert<Handle>(GetReg64(system, 0));
-    operation = Convert<CodeMemoryOperation>(GetReg64(system, 1));
-    address = Convert<uint64_t>(GetReg64(system, 2));
-    size = Convert<uint64_t>(GetReg64(system, 3));
-    perm = Convert<MemoryPermission>(GetReg64(system, 4));
+    code_memory_handle = Convert<Handle>(GetArg64(args, 0));
+    operation = Convert<CodeMemoryOperation>(GetArg64(args, 1));
+    address = Convert<uint64_t>(GetArg64(args, 2));
+    size = Convert<uint64_t>(GetArg64(args, 3));
+    perm = Convert<MemoryPermission>(GetArg64(args, 4));
 
     ret = ControlCodeMemory64(system, code_memory_handle, operation, address, size, perm);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_SleepSystem64(Core::System& system) {
+static void SvcWrap_SleepSystem64(Core::System& system, std::span<uint64_t, 8> args) {
     SleepSystem64(system);
 }
 
-static void SvcWrap_ReadWriteRegister64(Core::System& system) {
+static void SvcWrap_ReadWriteRegister64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint32_t out_value{};
@@ -3105,31 +3105,31 @@ static void SvcWrap_ReadWriteRegister64(Core::System& system) {
     uint32_t mask{};
     uint32_t value{};
 
-    address = Convert<uint64_t>(GetReg64(system, 1));
-    mask = Convert<uint32_t>(GetReg64(system, 2));
-    value = Convert<uint32_t>(GetReg64(system, 3));
+    address = Convert<uint64_t>(GetArg64(args, 1));
+    mask = Convert<uint32_t>(GetArg64(args, 2));
+    value = Convert<uint32_t>(GetArg64(args, 3));
 
     ret = ReadWriteRegister64(system, std::addressof(out_value), address, mask, value);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_value));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_value));
 }
 
-static void SvcWrap_SetProcessActivity64(Core::System& system) {
+static void SvcWrap_SetProcessActivity64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle process_handle{};
     ProcessActivity process_activity{};
 
-    process_handle = Convert<Handle>(GetReg64(system, 0));
-    process_activity = Convert<ProcessActivity>(GetReg64(system, 1));
+    process_handle = Convert<Handle>(GetArg64(args, 0));
+    process_activity = Convert<ProcessActivity>(GetArg64(args, 1));
 
     ret = SetProcessActivity64(system, process_handle, process_activity);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_CreateSharedMemory64(Core::System& system) {
+static void SvcWrap_CreateSharedMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
@@ -3137,17 +3137,17 @@ static void SvcWrap_CreateSharedMemory64(Core::System& system) {
     MemoryPermission owner_perm{};
     MemoryPermission remote_perm{};
 
-    size = Convert<uint64_t>(GetReg64(system, 1));
-    owner_perm = Convert<MemoryPermission>(GetReg64(system, 2));
-    remote_perm = Convert<MemoryPermission>(GetReg64(system, 3));
+    size = Convert<uint64_t>(GetArg64(args, 1));
+    owner_perm = Convert<MemoryPermission>(GetArg64(args, 2));
+    remote_perm = Convert<MemoryPermission>(GetArg64(args, 3));
 
     ret = CreateSharedMemory64(system, std::addressof(out_handle), size, owner_perm, remote_perm);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_handle));
 }
 
-static void SvcWrap_MapTransferMemory64(Core::System& system) {
+static void SvcWrap_MapTransferMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle trmem_handle{};
@@ -3155,66 +3155,66 @@ static void SvcWrap_MapTransferMemory64(Core::System& system) {
     uint64_t size{};
     MemoryPermission owner_perm{};
 
-    trmem_handle = Convert<Handle>(GetReg64(system, 0));
-    address = Convert<uint64_t>(GetReg64(system, 1));
-    size = Convert<uint64_t>(GetReg64(system, 2));
-    owner_perm = Convert<MemoryPermission>(GetReg64(system, 3));
+    trmem_handle = Convert<Handle>(GetArg64(args, 0));
+    address = Convert<uint64_t>(GetArg64(args, 1));
+    size = Convert<uint64_t>(GetArg64(args, 2));
+    owner_perm = Convert<MemoryPermission>(GetArg64(args, 3));
 
     ret = MapTransferMemory64(system, trmem_handle, address, size, owner_perm);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_UnmapTransferMemory64(Core::System& system) {
+static void SvcWrap_UnmapTransferMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle trmem_handle{};
     uint64_t address{};
     uint64_t size{};
 
-    trmem_handle = Convert<Handle>(GetReg64(system, 0));
-    address = Convert<uint64_t>(GetReg64(system, 1));
-    size = Convert<uint64_t>(GetReg64(system, 2));
+    trmem_handle = Convert<Handle>(GetArg64(args, 0));
+    address = Convert<uint64_t>(GetArg64(args, 1));
+    size = Convert<uint64_t>(GetArg64(args, 2));
 
     ret = UnmapTransferMemory64(system, trmem_handle, address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_CreateInterruptEvent64(Core::System& system) {
+static void SvcWrap_CreateInterruptEvent64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_read_handle{};
     int32_t interrupt_id{};
     InterruptType interrupt_type{};
 
-    interrupt_id = Convert<int32_t>(GetReg64(system, 1));
-    interrupt_type = Convert<InterruptType>(GetReg64(system, 2));
+    interrupt_id = Convert<int32_t>(GetArg64(args, 1));
+    interrupt_type = Convert<InterruptType>(GetArg64(args, 2));
 
     ret = CreateInterruptEvent64(system, std::addressof(out_read_handle), interrupt_id, interrupt_type);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_read_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_read_handle));
 }
 
-static void SvcWrap_QueryPhysicalAddress64(Core::System& system) {
+static void SvcWrap_QueryPhysicalAddress64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     lp64::PhysicalMemoryInfo out_info{};
     uint64_t address{};
 
-    address = Convert<uint64_t>(GetReg64(system, 1));
+    address = Convert<uint64_t>(GetArg64(args, 1));
 
     ret = QueryPhysicalAddress64(system, std::addressof(out_info), address);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
     auto out_info_scatter = Convert<std::array<uint64_t, 3>>(out_info);
-    SetReg64(system, 1, out_info_scatter[0]);
-    SetReg64(system, 2, out_info_scatter[1]);
-    SetReg64(system, 3, out_info_scatter[2]);
+    SetArg64(args, 1, out_info_scatter[0]);
+    SetArg64(args, 2, out_info_scatter[1]);
+    SetArg64(args, 3, out_info_scatter[2]);
 }
 
-static void SvcWrap_QueryIoMapping64(Core::System& system) {
+static void SvcWrap_QueryIoMapping64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t out_address{};
@@ -3222,61 +3222,61 @@ static void SvcWrap_QueryIoMapping64(Core::System& system) {
     uint64_t physical_address{};
     uint64_t size{};
 
-    physical_address = Convert<uint64_t>(GetReg64(system, 2));
-    size = Convert<uint64_t>(GetReg64(system, 3));
+    physical_address = Convert<uint64_t>(GetArg64(args, 2));
+    size = Convert<uint64_t>(GetArg64(args, 3));
 
     ret = QueryIoMapping64(system, std::addressof(out_address), std::addressof(out_size), physical_address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_address));
-    SetReg64(system, 2, Convert<uint64_t>(out_size));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_address));
+    SetArg64(args, 2, Convert<uint64_t>(out_size));
 }
 
-static void SvcWrap_CreateDeviceAddressSpace64(Core::System& system) {
+static void SvcWrap_CreateDeviceAddressSpace64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
     uint64_t das_address{};
     uint64_t das_size{};
 
-    das_address = Convert<uint64_t>(GetReg64(system, 1));
-    das_size = Convert<uint64_t>(GetReg64(system, 2));
+    das_address = Convert<uint64_t>(GetArg64(args, 1));
+    das_size = Convert<uint64_t>(GetArg64(args, 2));
 
     ret = CreateDeviceAddressSpace64(system, std::addressof(out_handle), das_address, das_size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_handle));
 }
 
-static void SvcWrap_AttachDeviceAddressSpace64(Core::System& system) {
+static void SvcWrap_AttachDeviceAddressSpace64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     DeviceName device_name{};
     Handle das_handle{};
 
-    device_name = Convert<DeviceName>(GetReg64(system, 0));
-    das_handle = Convert<Handle>(GetReg64(system, 1));
+    device_name = Convert<DeviceName>(GetArg64(args, 0));
+    das_handle = Convert<Handle>(GetArg64(args, 1));
 
     ret = AttachDeviceAddressSpace64(system, device_name, das_handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_DetachDeviceAddressSpace64(Core::System& system) {
+static void SvcWrap_DetachDeviceAddressSpace64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     DeviceName device_name{};
     Handle das_handle{};
 
-    device_name = Convert<DeviceName>(GetReg64(system, 0));
-    das_handle = Convert<Handle>(GetReg64(system, 1));
+    device_name = Convert<DeviceName>(GetArg64(args, 0));
+    das_handle = Convert<Handle>(GetArg64(args, 1));
 
     ret = DetachDeviceAddressSpace64(system, device_name, das_handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_MapDeviceAddressSpaceByForce64(Core::System& system) {
+static void SvcWrap_MapDeviceAddressSpaceByForce64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle das_handle{};
@@ -3286,19 +3286,19 @@ static void SvcWrap_MapDeviceAddressSpaceByForce64(Core::System& system) {
     uint64_t device_address{};
     uint32_t option{};
 
-    das_handle = Convert<Handle>(GetReg64(system, 0));
-    process_handle = Convert<Handle>(GetReg64(system, 1));
-    process_address = Convert<uint64_t>(GetReg64(system, 2));
-    size = Convert<uint64_t>(GetReg64(system, 3));
-    device_address = Convert<uint64_t>(GetReg64(system, 4));
-    option = Convert<uint32_t>(GetReg64(system, 5));
+    das_handle = Convert<Handle>(GetArg64(args, 0));
+    process_handle = Convert<Handle>(GetArg64(args, 1));
+    process_address = Convert<uint64_t>(GetArg64(args, 2));
+    size = Convert<uint64_t>(GetArg64(args, 3));
+    device_address = Convert<uint64_t>(GetArg64(args, 4));
+    option = Convert<uint32_t>(GetArg64(args, 5));
 
     ret = MapDeviceAddressSpaceByForce64(system, das_handle, process_handle, process_address, size, device_address, option);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_MapDeviceAddressSpaceAligned64(Core::System& system) {
+static void SvcWrap_MapDeviceAddressSpaceAligned64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle das_handle{};
@@ -3308,19 +3308,19 @@ static void SvcWrap_MapDeviceAddressSpaceAligned64(Core::System& system) {
     uint64_t device_address{};
     uint32_t option{};
 
-    das_handle = Convert<Handle>(GetReg64(system, 0));
-    process_handle = Convert<Handle>(GetReg64(system, 1));
-    process_address = Convert<uint64_t>(GetReg64(system, 2));
-    size = Convert<uint64_t>(GetReg64(system, 3));
-    device_address = Convert<uint64_t>(GetReg64(system, 4));
-    option = Convert<uint32_t>(GetReg64(system, 5));
+    das_handle = Convert<Handle>(GetArg64(args, 0));
+    process_handle = Convert<Handle>(GetArg64(args, 1));
+    process_address = Convert<uint64_t>(GetArg64(args, 2));
+    size = Convert<uint64_t>(GetArg64(args, 3));
+    device_address = Convert<uint64_t>(GetArg64(args, 4));
+    option = Convert<uint32_t>(GetArg64(args, 5));
 
     ret = MapDeviceAddressSpaceAligned64(system, das_handle, process_handle, process_address, size, device_address, option);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_UnmapDeviceAddressSpace64(Core::System& system) {
+static void SvcWrap_UnmapDeviceAddressSpace64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle das_handle{};
@@ -3329,118 +3329,118 @@ static void SvcWrap_UnmapDeviceAddressSpace64(Core::System& system) {
     uint64_t size{};
     uint64_t device_address{};
 
-    das_handle = Convert<Handle>(GetReg64(system, 0));
-    process_handle = Convert<Handle>(GetReg64(system, 1));
-    process_address = Convert<uint64_t>(GetReg64(system, 2));
-    size = Convert<uint64_t>(GetReg64(system, 3));
-    device_address = Convert<uint64_t>(GetReg64(system, 4));
+    das_handle = Convert<Handle>(GetArg64(args, 0));
+    process_handle = Convert<Handle>(GetArg64(args, 1));
+    process_address = Convert<uint64_t>(GetArg64(args, 2));
+    size = Convert<uint64_t>(GetArg64(args, 3));
+    device_address = Convert<uint64_t>(GetArg64(args, 4));
 
     ret = UnmapDeviceAddressSpace64(system, das_handle, process_handle, process_address, size, device_address);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_InvalidateProcessDataCache64(Core::System& system) {
+static void SvcWrap_InvalidateProcessDataCache64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle process_handle{};
     uint64_t address{};
     uint64_t size{};
 
-    process_handle = Convert<Handle>(GetReg64(system, 0));
-    address = Convert<uint64_t>(GetReg64(system, 1));
-    size = Convert<uint64_t>(GetReg64(system, 2));
+    process_handle = Convert<Handle>(GetArg64(args, 0));
+    address = Convert<uint64_t>(GetArg64(args, 1));
+    size = Convert<uint64_t>(GetArg64(args, 2));
 
     ret = InvalidateProcessDataCache64(system, process_handle, address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_StoreProcessDataCache64(Core::System& system) {
+static void SvcWrap_StoreProcessDataCache64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle process_handle{};
     uint64_t address{};
     uint64_t size{};
 
-    process_handle = Convert<Handle>(GetReg64(system, 0));
-    address = Convert<uint64_t>(GetReg64(system, 1));
-    size = Convert<uint64_t>(GetReg64(system, 2));
+    process_handle = Convert<Handle>(GetArg64(args, 0));
+    address = Convert<uint64_t>(GetArg64(args, 1));
+    size = Convert<uint64_t>(GetArg64(args, 2));
 
     ret = StoreProcessDataCache64(system, process_handle, address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_FlushProcessDataCache64(Core::System& system) {
+static void SvcWrap_FlushProcessDataCache64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle process_handle{};
     uint64_t address{};
     uint64_t size{};
 
-    process_handle = Convert<Handle>(GetReg64(system, 0));
-    address = Convert<uint64_t>(GetReg64(system, 1));
-    size = Convert<uint64_t>(GetReg64(system, 2));
+    process_handle = Convert<Handle>(GetArg64(args, 0));
+    address = Convert<uint64_t>(GetArg64(args, 1));
+    size = Convert<uint64_t>(GetArg64(args, 2));
 
     ret = FlushProcessDataCache64(system, process_handle, address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_DebugActiveProcess64(Core::System& system) {
+static void SvcWrap_DebugActiveProcess64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
     uint64_t process_id{};
 
-    process_id = Convert<uint64_t>(GetReg64(system, 1));
+    process_id = Convert<uint64_t>(GetArg64(args, 1));
 
     ret = DebugActiveProcess64(system, std::addressof(out_handle), process_id);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_handle));
 }
 
-static void SvcWrap_BreakDebugProcess64(Core::System& system) {
+static void SvcWrap_BreakDebugProcess64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle debug_handle{};
 
-    debug_handle = Convert<Handle>(GetReg64(system, 0));
+    debug_handle = Convert<Handle>(GetArg64(args, 0));
 
     ret = BreakDebugProcess64(system, debug_handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_TerminateDebugProcess64(Core::System& system) {
+static void SvcWrap_TerminateDebugProcess64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle debug_handle{};
 
-    debug_handle = Convert<Handle>(GetReg64(system, 0));
+    debug_handle = Convert<Handle>(GetArg64(args, 0));
 
     ret = TerminateDebugProcess64(system, debug_handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_GetDebugEvent64(Core::System& system) {
+static void SvcWrap_GetDebugEvent64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t out_info{};
     Handle debug_handle{};
 
-    out_info = Convert<uint64_t>(GetReg64(system, 0));
-    debug_handle = Convert<Handle>(GetReg64(system, 1));
+    out_info = Convert<uint64_t>(GetArg64(args, 0));
+    debug_handle = Convert<Handle>(GetArg64(args, 1));
 
     ret = GetDebugEvent64(system, out_info, debug_handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_ContinueDebugEvent64(Core::System& system) {
+static void SvcWrap_ContinueDebugEvent64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle debug_handle{};
@@ -3448,33 +3448,33 @@ static void SvcWrap_ContinueDebugEvent64(Core::System& system) {
     uint64_t thread_ids{};
     int32_t num_thread_ids{};
 
-    debug_handle = Convert<Handle>(GetReg64(system, 0));
-    flags = Convert<uint32_t>(GetReg64(system, 1));
-    thread_ids = Convert<uint64_t>(GetReg64(system, 2));
-    num_thread_ids = Convert<int32_t>(GetReg64(system, 3));
+    debug_handle = Convert<Handle>(GetArg64(args, 0));
+    flags = Convert<uint32_t>(GetArg64(args, 1));
+    thread_ids = Convert<uint64_t>(GetArg64(args, 2));
+    num_thread_ids = Convert<int32_t>(GetArg64(args, 3));
 
     ret = ContinueDebugEvent64(system, debug_handle, flags, thread_ids, num_thread_ids);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_GetProcessList64(Core::System& system) {
+static void SvcWrap_GetProcessList64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int32_t out_num_processes{};
     uint64_t out_process_ids{};
     int32_t max_out_count{};
 
-    out_process_ids = Convert<uint64_t>(GetReg64(system, 1));
-    max_out_count = Convert<int32_t>(GetReg64(system, 2));
+    out_process_ids = Convert<uint64_t>(GetArg64(args, 1));
+    max_out_count = Convert<int32_t>(GetArg64(args, 2));
 
     ret = GetProcessList64(system, std::addressof(out_num_processes), out_process_ids, max_out_count);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_num_processes));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_num_processes));
 }
 
-static void SvcWrap_GetThreadList64(Core::System& system) {
+static void SvcWrap_GetThreadList64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int32_t out_num_threads{};
@@ -3482,17 +3482,17 @@ static void SvcWrap_GetThreadList64(Core::System& system) {
     int32_t max_out_count{};
     Handle debug_handle{};
 
-    out_thread_ids = Convert<uint64_t>(GetReg64(system, 1));
-    max_out_count = Convert<int32_t>(GetReg64(system, 2));
-    debug_handle = Convert<Handle>(GetReg64(system, 3));
+    out_thread_ids = Convert<uint64_t>(GetArg64(args, 1));
+    max_out_count = Convert<int32_t>(GetArg64(args, 2));
+    debug_handle = Convert<Handle>(GetArg64(args, 3));
 
     ret = GetThreadList64(system, std::addressof(out_num_threads), out_thread_ids, max_out_count, debug_handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_num_threads));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_num_threads));
 }
 
-static void SvcWrap_GetDebugThreadContext64(Core::System& system) {
+static void SvcWrap_GetDebugThreadContext64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t out_context{};
@@ -3500,17 +3500,17 @@ static void SvcWrap_GetDebugThreadContext64(Core::System& system) {
     uint64_t thread_id{};
     uint32_t context_flags{};
 
-    out_context = Convert<uint64_t>(GetReg64(system, 0));
-    debug_handle = Convert<Handle>(GetReg64(system, 1));
-    thread_id = Convert<uint64_t>(GetReg64(system, 2));
-    context_flags = Convert<uint32_t>(GetReg64(system, 3));
+    out_context = Convert<uint64_t>(GetArg64(args, 0));
+    debug_handle = Convert<Handle>(GetArg64(args, 1));
+    thread_id = Convert<uint64_t>(GetArg64(args, 2));
+    context_flags = Convert<uint32_t>(GetArg64(args, 3));
 
     ret = GetDebugThreadContext64(system, out_context, debug_handle, thread_id, context_flags);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_SetDebugThreadContext64(Core::System& system) {
+static void SvcWrap_SetDebugThreadContext64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle debug_handle{};
@@ -3518,17 +3518,17 @@ static void SvcWrap_SetDebugThreadContext64(Core::System& system) {
     uint64_t context{};
     uint32_t context_flags{};
 
-    debug_handle = Convert<Handle>(GetReg64(system, 0));
-    thread_id = Convert<uint64_t>(GetReg64(system, 1));
-    context = Convert<uint64_t>(GetReg64(system, 2));
-    context_flags = Convert<uint32_t>(GetReg64(system, 3));
+    debug_handle = Convert<Handle>(GetArg64(args, 0));
+    thread_id = Convert<uint64_t>(GetArg64(args, 1));
+    context = Convert<uint64_t>(GetArg64(args, 2));
+    context_flags = Convert<uint32_t>(GetArg64(args, 3));
 
     ret = SetDebugThreadContext64(system, debug_handle, thread_id, context, context_flags);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_QueryDebugProcessMemory64(Core::System& system) {
+static void SvcWrap_QueryDebugProcessMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     PageInfo out_page_info{};
@@ -3536,17 +3536,17 @@ static void SvcWrap_QueryDebugProcessMemory64(Core::System& system) {
     Handle process_handle{};
     uint64_t address{};
 
-    out_memory_info = Convert<uint64_t>(GetReg64(system, 0));
-    process_handle = Convert<Handle>(GetReg64(system, 2));
-    address = Convert<uint64_t>(GetReg64(system, 3));
+    out_memory_info = Convert<uint64_t>(GetArg64(args, 0));
+    process_handle = Convert<Handle>(GetArg64(args, 2));
+    address = Convert<uint64_t>(GetArg64(args, 3));
 
     ret = QueryDebugProcessMemory64(system, out_memory_info, std::addressof(out_page_info), process_handle, address);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_page_info));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_page_info));
 }
 
-static void SvcWrap_ReadDebugProcessMemory64(Core::System& system) {
+static void SvcWrap_ReadDebugProcessMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t buffer{};
@@ -3554,17 +3554,17 @@ static void SvcWrap_ReadDebugProcessMemory64(Core::System& system) {
     uint64_t address{};
     uint64_t size{};
 
-    buffer = Convert<uint64_t>(GetReg64(system, 0));
-    debug_handle = Convert<Handle>(GetReg64(system, 1));
-    address = Convert<uint64_t>(GetReg64(system, 2));
-    size = Convert<uint64_t>(GetReg64(system, 3));
+    buffer = Convert<uint64_t>(GetArg64(args, 0));
+    debug_handle = Convert<Handle>(GetArg64(args, 1));
+    address = Convert<uint64_t>(GetArg64(args, 2));
+    size = Convert<uint64_t>(GetArg64(args, 3));
 
     ret = ReadDebugProcessMemory64(system, buffer, debug_handle, address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_WriteDebugProcessMemory64(Core::System& system) {
+static void SvcWrap_WriteDebugProcessMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle debug_handle{};
@@ -3572,33 +3572,33 @@ static void SvcWrap_WriteDebugProcessMemory64(Core::System& system) {
     uint64_t address{};
     uint64_t size{};
 
-    debug_handle = Convert<Handle>(GetReg64(system, 0));
-    buffer = Convert<uint64_t>(GetReg64(system, 1));
-    address = Convert<uint64_t>(GetReg64(system, 2));
-    size = Convert<uint64_t>(GetReg64(system, 3));
+    debug_handle = Convert<Handle>(GetArg64(args, 0));
+    buffer = Convert<uint64_t>(GetArg64(args, 1));
+    address = Convert<uint64_t>(GetArg64(args, 2));
+    size = Convert<uint64_t>(GetArg64(args, 3));
 
     ret = WriteDebugProcessMemory64(system, debug_handle, buffer, address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_SetHardwareBreakPoint64(Core::System& system) {
+static void SvcWrap_SetHardwareBreakPoint64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     HardwareBreakPointRegisterName name{};
     uint64_t flags{};
     uint64_t value{};
 
-    name = Convert<HardwareBreakPointRegisterName>(GetReg64(system, 0));
-    flags = Convert<uint64_t>(GetReg64(system, 1));
-    value = Convert<uint64_t>(GetReg64(system, 2));
+    name = Convert<HardwareBreakPointRegisterName>(GetArg64(args, 0));
+    flags = Convert<uint64_t>(GetArg64(args, 1));
+    value = Convert<uint64_t>(GetArg64(args, 2));
 
     ret = SetHardwareBreakPoint64(system, name, flags, value);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_GetDebugThreadParam64(Core::System& system) {
+static void SvcWrap_GetDebugThreadParam64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t out_64{};
@@ -3607,18 +3607,18 @@ static void SvcWrap_GetDebugThreadParam64(Core::System& system) {
     uint64_t thread_id{};
     DebugThreadParam param{};
 
-    debug_handle = Convert<Handle>(GetReg64(system, 2));
-    thread_id = Convert<uint64_t>(GetReg64(system, 3));
-    param = Convert<DebugThreadParam>(GetReg64(system, 4));
+    debug_handle = Convert<Handle>(GetArg64(args, 2));
+    thread_id = Convert<uint64_t>(GetArg64(args, 3));
+    param = Convert<DebugThreadParam>(GetArg64(args, 4));
 
     ret = GetDebugThreadParam64(system, std::addressof(out_64), std::addressof(out_32), debug_handle, thread_id, param);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_64));
-    SetReg64(system, 2, Convert<uint64_t>(out_32));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_64));
+    SetArg64(args, 2, Convert<uint64_t>(out_32));
 }
 
-static void SvcWrap_GetSystemInfo64(Core::System& system) {
+static void SvcWrap_GetSystemInfo64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t out{};
@@ -3626,17 +3626,17 @@ static void SvcWrap_GetSystemInfo64(Core::System& system) {
     Handle handle{};
     uint64_t info_subtype{};
 
-    info_type = Convert<SystemInfoType>(GetReg64(system, 1));
-    handle = Convert<Handle>(GetReg64(system, 2));
-    info_subtype = Convert<uint64_t>(GetReg64(system, 3));
+    info_type = Convert<SystemInfoType>(GetArg64(args, 1));
+    handle = Convert<Handle>(GetArg64(args, 2));
+    info_subtype = Convert<uint64_t>(GetArg64(args, 3));
 
     ret = GetSystemInfo64(system, std::addressof(out), info_type, handle, info_subtype);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out));
 }
 
-static void SvcWrap_CreatePort64(Core::System& system) {
+static void SvcWrap_CreatePort64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_server_handle{};
@@ -3645,48 +3645,48 @@ static void SvcWrap_CreatePort64(Core::System& system) {
     bool is_light{};
     uint64_t name{};
 
-    max_sessions = Convert<int32_t>(GetReg64(system, 2));
-    is_light = Convert<bool>(GetReg64(system, 3));
-    name = Convert<uint64_t>(GetReg64(system, 4));
+    max_sessions = Convert<int32_t>(GetArg64(args, 2));
+    is_light = Convert<bool>(GetArg64(args, 3));
+    name = Convert<uint64_t>(GetArg64(args, 4));
 
     ret = CreatePort64(system, std::addressof(out_server_handle), std::addressof(out_client_handle), max_sessions, is_light, name);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_server_handle));
-    SetReg64(system, 2, Convert<uint64_t>(out_client_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_server_handle));
+    SetArg64(args, 2, Convert<uint64_t>(out_client_handle));
 }
 
-static void SvcWrap_ManageNamedPort64(Core::System& system) {
+static void SvcWrap_ManageNamedPort64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_server_handle{};
     uint64_t name{};
     int32_t max_sessions{};
 
-    name = Convert<uint64_t>(GetReg64(system, 1));
-    max_sessions = Convert<int32_t>(GetReg64(system, 2));
+    name = Convert<uint64_t>(GetArg64(args, 1));
+    max_sessions = Convert<int32_t>(GetArg64(args, 2));
 
     ret = ManageNamedPort64(system, std::addressof(out_server_handle), name, max_sessions);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_server_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_server_handle));
 }
 
-static void SvcWrap_ConnectToPort64(Core::System& system) {
+static void SvcWrap_ConnectToPort64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
     Handle port{};
 
-    port = Convert<Handle>(GetReg64(system, 1));
+    port = Convert<Handle>(GetArg64(args, 1));
 
     ret = ConnectToPort64(system, std::addressof(out_handle), port);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_handle));
 }
 
-static void SvcWrap_SetProcessMemoryPermission64(Core::System& system) {
+static void SvcWrap_SetProcessMemoryPermission64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle process_handle{};
@@ -3694,17 +3694,17 @@ static void SvcWrap_SetProcessMemoryPermission64(Core::System& system) {
     uint64_t size{};
     MemoryPermission perm{};
 
-    process_handle = Convert<Handle>(GetReg64(system, 0));
-    address = Convert<uint64_t>(GetReg64(system, 1));
-    size = Convert<uint64_t>(GetReg64(system, 2));
-    perm = Convert<MemoryPermission>(GetReg64(system, 3));
+    process_handle = Convert<Handle>(GetArg64(args, 0));
+    address = Convert<uint64_t>(GetArg64(args, 1));
+    size = Convert<uint64_t>(GetArg64(args, 2));
+    perm = Convert<MemoryPermission>(GetArg64(args, 3));
 
     ret = SetProcessMemoryPermission64(system, process_handle, address, size, perm);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_MapProcessMemory64(Core::System& system) {
+static void SvcWrap_MapProcessMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t dst_address{};
@@ -3712,17 +3712,17 @@ static void SvcWrap_MapProcessMemory64(Core::System& system) {
     uint64_t src_address{};
     uint64_t size{};
 
-    dst_address = Convert<uint64_t>(GetReg64(system, 0));
-    process_handle = Convert<Handle>(GetReg64(system, 1));
-    src_address = Convert<uint64_t>(GetReg64(system, 2));
-    size = Convert<uint64_t>(GetReg64(system, 3));
+    dst_address = Convert<uint64_t>(GetArg64(args, 0));
+    process_handle = Convert<Handle>(GetArg64(args, 1));
+    src_address = Convert<uint64_t>(GetArg64(args, 2));
+    size = Convert<uint64_t>(GetArg64(args, 3));
 
     ret = MapProcessMemory64(system, dst_address, process_handle, src_address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_UnmapProcessMemory64(Core::System& system) {
+static void SvcWrap_UnmapProcessMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t dst_address{};
@@ -3730,17 +3730,17 @@ static void SvcWrap_UnmapProcessMemory64(Core::System& system) {
     uint64_t src_address{};
     uint64_t size{};
 
-    dst_address = Convert<uint64_t>(GetReg64(system, 0));
-    process_handle = Convert<Handle>(GetReg64(system, 1));
-    src_address = Convert<uint64_t>(GetReg64(system, 2));
-    size = Convert<uint64_t>(GetReg64(system, 3));
+    dst_address = Convert<uint64_t>(GetArg64(args, 0));
+    process_handle = Convert<Handle>(GetArg64(args, 1));
+    src_address = Convert<uint64_t>(GetArg64(args, 2));
+    size = Convert<uint64_t>(GetArg64(args, 3));
 
     ret = UnmapProcessMemory64(system, dst_address, process_handle, src_address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_QueryProcessMemory64(Core::System& system) {
+static void SvcWrap_QueryProcessMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     PageInfo out_page_info{};
@@ -3748,17 +3748,17 @@ static void SvcWrap_QueryProcessMemory64(Core::System& system) {
     Handle process_handle{};
     uint64_t address{};
 
-    out_memory_info = Convert<uint64_t>(GetReg64(system, 0));
-    process_handle = Convert<Handle>(GetReg64(system, 2));
-    address = Convert<uint64_t>(GetReg64(system, 3));
+    out_memory_info = Convert<uint64_t>(GetArg64(args, 0));
+    process_handle = Convert<Handle>(GetArg64(args, 2));
+    address = Convert<uint64_t>(GetArg64(args, 3));
 
     ret = QueryProcessMemory64(system, out_memory_info, std::addressof(out_page_info), process_handle, address);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_page_info));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_page_info));
 }
 
-static void SvcWrap_MapProcessCodeMemory64(Core::System& system) {
+static void SvcWrap_MapProcessCodeMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle process_handle{};
@@ -3766,17 +3766,17 @@ static void SvcWrap_MapProcessCodeMemory64(Core::System& system) {
     uint64_t src_address{};
     uint64_t size{};
 
-    process_handle = Convert<Handle>(GetReg64(system, 0));
-    dst_address = Convert<uint64_t>(GetReg64(system, 1));
-    src_address = Convert<uint64_t>(GetReg64(system, 2));
-    size = Convert<uint64_t>(GetReg64(system, 3));
+    process_handle = Convert<Handle>(GetArg64(args, 0));
+    dst_address = Convert<uint64_t>(GetArg64(args, 1));
+    src_address = Convert<uint64_t>(GetArg64(args, 2));
+    size = Convert<uint64_t>(GetArg64(args, 3));
 
     ret = MapProcessCodeMemory64(system, process_handle, dst_address, src_address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_UnmapProcessCodeMemory64(Core::System& system) {
+static void SvcWrap_UnmapProcessCodeMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle process_handle{};
@@ -3784,17 +3784,17 @@ static void SvcWrap_UnmapProcessCodeMemory64(Core::System& system) {
     uint64_t src_address{};
     uint64_t size{};
 
-    process_handle = Convert<Handle>(GetReg64(system, 0));
-    dst_address = Convert<uint64_t>(GetReg64(system, 1));
-    src_address = Convert<uint64_t>(GetReg64(system, 2));
-    size = Convert<uint64_t>(GetReg64(system, 3));
+    process_handle = Convert<Handle>(GetArg64(args, 0));
+    dst_address = Convert<uint64_t>(GetArg64(args, 1));
+    src_address = Convert<uint64_t>(GetArg64(args, 2));
+    size = Convert<uint64_t>(GetArg64(args, 3));
 
     ret = UnmapProcessCodeMemory64(system, process_handle, dst_address, src_address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_CreateProcess64(Core::System& system) {
+static void SvcWrap_CreateProcess64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
@@ -3802,17 +3802,17 @@ static void SvcWrap_CreateProcess64(Core::System& system) {
     uint64_t caps{};
     int32_t num_caps{};
 
-    parameters = Convert<uint64_t>(GetReg64(system, 1));
-    caps = Convert<uint64_t>(GetReg64(system, 2));
-    num_caps = Convert<int32_t>(GetReg64(system, 3));
+    parameters = Convert<uint64_t>(GetArg64(args, 1));
+    caps = Convert<uint64_t>(GetArg64(args, 2));
+    num_caps = Convert<int32_t>(GetArg64(args, 3));
 
     ret = CreateProcess64(system, std::addressof(out_handle), parameters, caps, num_caps);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_handle));
 }
 
-static void SvcWrap_StartProcess64(Core::System& system) {
+static void SvcWrap_StartProcess64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle process_handle{};
@@ -3820,601 +3820,601 @@ static void SvcWrap_StartProcess64(Core::System& system) {
     int32_t core_id{};
     uint64_t main_thread_stack_size{};
 
-    process_handle = Convert<Handle>(GetReg64(system, 0));
-    priority = Convert<int32_t>(GetReg64(system, 1));
-    core_id = Convert<int32_t>(GetReg64(system, 2));
-    main_thread_stack_size = Convert<uint64_t>(GetReg64(system, 3));
+    process_handle = Convert<Handle>(GetArg64(args, 0));
+    priority = Convert<int32_t>(GetArg64(args, 1));
+    core_id = Convert<int32_t>(GetArg64(args, 2));
+    main_thread_stack_size = Convert<uint64_t>(GetArg64(args, 3));
 
     ret = StartProcess64(system, process_handle, priority, core_id, main_thread_stack_size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_TerminateProcess64(Core::System& system) {
+static void SvcWrap_TerminateProcess64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle process_handle{};
 
-    process_handle = Convert<Handle>(GetReg64(system, 0));
+    process_handle = Convert<Handle>(GetArg64(args, 0));
 
     ret = TerminateProcess64(system, process_handle);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_GetProcessInfo64(Core::System& system) {
+static void SvcWrap_GetProcessInfo64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     int64_t out_info{};
     Handle process_handle{};
     ProcessInfoType info_type{};
 
-    process_handle = Convert<Handle>(GetReg64(system, 1));
-    info_type = Convert<ProcessInfoType>(GetReg64(system, 2));
+    process_handle = Convert<Handle>(GetArg64(args, 1));
+    info_type = Convert<ProcessInfoType>(GetArg64(args, 2));
 
     ret = GetProcessInfo64(system, std::addressof(out_info), process_handle, info_type);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_info));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_info));
 }
 
-static void SvcWrap_CreateResourceLimit64(Core::System& system) {
+static void SvcWrap_CreateResourceLimit64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle out_handle{};
 
     ret = CreateResourceLimit64(system, std::addressof(out_handle));
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
-    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 1, Convert<uint64_t>(out_handle));
 }
 
-static void SvcWrap_SetResourceLimitLimitValue64(Core::System& system) {
+static void SvcWrap_SetResourceLimitLimitValue64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     Handle resource_limit_handle{};
     LimitableResource which{};
     int64_t limit_value{};
 
-    resource_limit_handle = Convert<Handle>(GetReg64(system, 0));
-    which = Convert<LimitableResource>(GetReg64(system, 1));
-    limit_value = Convert<int64_t>(GetReg64(system, 2));
+    resource_limit_handle = Convert<Handle>(GetArg64(args, 0));
+    which = Convert<LimitableResource>(GetArg64(args, 1));
+    limit_value = Convert<int64_t>(GetArg64(args, 2));
 
     ret = SetResourceLimitLimitValue64(system, resource_limit_handle, which, limit_value);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_MapInsecureMemory64(Core::System& system) {
+static void SvcWrap_MapInsecureMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t address{};
     uint64_t size{};
 
-    address = Convert<uint64_t>(GetReg64(system, 0));
-    size = Convert<uint64_t>(GetReg64(system, 1));
+    address = Convert<uint64_t>(GetArg64(args, 0));
+    size = Convert<uint64_t>(GetArg64(args, 1));
 
     ret = MapInsecureMemory64(system, address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void SvcWrap_UnmapInsecureMemory64(Core::System& system) {
+static void SvcWrap_UnmapInsecureMemory64(Core::System& system, std::span<uint64_t, 8> args) {
     Result ret{};
 
     uint64_t address{};
     uint64_t size{};
 
-    address = Convert<uint64_t>(GetReg64(system, 0));
-    size = Convert<uint64_t>(GetReg64(system, 1));
+    address = Convert<uint64_t>(GetArg64(args, 0));
+    size = Convert<uint64_t>(GetArg64(args, 1));
 
     ret = UnmapInsecureMemory64(system, address, size);
 
-    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetArg64(args, 0, Convert<uint64_t>(ret));
 }
 
-static void Call32(Core::System& system, u32 imm) {
+static void Call32(Core::System& system, u32 imm, std::span<uint64_t, 8> args) {
     switch (static_cast<SvcId>(imm)) {
     case SvcId::SetHeapSize:
-        return SvcWrap_SetHeapSize64From32(system);
+        return SvcWrap_SetHeapSize64From32(system, args);
     case SvcId::SetMemoryPermission:
-        return SvcWrap_SetMemoryPermission64From32(system);
+        return SvcWrap_SetMemoryPermission64From32(system, args);
     case SvcId::SetMemoryAttribute:
-        return SvcWrap_SetMemoryAttribute64From32(system);
+        return SvcWrap_SetMemoryAttribute64From32(system, args);
     case SvcId::MapMemory:
-        return SvcWrap_MapMemory64From32(system);
+        return SvcWrap_MapMemory64From32(system, args);
     case SvcId::UnmapMemory:
-        return SvcWrap_UnmapMemory64From32(system);
+        return SvcWrap_UnmapMemory64From32(system, args);
     case SvcId::QueryMemory:
-        return SvcWrap_QueryMemory64From32(system);
+        return SvcWrap_QueryMemory64From32(system, args);
     case SvcId::ExitProcess:
-        return SvcWrap_ExitProcess64From32(system);
+        return SvcWrap_ExitProcess64From32(system, args);
     case SvcId::CreateThread:
-        return SvcWrap_CreateThread64From32(system);
+        return SvcWrap_CreateThread64From32(system, args);
     case SvcId::StartThread:
-        return SvcWrap_StartThread64From32(system);
+        return SvcWrap_StartThread64From32(system, args);
     case SvcId::ExitThread:
-        return SvcWrap_ExitThread64From32(system);
+        return SvcWrap_ExitThread64From32(system, args);
     case SvcId::SleepThread:
-        return SvcWrap_SleepThread64From32(system);
+        return SvcWrap_SleepThread64From32(system, args);
     case SvcId::GetThreadPriority:
-        return SvcWrap_GetThreadPriority64From32(system);
+        return SvcWrap_GetThreadPriority64From32(system, args);
     case SvcId::SetThreadPriority:
-        return SvcWrap_SetThreadPriority64From32(system);
+        return SvcWrap_SetThreadPriority64From32(system, args);
     case SvcId::GetThreadCoreMask:
-        return SvcWrap_GetThreadCoreMask64From32(system);
+        return SvcWrap_GetThreadCoreMask64From32(system, args);
     case SvcId::SetThreadCoreMask:
-        return SvcWrap_SetThreadCoreMask64From32(system);
+        return SvcWrap_SetThreadCoreMask64From32(system, args);
     case SvcId::GetCurrentProcessorNumber:
-        return SvcWrap_GetCurrentProcessorNumber64From32(system);
+        return SvcWrap_GetCurrentProcessorNumber64From32(system, args);
     case SvcId::SignalEvent:
-        return SvcWrap_SignalEvent64From32(system);
+        return SvcWrap_SignalEvent64From32(system, args);
     case SvcId::ClearEvent:
-        return SvcWrap_ClearEvent64From32(system);
+        return SvcWrap_ClearEvent64From32(system, args);
     case SvcId::MapSharedMemory:
-        return SvcWrap_MapSharedMemory64From32(system);
+        return SvcWrap_MapSharedMemory64From32(system, args);
     case SvcId::UnmapSharedMemory:
-        return SvcWrap_UnmapSharedMemory64From32(system);
+        return SvcWrap_UnmapSharedMemory64From32(system, args);
     case SvcId::CreateTransferMemory:
-        return SvcWrap_CreateTransferMemory64From32(system);
+        return SvcWrap_CreateTransferMemory64From32(system, args);
     case SvcId::CloseHandle:
-        return SvcWrap_CloseHandle64From32(system);
+        return SvcWrap_CloseHandle64From32(system, args);
     case SvcId::ResetSignal:
-        return SvcWrap_ResetSignal64From32(system);
+        return SvcWrap_ResetSignal64From32(system, args);
     case SvcId::WaitSynchronization:
-        return SvcWrap_WaitSynchronization64From32(system);
+        return SvcWrap_WaitSynchronization64From32(system, args);
     case SvcId::CancelSynchronization:
-        return SvcWrap_CancelSynchronization64From32(system);
+        return SvcWrap_CancelSynchronization64From32(system, args);
     case SvcId::ArbitrateLock:
-        return SvcWrap_ArbitrateLock64From32(system);
+        return SvcWrap_ArbitrateLock64From32(system, args);
     case SvcId::ArbitrateUnlock:
-        return SvcWrap_ArbitrateUnlock64From32(system);
+        return SvcWrap_ArbitrateUnlock64From32(system, args);
     case SvcId::WaitProcessWideKeyAtomic:
-        return SvcWrap_WaitProcessWideKeyAtomic64From32(system);
+        return SvcWrap_WaitProcessWideKeyAtomic64From32(system, args);
     case SvcId::SignalProcessWideKey:
-        return SvcWrap_SignalProcessWideKey64From32(system);
+        return SvcWrap_SignalProcessWideKey64From32(system, args);
     case SvcId::GetSystemTick:
-        return SvcWrap_GetSystemTick64From32(system);
+        return SvcWrap_GetSystemTick64From32(system, args);
     case SvcId::ConnectToNamedPort:
-        return SvcWrap_ConnectToNamedPort64From32(system);
+        return SvcWrap_ConnectToNamedPort64From32(system, args);
     case SvcId::SendSyncRequestLight:
-        return SvcWrap_SendSyncRequestLight64From32(system);
+        return SvcWrap_SendSyncRequestLight64From32(system, args);
     case SvcId::SendSyncRequest:
-        return SvcWrap_SendSyncRequest64From32(system);
+        return SvcWrap_SendSyncRequest64From32(system, args);
     case SvcId::SendSyncRequestWithUserBuffer:
-        return SvcWrap_SendSyncRequestWithUserBuffer64From32(system);
+        return SvcWrap_SendSyncRequestWithUserBuffer64From32(system, args);
     case SvcId::SendAsyncRequestWithUserBuffer:
-        return SvcWrap_SendAsyncRequestWithUserBuffer64From32(system);
+        return SvcWrap_SendAsyncRequestWithUserBuffer64From32(system, args);
     case SvcId::GetProcessId:
-        return SvcWrap_GetProcessId64From32(system);
+        return SvcWrap_GetProcessId64From32(system, args);
     case SvcId::GetThreadId:
-        return SvcWrap_GetThreadId64From32(system);
+        return SvcWrap_GetThreadId64From32(system, args);
     case SvcId::Break:
-        return SvcWrap_Break64From32(system);
+        return SvcWrap_Break64From32(system, args);
     case SvcId::OutputDebugString:
-        return SvcWrap_OutputDebugString64From32(system);
+        return SvcWrap_OutputDebugString64From32(system, args);
     case SvcId::ReturnFromException:
-        return SvcWrap_ReturnFromException64From32(system);
+        return SvcWrap_ReturnFromException64From32(system, args);
     case SvcId::GetInfo:
-        return SvcWrap_GetInfo64From32(system);
+        return SvcWrap_GetInfo64From32(system, args);
     case SvcId::FlushEntireDataCache:
-        return SvcWrap_FlushEntireDataCache64From32(system);
+        return SvcWrap_FlushEntireDataCache64From32(system, args);
     case SvcId::FlushDataCache:
-        return SvcWrap_FlushDataCache64From32(system);
+        return SvcWrap_FlushDataCache64From32(system, args);
     case SvcId::MapPhysicalMemory:
-        return SvcWrap_MapPhysicalMemory64From32(system);
+        return SvcWrap_MapPhysicalMemory64From32(system, args);
     case SvcId::UnmapPhysicalMemory:
-        return SvcWrap_UnmapPhysicalMemory64From32(system);
+        return SvcWrap_UnmapPhysicalMemory64From32(system, args);
     case SvcId::GetDebugFutureThreadInfo:
-        return SvcWrap_GetDebugFutureThreadInfo64From32(system);
+        return SvcWrap_GetDebugFutureThreadInfo64From32(system, args);
     case SvcId::GetLastThreadInfo:
-        return SvcWrap_GetLastThreadInfo64From32(system);
+        return SvcWrap_GetLastThreadInfo64From32(system, args);
     case SvcId::GetResourceLimitLimitValue:
-        return SvcWrap_GetResourceLimitLimitValue64From32(system);
+        return SvcWrap_GetResourceLimitLimitValue64From32(system, args);
     case SvcId::GetResourceLimitCurrentValue:
-        return SvcWrap_GetResourceLimitCurrentValue64From32(system);
+        return SvcWrap_GetResourceLimitCurrentValue64From32(system, args);
     case SvcId::SetThreadActivity:
-        return SvcWrap_SetThreadActivity64From32(system);
+        return SvcWrap_SetThreadActivity64From32(system, args);
     case SvcId::GetThreadContext3:
-        return SvcWrap_GetThreadContext364From32(system);
+        return SvcWrap_GetThreadContext364From32(system, args);
     case SvcId::WaitForAddress:
-        return SvcWrap_WaitForAddress64From32(system);
+        return SvcWrap_WaitForAddress64From32(system, args);
     case SvcId::SignalToAddress:
-        return SvcWrap_SignalToAddress64From32(system);
+        return SvcWrap_SignalToAddress64From32(system, args);
     case SvcId::SynchronizePreemptionState:
-        return SvcWrap_SynchronizePreemptionState64From32(system);
+        return SvcWrap_SynchronizePreemptionState64From32(system, args);
     case SvcId::GetResourceLimitPeakValue:
-        return SvcWrap_GetResourceLimitPeakValue64From32(system);
+        return SvcWrap_GetResourceLimitPeakValue64From32(system, args);
     case SvcId::CreateIoPool:
-        return SvcWrap_CreateIoPool64From32(system);
+        return SvcWrap_CreateIoPool64From32(system, args);
     case SvcId::CreateIoRegion:
-        return SvcWrap_CreateIoRegion64From32(system);
+        return SvcWrap_CreateIoRegion64From32(system, args);
     case SvcId::KernelDebug:
-        return SvcWrap_KernelDebug64From32(system);
+        return SvcWrap_KernelDebug64From32(system, args);
     case SvcId::ChangeKernelTraceState:
-        return SvcWrap_ChangeKernelTraceState64From32(system);
+        return SvcWrap_ChangeKernelTraceState64From32(system, args);
     case SvcId::CreateSession:
-        return SvcWrap_CreateSession64From32(system);
+        return SvcWrap_CreateSession64From32(system, args);
     case SvcId::AcceptSession:
-        return SvcWrap_AcceptSession64From32(system);
+        return SvcWrap_AcceptSession64From32(system, args);
     case SvcId::ReplyAndReceiveLight:
-        return SvcWrap_ReplyAndReceiveLight64From32(system);
+        return SvcWrap_ReplyAndReceiveLight64From32(system, args);
     case SvcId::ReplyAndReceive:
-        return SvcWrap_ReplyAndReceive64From32(system);
+        return SvcWrap_ReplyAndReceive64From32(system, args);
     case SvcId::ReplyAndReceiveWithUserBuffer:
-        return SvcWrap_ReplyAndReceiveWithUserBuffer64From32(system);
+        return SvcWrap_ReplyAndReceiveWithUserBuffer64From32(system, args);
     case SvcId::CreateEvent:
-        return SvcWrap_CreateEvent64From32(system);
+        return SvcWrap_CreateEvent64From32(system, args);
     case SvcId::MapIoRegion:
-        return SvcWrap_MapIoRegion64From32(system);
+        return SvcWrap_MapIoRegion64From32(system, args);
     case SvcId::UnmapIoRegion:
-        return SvcWrap_UnmapIoRegion64From32(system);
+        return SvcWrap_UnmapIoRegion64From32(system, args);
     case SvcId::MapPhysicalMemoryUnsafe:
-        return SvcWrap_MapPhysicalMemoryUnsafe64From32(system);
+        return SvcWrap_MapPhysicalMemoryUnsafe64From32(system, args);
     case SvcId::UnmapPhysicalMemoryUnsafe:
-        return SvcWrap_UnmapPhysicalMemoryUnsafe64From32(system);
+        return SvcWrap_UnmapPhysicalMemoryUnsafe64From32(system, args);
     case SvcId::SetUnsafeLimit:
-        return SvcWrap_SetUnsafeLimit64From32(system);
+        return SvcWrap_SetUnsafeLimit64From32(system, args);
     case SvcId::CreateCodeMemory:
-        return SvcWrap_CreateCodeMemory64From32(system);
+        return SvcWrap_CreateCodeMemory64From32(system, args);
     case SvcId::ControlCodeMemory:
-        return SvcWrap_ControlCodeMemory64From32(system);
+        return SvcWrap_ControlCodeMemory64From32(system, args);
     case SvcId::SleepSystem:
-        return SvcWrap_SleepSystem64From32(system);
+        return SvcWrap_SleepSystem64From32(system, args);
     case SvcId::ReadWriteRegister:
-        return SvcWrap_ReadWriteRegister64From32(system);
+        return SvcWrap_ReadWriteRegister64From32(system, args);
     case SvcId::SetProcessActivity:
-        return SvcWrap_SetProcessActivity64From32(system);
+        return SvcWrap_SetProcessActivity64From32(system, args);
     case SvcId::CreateSharedMemory:
-        return SvcWrap_CreateSharedMemory64From32(system);
+        return SvcWrap_CreateSharedMemory64From32(system, args);
     case SvcId::MapTransferMemory:
-        return SvcWrap_MapTransferMemory64From32(system);
+        return SvcWrap_MapTransferMemory64From32(system, args);
     case SvcId::UnmapTransferMemory:
-        return SvcWrap_UnmapTransferMemory64From32(system);
+        return SvcWrap_UnmapTransferMemory64From32(system, args);
     case SvcId::CreateInterruptEvent:
-        return SvcWrap_CreateInterruptEvent64From32(system);
+        return SvcWrap_CreateInterruptEvent64From32(system, args);
     case SvcId::QueryPhysicalAddress:
-        return SvcWrap_QueryPhysicalAddress64From32(system);
+        return SvcWrap_QueryPhysicalAddress64From32(system, args);
     case SvcId::QueryIoMapping:
-        return SvcWrap_QueryIoMapping64From32(system);
+        return SvcWrap_QueryIoMapping64From32(system, args);
     case SvcId::CreateDeviceAddressSpace:
-        return SvcWrap_CreateDeviceAddressSpace64From32(system);
+        return SvcWrap_CreateDeviceAddressSpace64From32(system, args);
     case SvcId::AttachDeviceAddressSpace:
-        return SvcWrap_AttachDeviceAddressSpace64From32(system);
+        return SvcWrap_AttachDeviceAddressSpace64From32(system, args);
     case SvcId::DetachDeviceAddressSpace:
-        return SvcWrap_DetachDeviceAddressSpace64From32(system);
+        return SvcWrap_DetachDeviceAddressSpace64From32(system, args);
     case SvcId::MapDeviceAddressSpaceByForce:
-        return SvcWrap_MapDeviceAddressSpaceByForce64From32(system);
+        return SvcWrap_MapDeviceAddressSpaceByForce64From32(system, args);
     case SvcId::MapDeviceAddressSpaceAligned:
-        return SvcWrap_MapDeviceAddressSpaceAligned64From32(system);
+        return SvcWrap_MapDeviceAddressSpaceAligned64From32(system, args);
     case SvcId::UnmapDeviceAddressSpace:
-        return SvcWrap_UnmapDeviceAddressSpace64From32(system);
+        return SvcWrap_UnmapDeviceAddressSpace64From32(system, args);
     case SvcId::InvalidateProcessDataCache:
-        return SvcWrap_InvalidateProcessDataCache64From32(system);
+        return SvcWrap_InvalidateProcessDataCache64From32(system, args);
     case SvcId::StoreProcessDataCache:
-        return SvcWrap_StoreProcessDataCache64From32(system);
+        return SvcWrap_StoreProcessDataCache64From32(system, args);
     case SvcId::FlushProcessDataCache:
-        return SvcWrap_FlushProcessDataCache64From32(system);
+        return SvcWrap_FlushProcessDataCache64From32(system, args);
     case SvcId::DebugActiveProcess:
-        return SvcWrap_DebugActiveProcess64From32(system);
+        return SvcWrap_DebugActiveProcess64From32(system, args);
     case SvcId::BreakDebugProcess:
-        return SvcWrap_BreakDebugProcess64From32(system);
+        return SvcWrap_BreakDebugProcess64From32(system, args);
     case SvcId::TerminateDebugProcess:
-        return SvcWrap_TerminateDebugProcess64From32(system);
+        return SvcWrap_TerminateDebugProcess64From32(system, args);
     case SvcId::GetDebugEvent:
-        return SvcWrap_GetDebugEvent64From32(system);
+        return SvcWrap_GetDebugEvent64From32(system, args);
     case SvcId::ContinueDebugEvent:
-        return SvcWrap_ContinueDebugEvent64From32(system);
+        return SvcWrap_ContinueDebugEvent64From32(system, args);
     case SvcId::GetProcessList:
-        return SvcWrap_GetProcessList64From32(system);
+        return SvcWrap_GetProcessList64From32(system, args);
     case SvcId::GetThreadList:
-        return SvcWrap_GetThreadList64From32(system);
+        return SvcWrap_GetThreadList64From32(system, args);
     case SvcId::GetDebugThreadContext:
-        return SvcWrap_GetDebugThreadContext64From32(system);
+        return SvcWrap_GetDebugThreadContext64From32(system, args);
     case SvcId::SetDebugThreadContext:
-        return SvcWrap_SetDebugThreadContext64From32(system);
+        return SvcWrap_SetDebugThreadContext64From32(system, args);
     case SvcId::QueryDebugProcessMemory:
-        return SvcWrap_QueryDebugProcessMemory64From32(system);
+        return SvcWrap_QueryDebugProcessMemory64From32(system, args);
     case SvcId::ReadDebugProcessMemory:
-        return SvcWrap_ReadDebugProcessMemory64From32(system);
+        return SvcWrap_ReadDebugProcessMemory64From32(system, args);
     case SvcId::WriteDebugProcessMemory:
-        return SvcWrap_WriteDebugProcessMemory64From32(system);
+        return SvcWrap_WriteDebugProcessMemory64From32(system, args);
     case SvcId::SetHardwareBreakPoint:
-        return SvcWrap_SetHardwareBreakPoint64From32(system);
+        return SvcWrap_SetHardwareBreakPoint64From32(system, args);
     case SvcId::GetDebugThreadParam:
-        return SvcWrap_GetDebugThreadParam64From32(system);
+        return SvcWrap_GetDebugThreadParam64From32(system, args);
     case SvcId::GetSystemInfo:
-        return SvcWrap_GetSystemInfo64From32(system);
+        return SvcWrap_GetSystemInfo64From32(system, args);
     case SvcId::CreatePort:
-        return SvcWrap_CreatePort64From32(system);
+        return SvcWrap_CreatePort64From32(system, args);
     case SvcId::ManageNamedPort:
-        return SvcWrap_ManageNamedPort64From32(system);
+        return SvcWrap_ManageNamedPort64From32(system, args);
     case SvcId::ConnectToPort:
-        return SvcWrap_ConnectToPort64From32(system);
+        return SvcWrap_ConnectToPort64From32(system, args);
     case SvcId::SetProcessMemoryPermission:
-        return SvcWrap_SetProcessMemoryPermission64From32(system);
+        return SvcWrap_SetProcessMemoryPermission64From32(system, args);
     case SvcId::MapProcessMemory:
-        return SvcWrap_MapProcessMemory64From32(system);
+        return SvcWrap_MapProcessMemory64From32(system, args);
     case SvcId::UnmapProcessMemory:
-        return SvcWrap_UnmapProcessMemory64From32(system);
+        return SvcWrap_UnmapProcessMemory64From32(system, args);
     case SvcId::QueryProcessMemory:
-        return SvcWrap_QueryProcessMemory64From32(system);
+        return SvcWrap_QueryProcessMemory64From32(system, args);
     case SvcId::MapProcessCodeMemory:
-        return SvcWrap_MapProcessCodeMemory64From32(system);
+        return SvcWrap_MapProcessCodeMemory64From32(system, args);
     case SvcId::UnmapProcessCodeMemory:
-        return SvcWrap_UnmapProcessCodeMemory64From32(system);
+        return SvcWrap_UnmapProcessCodeMemory64From32(system, args);
     case SvcId::CreateProcess:
-        return SvcWrap_CreateProcess64From32(system);
+        return SvcWrap_CreateProcess64From32(system, args);
     case SvcId::StartProcess:
-        return SvcWrap_StartProcess64From32(system);
+        return SvcWrap_StartProcess64From32(system, args);
     case SvcId::TerminateProcess:
-        return SvcWrap_TerminateProcess64From32(system);
+        return SvcWrap_TerminateProcess64From32(system, args);
     case SvcId::GetProcessInfo:
-        return SvcWrap_GetProcessInfo64From32(system);
+        return SvcWrap_GetProcessInfo64From32(system, args);
     case SvcId::CreateResourceLimit:
-        return SvcWrap_CreateResourceLimit64From32(system);
+        return SvcWrap_CreateResourceLimit64From32(system, args);
     case SvcId::SetResourceLimitLimitValue:
-        return SvcWrap_SetResourceLimitLimitValue64From32(system);
+        return SvcWrap_SetResourceLimitLimitValue64From32(system, args);
     case SvcId::CallSecureMonitor:
-        return SvcWrap_CallSecureMonitor64From32(system);
+        return SvcWrap_CallSecureMonitor64From32(system, args);
     case SvcId::MapInsecureMemory:
-        return SvcWrap_MapInsecureMemory64From32(system);
+        return SvcWrap_MapInsecureMemory64From32(system, args);
     case SvcId::UnmapInsecureMemory:
-        return SvcWrap_UnmapInsecureMemory64From32(system);
+        return SvcWrap_UnmapInsecureMemory64From32(system, args);
     default:
         LOG_CRITICAL(Kernel_SVC, "Unknown SVC {:x}!", imm);
         break;
     }
 }
 
-static void Call64(Core::System& system, u32 imm) {
+static void Call64(Core::System& system, u32 imm, std::span<uint64_t, 8> args) {
     switch (static_cast<SvcId>(imm)) {
     case SvcId::SetHeapSize:
-        return SvcWrap_SetHeapSize64(system);
+        return SvcWrap_SetHeapSize64(system, args);
     case SvcId::SetMemoryPermission:
-        return SvcWrap_SetMemoryPermission64(system);
+        return SvcWrap_SetMemoryPermission64(system, args);
     case SvcId::SetMemoryAttribute:
-        return SvcWrap_SetMemoryAttribute64(system);
+        return SvcWrap_SetMemoryAttribute64(system, args);
     case SvcId::MapMemory:
-        return SvcWrap_MapMemory64(system);
+        return SvcWrap_MapMemory64(system, args);
     case SvcId::UnmapMemory:
-        return SvcWrap_UnmapMemory64(system);
+        return SvcWrap_UnmapMemory64(system, args);
     case SvcId::QueryMemory:
-        return SvcWrap_QueryMemory64(system);
+        return SvcWrap_QueryMemory64(system, args);
     case SvcId::ExitProcess:
-        return SvcWrap_ExitProcess64(system);
+        return SvcWrap_ExitProcess64(system, args);
     case SvcId::CreateThread:
-        return SvcWrap_CreateThread64(system);
+        return SvcWrap_CreateThread64(system, args);
     case SvcId::StartThread:
-        return SvcWrap_StartThread64(system);
+        return SvcWrap_StartThread64(system, args);
     case SvcId::ExitThread:
-        return SvcWrap_ExitThread64(system);
+        return SvcWrap_ExitThread64(system, args);
     case SvcId::SleepThread:
-        return SvcWrap_SleepThread64(system);
+        return SvcWrap_SleepThread64(system, args);
     case SvcId::GetThreadPriority:
-        return SvcWrap_GetThreadPriority64(system);
+        return SvcWrap_GetThreadPriority64(system, args);
     case SvcId::SetThreadPriority:
-        return SvcWrap_SetThreadPriority64(system);
+        return SvcWrap_SetThreadPriority64(system, args);
     case SvcId::GetThreadCoreMask:
-        return SvcWrap_GetThreadCoreMask64(system);
+        return SvcWrap_GetThreadCoreMask64(system, args);
     case SvcId::SetThreadCoreMask:
-        return SvcWrap_SetThreadCoreMask64(system);
+        return SvcWrap_SetThreadCoreMask64(system, args);
     case SvcId::GetCurrentProcessorNumber:
-        return SvcWrap_GetCurrentProcessorNumber64(system);
+        return SvcWrap_GetCurrentProcessorNumber64(system, args);
     case SvcId::SignalEvent:
-        return SvcWrap_SignalEvent64(system);
+        return SvcWrap_SignalEvent64(system, args);
     case SvcId::ClearEvent:
-        return SvcWrap_ClearEvent64(system);
+        return SvcWrap_ClearEvent64(system, args);
     case SvcId::MapSharedMemory:
-        return SvcWrap_MapSharedMemory64(system);
+        return SvcWrap_MapSharedMemory64(system, args);
     case SvcId::UnmapSharedMemory:
-        return SvcWrap_UnmapSharedMemory64(system);
+        return SvcWrap_UnmapSharedMemory64(system, args);
     case SvcId::CreateTransferMemory:
-        return SvcWrap_CreateTransferMemory64(system);
+        return SvcWrap_CreateTransferMemory64(system, args);
     case SvcId::CloseHandle:
-        return SvcWrap_CloseHandle64(system);
+        return SvcWrap_CloseHandle64(system, args);
     case SvcId::ResetSignal:
-        return SvcWrap_ResetSignal64(system);
+        return SvcWrap_ResetSignal64(system, args);
     case SvcId::WaitSynchronization:
-        return SvcWrap_WaitSynchronization64(system);
+        return SvcWrap_WaitSynchronization64(system, args);
     case SvcId::CancelSynchronization:
-        return SvcWrap_CancelSynchronization64(system);
+        return SvcWrap_CancelSynchronization64(system, args);
     case SvcId::ArbitrateLock:
-        return SvcWrap_ArbitrateLock64(system);
+        return SvcWrap_ArbitrateLock64(system, args);
     case SvcId::ArbitrateUnlock:
-        return SvcWrap_ArbitrateUnlock64(system);
+        return SvcWrap_ArbitrateUnlock64(system, args);
     case SvcId::WaitProcessWideKeyAtomic:
-        return SvcWrap_WaitProcessWideKeyAtomic64(system);
+        return SvcWrap_WaitProcessWideKeyAtomic64(system, args);
     case SvcId::SignalProcessWideKey:
-        return SvcWrap_SignalProcessWideKey64(system);
+        return SvcWrap_SignalProcessWideKey64(system, args);
     case SvcId::GetSystemTick:
-        return SvcWrap_GetSystemTick64(system);
+        return SvcWrap_GetSystemTick64(system, args);
     case SvcId::ConnectToNamedPort:
-        return SvcWrap_ConnectToNamedPort64(system);
+        return SvcWrap_ConnectToNamedPort64(system, args);
     case SvcId::SendSyncRequestLight:
-        return SvcWrap_SendSyncRequestLight64(system);
+        return SvcWrap_SendSyncRequestLight64(system, args);
     case SvcId::SendSyncRequest:
-        return SvcWrap_SendSyncRequest64(system);
+        return SvcWrap_SendSyncRequest64(system, args);
     case SvcId::SendSyncRequestWithUserBuffer:
-        return SvcWrap_SendSyncRequestWithUserBuffer64(system);
+        return SvcWrap_SendSyncRequestWithUserBuffer64(system, args);
     case SvcId::SendAsyncRequestWithUserBuffer:
-        return SvcWrap_SendAsyncRequestWithUserBuffer64(system);
+        return SvcWrap_SendAsyncRequestWithUserBuffer64(system, args);
     case SvcId::GetProcessId:
-        return SvcWrap_GetProcessId64(system);
+        return SvcWrap_GetProcessId64(system, args);
     case SvcId::GetThreadId:
-        return SvcWrap_GetThreadId64(system);
+        return SvcWrap_GetThreadId64(system, args);
     case SvcId::Break:
-        return SvcWrap_Break64(system);
+        return SvcWrap_Break64(system, args);
     case SvcId::OutputDebugString:
-        return SvcWrap_OutputDebugString64(system);
+        return SvcWrap_OutputDebugString64(system, args);
     case SvcId::ReturnFromException:
-        return SvcWrap_ReturnFromException64(system);
+        return SvcWrap_ReturnFromException64(system, args);
     case SvcId::GetInfo:
-        return SvcWrap_GetInfo64(system);
+        return SvcWrap_GetInfo64(system, args);
     case SvcId::FlushEntireDataCache:
-        return SvcWrap_FlushEntireDataCache64(system);
+        return SvcWrap_FlushEntireDataCache64(system, args);
     case SvcId::FlushDataCache:
-        return SvcWrap_FlushDataCache64(system);
+        return SvcWrap_FlushDataCache64(system, args);
     case SvcId::MapPhysicalMemory:
-        return SvcWrap_MapPhysicalMemory64(system);
+        return SvcWrap_MapPhysicalMemory64(system, args);
     case SvcId::UnmapPhysicalMemory:
-        return SvcWrap_UnmapPhysicalMemory64(system);
+        return SvcWrap_UnmapPhysicalMemory64(system, args);
     case SvcId::GetDebugFutureThreadInfo:
-        return SvcWrap_GetDebugFutureThreadInfo64(system);
+        return SvcWrap_GetDebugFutureThreadInfo64(system, args);
     case SvcId::GetLastThreadInfo:
-        return SvcWrap_GetLastThreadInfo64(system);
+        return SvcWrap_GetLastThreadInfo64(system, args);
     case SvcId::GetResourceLimitLimitValue:
-        return SvcWrap_GetResourceLimitLimitValue64(system);
+        return SvcWrap_GetResourceLimitLimitValue64(system, args);
     case SvcId::GetResourceLimitCurrentValue:
-        return SvcWrap_GetResourceLimitCurrentValue64(system);
+        return SvcWrap_GetResourceLimitCurrentValue64(system, args);
     case SvcId::SetThreadActivity:
-        return SvcWrap_SetThreadActivity64(system);
+        return SvcWrap_SetThreadActivity64(system, args);
     case SvcId::GetThreadContext3:
-        return SvcWrap_GetThreadContext364(system);
+        return SvcWrap_GetThreadContext364(system, args);
     case SvcId::WaitForAddress:
-        return SvcWrap_WaitForAddress64(system);
+        return SvcWrap_WaitForAddress64(system, args);
     case SvcId::SignalToAddress:
-        return SvcWrap_SignalToAddress64(system);
+        return SvcWrap_SignalToAddress64(system, args);
     case SvcId::SynchronizePreemptionState:
-        return SvcWrap_SynchronizePreemptionState64(system);
+        return SvcWrap_SynchronizePreemptionState64(system, args);
     case SvcId::GetResourceLimitPeakValue:
-        return SvcWrap_GetResourceLimitPeakValue64(system);
+        return SvcWrap_GetResourceLimitPeakValue64(system, args);
     case SvcId::CreateIoPool:
-        return SvcWrap_CreateIoPool64(system);
+        return SvcWrap_CreateIoPool64(system, args);
     case SvcId::CreateIoRegion:
-        return SvcWrap_CreateIoRegion64(system);
+        return SvcWrap_CreateIoRegion64(system, args);
     case SvcId::KernelDebug:
-        return SvcWrap_KernelDebug64(system);
+        return SvcWrap_KernelDebug64(system, args);
     case SvcId::ChangeKernelTraceState:
-        return SvcWrap_ChangeKernelTraceState64(system);
+        return SvcWrap_ChangeKernelTraceState64(system, args);
     case SvcId::CreateSession:
-        return SvcWrap_CreateSession64(system);
+        return SvcWrap_CreateSession64(system, args);
     case SvcId::AcceptSession:
-        return SvcWrap_AcceptSession64(system);
+        return SvcWrap_AcceptSession64(system, args);
     case SvcId::ReplyAndReceiveLight:
-        return SvcWrap_ReplyAndReceiveLight64(system);
+        return SvcWrap_ReplyAndReceiveLight64(system, args);
     case SvcId::ReplyAndReceive:
-        return SvcWrap_ReplyAndReceive64(system);
+        return SvcWrap_ReplyAndReceive64(system, args);
     case SvcId::ReplyAndReceiveWithUserBuffer:
-        return SvcWrap_ReplyAndReceiveWithUserBuffer64(system);
+        return SvcWrap_ReplyAndReceiveWithUserBuffer64(system, args);
     case SvcId::CreateEvent:
-        return SvcWrap_CreateEvent64(system);
+        return SvcWrap_CreateEvent64(system, args);
     case SvcId::MapIoRegion:
-        return SvcWrap_MapIoRegion64(system);
+        return SvcWrap_MapIoRegion64(system, args);
     case SvcId::UnmapIoRegion:
-        return SvcWrap_UnmapIoRegion64(system);
+        return SvcWrap_UnmapIoRegion64(system, args);
     case SvcId::MapPhysicalMemoryUnsafe:
-        return SvcWrap_MapPhysicalMemoryUnsafe64(system);
+        return SvcWrap_MapPhysicalMemoryUnsafe64(system, args);
     case SvcId::UnmapPhysicalMemoryUnsafe:
-        return SvcWrap_UnmapPhysicalMemoryUnsafe64(system);
+        return SvcWrap_UnmapPhysicalMemoryUnsafe64(system, args);
     case SvcId::SetUnsafeLimit:
-        return SvcWrap_SetUnsafeLimit64(system);
+        return SvcWrap_SetUnsafeLimit64(system, args);
     case SvcId::CreateCodeMemory:
-        return SvcWrap_CreateCodeMemory64(system);
+        return SvcWrap_CreateCodeMemory64(system, args);
     case SvcId::ControlCodeMemory:
-        return SvcWrap_ControlCodeMemory64(system);
+        return SvcWrap_ControlCodeMemory64(system, args);
     case SvcId::SleepSystem:
-        return SvcWrap_SleepSystem64(system);
+        return SvcWrap_SleepSystem64(system, args);
     case SvcId::ReadWriteRegister:
-        return SvcWrap_ReadWriteRegister64(system);
+        return SvcWrap_ReadWriteRegister64(system, args);
     case SvcId::SetProcessActivity:
-        return SvcWrap_SetProcessActivity64(system);
+        return SvcWrap_SetProcessActivity64(system, args);
     case SvcId::CreateSharedMemory:
-        return SvcWrap_CreateSharedMemory64(system);
+        return SvcWrap_CreateSharedMemory64(system, args);
     case SvcId::MapTransferMemory:
-        return SvcWrap_MapTransferMemory64(system);
+        return SvcWrap_MapTransferMemory64(system, args);
     case SvcId::UnmapTransferMemory:
-        return SvcWrap_UnmapTransferMemory64(system);
+        return SvcWrap_UnmapTransferMemory64(system, args);
     case SvcId::CreateInterruptEvent:
-        return SvcWrap_CreateInterruptEvent64(system);
+        return SvcWrap_CreateInterruptEvent64(system, args);
     case SvcId::QueryPhysicalAddress:
-        return SvcWrap_QueryPhysicalAddress64(system);
+        return SvcWrap_QueryPhysicalAddress64(system, args);
     case SvcId::QueryIoMapping:
-        return SvcWrap_QueryIoMapping64(system);
+        return SvcWrap_QueryIoMapping64(system, args);
     case SvcId::CreateDeviceAddressSpace:
-        return SvcWrap_CreateDeviceAddressSpace64(system);
+        return SvcWrap_CreateDeviceAddressSpace64(system, args);
     case SvcId::AttachDeviceAddressSpace:
-        return SvcWrap_AttachDeviceAddressSpace64(system);
+        return SvcWrap_AttachDeviceAddressSpace64(system, args);
     case SvcId::DetachDeviceAddressSpace:
-        return SvcWrap_DetachDeviceAddressSpace64(system);
+        return SvcWrap_DetachDeviceAddressSpace64(system, args);
     case SvcId::MapDeviceAddressSpaceByForce:
-        return SvcWrap_MapDeviceAddressSpaceByForce64(system);
+        return SvcWrap_MapDeviceAddressSpaceByForce64(system, args);
     case SvcId::MapDeviceAddressSpaceAligned:
-        return SvcWrap_MapDeviceAddressSpaceAligned64(system);
+        return SvcWrap_MapDeviceAddressSpaceAligned64(system, args);
     case SvcId::UnmapDeviceAddressSpace:
-        return SvcWrap_UnmapDeviceAddressSpace64(system);
+        return SvcWrap_UnmapDeviceAddressSpace64(system, args);
     case SvcId::InvalidateProcessDataCache:
-        return SvcWrap_InvalidateProcessDataCache64(system);
+        return SvcWrap_InvalidateProcessDataCache64(system, args);
     case SvcId::StoreProcessDataCache:
-        return SvcWrap_StoreProcessDataCache64(system);
+        return SvcWrap_StoreProcessDataCache64(system, args);
     case SvcId::FlushProcessDataCache:
-        return SvcWrap_FlushProcessDataCache64(system);
+        return SvcWrap_FlushProcessDataCache64(system, args);
     case SvcId::DebugActiveProcess:
-        return SvcWrap_DebugActiveProcess64(system);
+        return SvcWrap_DebugActiveProcess64(system, args);
     case SvcId::BreakDebugProcess:
-        return SvcWrap_BreakDebugProcess64(system);
+        return SvcWrap_BreakDebugProcess64(system, args);
     case SvcId::TerminateDebugProcess:
-        return SvcWrap_TerminateDebugProcess64(system);
+        return SvcWrap_TerminateDebugProcess64(system, args);
     case SvcId::GetDebugEvent:
-        return SvcWrap_GetDebugEvent64(system);
+        return SvcWrap_GetDebugEvent64(system, args);
     case SvcId::ContinueDebugEvent:
-        return SvcWrap_ContinueDebugEvent64(system);
+        return SvcWrap_ContinueDebugEvent64(system, args);
     case SvcId::GetProcessList:
-        return SvcWrap_GetProcessList64(system);
+        return SvcWrap_GetProcessList64(system, args);
     case SvcId::GetThreadList:
-        return SvcWrap_GetThreadList64(system);
+        return SvcWrap_GetThreadList64(system, args);
     case SvcId::GetDebugThreadContext:
-        return SvcWrap_GetDebugThreadContext64(system);
+        return SvcWrap_GetDebugThreadContext64(system, args);
     case SvcId::SetDebugThreadContext:
-        return SvcWrap_SetDebugThreadContext64(system);
+        return SvcWrap_SetDebugThreadContext64(system, args);
     case SvcId::QueryDebugProcessMemory:
-        return SvcWrap_QueryDebugProcessMemory64(system);
+        return SvcWrap_QueryDebugProcessMemory64(system, args);
     case SvcId::ReadDebugProcessMemory:
-        return SvcWrap_ReadDebugProcessMemory64(system);
+        return SvcWrap_ReadDebugProcessMemory64(system, args);
     case SvcId::WriteDebugProcessMemory:
-        return SvcWrap_WriteDebugProcessMemory64(system);
+        return SvcWrap_WriteDebugProcessMemory64(system, args);
     case SvcId::SetHardwareBreakPoint:
-        return SvcWrap_SetHardwareBreakPoint64(system);
+        return SvcWrap_SetHardwareBreakPoint64(system, args);
     case SvcId::GetDebugThreadParam:
-        return SvcWrap_GetDebugThreadParam64(system);
+        return SvcWrap_GetDebugThreadParam64(system, args);
     case SvcId::GetSystemInfo:
-        return SvcWrap_GetSystemInfo64(system);
+        return SvcWrap_GetSystemInfo64(system, args);
     case SvcId::CreatePort:
-        return SvcWrap_CreatePort64(system);
+        return SvcWrap_CreatePort64(system, args);
     case SvcId::ManageNamedPort:
-        return SvcWrap_ManageNamedPort64(system);
+        return SvcWrap_ManageNamedPort64(system, args);
     case SvcId::ConnectToPort:
-        return SvcWrap_ConnectToPort64(system);
+        return SvcWrap_ConnectToPort64(system, args);
     case SvcId::SetProcessMemoryPermission:
-        return SvcWrap_SetProcessMemoryPermission64(system);
+        return SvcWrap_SetProcessMemoryPermission64(system, args);
     case SvcId::MapProcessMemory:
-        return SvcWrap_MapProcessMemory64(system);
+        return SvcWrap_MapProcessMemory64(system, args);
     case SvcId::UnmapProcessMemory:
-        return SvcWrap_UnmapProcessMemory64(system);
+        return SvcWrap_UnmapProcessMemory64(system, args);
     case SvcId::QueryProcessMemory:
-        return SvcWrap_QueryProcessMemory64(system);
+        return SvcWrap_QueryProcessMemory64(system, args);
     case SvcId::MapProcessCodeMemory:
-        return SvcWrap_MapProcessCodeMemory64(system);
+        return SvcWrap_MapProcessCodeMemory64(system, args);
     case SvcId::UnmapProcessCodeMemory:
-        return SvcWrap_UnmapProcessCodeMemory64(system);
+        return SvcWrap_UnmapProcessCodeMemory64(system, args);
     case SvcId::CreateProcess:
-        return SvcWrap_CreateProcess64(system);
+        return SvcWrap_CreateProcess64(system, args);
     case SvcId::StartProcess:
-        return SvcWrap_StartProcess64(system);
+        return SvcWrap_StartProcess64(system, args);
     case SvcId::TerminateProcess:
-        return SvcWrap_TerminateProcess64(system);
+        return SvcWrap_TerminateProcess64(system, args);
     case SvcId::GetProcessInfo:
-        return SvcWrap_GetProcessInfo64(system);
+        return SvcWrap_GetProcessInfo64(system, args);
     case SvcId::CreateResourceLimit:
-        return SvcWrap_CreateResourceLimit64(system);
+        return SvcWrap_CreateResourceLimit64(system, args);
     case SvcId::SetResourceLimitLimitValue:
-        return SvcWrap_SetResourceLimitLimitValue64(system);
+        return SvcWrap_SetResourceLimitLimitValue64(system, args);
     case SvcId::CallSecureMonitor:
-        return SvcWrap_CallSecureMonitor64(system);
+        return SvcWrap_CallSecureMonitor64(system, args);
     case SvcId::MapInsecureMemory:
-        return SvcWrap_MapInsecureMemory64(system);
+        return SvcWrap_MapInsecureMemory64(system, args);
     case SvcId::UnmapInsecureMemory:
-        return SvcWrap_UnmapInsecureMemory64(system);
+        return SvcWrap_UnmapInsecureMemory64(system, args);
     default:
         LOG_CRITICAL(Kernel_SVC, "Unknown SVC {:x}!", imm);
         break;
@@ -4424,15 +4424,20 @@ static void Call64(Core::System& system, u32 imm) {
 
 void Call(Core::System& system, u32 imm) {
     auto& kernel = system.Kernel();
+    auto& process = GetCurrentProcess(kernel);
+
+    std::array<uint64_t, 8> args;
+    kernel.CurrentPhysicalCore().SaveSvcArguments(process, args);
     kernel.EnterSVCProfile();
 
-    if (GetCurrentProcess(system.Kernel()).Is64Bit()) {
-        Call64(system, imm);
+    if (process.Is64Bit()) {
+        Call64(system, imm, args);
     } else {
-        Call32(system, imm);
+        Call32(system, imm, args);
     }
 
     kernel.ExitSVCProfile();
+    kernel.CurrentPhysicalCore().LoadSvcArguments(process, args);
 }
 
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc.h b/src/core/hle/kernel/svc.h
index ac4696008..828f39611 100644
--- a/src/core/hle/kernel/svc.h
+++ b/src/core/hle/kernel/svc.h
@@ -9,6 +9,8 @@ namespace Core {
 class System;
 }
 
+#include <span>
+
 #include "common/common_types.h"
 #include "core/hle/kernel/svc_types.h"
 #include "core/hle/result.h"
@@ -520,15 +522,15 @@ void CallSecureMonitor64From32(Core::System& system, ilp32::SecureMonitorArgumen
 void CallSecureMonitor64(Core::System& system, lp64::SecureMonitorArguments* args);
 
 // Defined in svc_light_ipc.cpp.
-void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system);
-void SvcWrap_ReplyAndReceiveLight64(Core::System& system);
+void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system, std::span<uint64_t, 8> args);
+void SvcWrap_ReplyAndReceiveLight64(Core::System& system, std::span<uint64_t, 8> args);
 
-void SvcWrap_SendSyncRequestLight64From32(Core::System& system);
-void SvcWrap_SendSyncRequestLight64(Core::System& system);
+void SvcWrap_SendSyncRequestLight64From32(Core::System& system, std::span<uint64_t, 8> args);
+void SvcWrap_SendSyncRequestLight64(Core::System& system, std::span<uint64_t, 8> args);
 
 // Defined in svc_secure_monitor_call.cpp.
-void SvcWrap_CallSecureMonitor64From32(Core::System& system);
-void SvcWrap_CallSecureMonitor64(Core::System& system);
+void SvcWrap_CallSecureMonitor64From32(Core::System& system, std::span<uint64_t, 8> args);
+void SvcWrap_CallSecureMonitor64(Core::System& system, std::span<uint64_t, 8> args);
 
 // Perform a supervisor call by index.
 void Call(Core::System& system, u32 imm);
diff --git a/src/core/hle/kernel/svc/svc_exception.cpp b/src/core/hle/kernel/svc/svc_exception.cpp
index c581c086b..47b756828 100644
--- a/src/core/hle/kernel/svc/svc_exception.cpp
+++ b/src/core/hle/kernel/svc/svc_exception.cpp
@@ -103,9 +103,7 @@ void Break(Core::System& system, BreakReason reason, u64 info1, u64 info2) {
 
         handle_debug_buffer(info1, info2);
 
-        auto* const current_thread = GetCurrentThreadPointer(system.Kernel());
-        const auto thread_processor_id = current_thread->GetActiveCore();
-        system.ArmInterface(static_cast<std::size_t>(thread_processor_id)).LogBacktrace();
+        system.CurrentPhysicalCore().LogBacktrace();
     }
 
     const bool is_hbl = GetCurrentProcess(system.Kernel()).IsHbl();
diff --git a/src/core/hle/kernel/svc/svc_light_ipc.cpp b/src/core/hle/kernel/svc/svc_light_ipc.cpp
index b76ce984c..d757d5af2 100644
--- a/src/core/hle/kernel/svc/svc_light_ipc.cpp
+++ b/src/core/hle/kernel/svc/svc_light_ipc.cpp
@@ -37,37 +37,36 @@ Result ReplyAndReceiveLight64From32(Core::System& system, Handle session_handle,
 // Custom ABI implementation for light IPC.
 
 template <typename F>
-static void SvcWrap_LightIpc(Core::System& system, F&& cb) {
-    auto& core = system.CurrentArmInterface();
-    std::array<u32, 7> arguments{};
+static void SvcWrap_LightIpc(Core::System& system, std::span<uint64_t, 8> args, F&& cb) {
+    std::array<u32, 7> ipc_args{};
 
-    Handle session_handle = static_cast<Handle>(core.GetReg(0));
+    Handle session_handle = static_cast<Handle>(args[0]);
     for (int i = 0; i < 7; i++) {
-        arguments[i] = static_cast<u32>(core.GetReg(i + 1));
+        ipc_args[i] = static_cast<u32>(args[i + 1]);
     }
 
-    Result ret = cb(system, session_handle, arguments.data());
+    Result ret = cb(system, session_handle, ipc_args.data());
 
-    core.SetReg(0, ret.raw);
+    args[0] = ret.raw;
     for (int i = 0; i < 7; i++) {
-        core.SetReg(i + 1, arguments[i]);
+        args[i + 1] = ipc_args[i];
     }
 }
 
-void SvcWrap_SendSyncRequestLight64(Core::System& system) {
-    SvcWrap_LightIpc(system, SendSyncRequestLight64);
+void SvcWrap_SendSyncRequestLight64(Core::System& system, std::span<uint64_t, 8> args) {
+    SvcWrap_LightIpc(system, args, SendSyncRequestLight64);
 }
 
-void SvcWrap_ReplyAndReceiveLight64(Core::System& system) {
-    SvcWrap_LightIpc(system, ReplyAndReceiveLight64);
+void SvcWrap_ReplyAndReceiveLight64(Core::System& system, std::span<uint64_t, 8> args) {
+    SvcWrap_LightIpc(system, args, ReplyAndReceiveLight64);
 }
 
-void SvcWrap_SendSyncRequestLight64From32(Core::System& system) {
-    SvcWrap_LightIpc(system, SendSyncRequestLight64From32);
+void SvcWrap_SendSyncRequestLight64From32(Core::System& system, std::span<uint64_t, 8> args) {
+    SvcWrap_LightIpc(system, args, SendSyncRequestLight64From32);
 }
 
-void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system) {
-    SvcWrap_LightIpc(system, ReplyAndReceiveLight64From32);
+void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system, std::span<uint64_t, 8> args) {
+    SvcWrap_LightIpc(system, args, ReplyAndReceiveLight64From32);
 }
 
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_secure_monitor_call.cpp b/src/core/hle/kernel/svc/svc_secure_monitor_call.cpp
index 62c781551..48b564ec8 100644
--- a/src/core/hle/kernel/svc/svc_secure_monitor_call.cpp
+++ b/src/core/hle/kernel/svc/svc_secure_monitor_call.cpp
@@ -22,31 +22,29 @@ void CallSecureMonitor64From32(Core::System& system, ilp32::SecureMonitorArgumen
 
 // Custom ABI for CallSecureMonitor.
 
-void SvcWrap_CallSecureMonitor64(Core::System& system) {
-    auto& core = system.CurrentPhysicalCore().ArmInterface();
-    lp64::SecureMonitorArguments args{};
+void SvcWrap_CallSecureMonitor64(Core::System& system, std::span<uint64_t, 8> args) {
+    lp64::SecureMonitorArguments smc_args{};
     for (int i = 0; i < 8; i++) {
-        args.r[i] = core.GetReg(i);
+        smc_args.r[i] = args[i];
     }
 
-    CallSecureMonitor64(system, std::addressof(args));
+    CallSecureMonitor64(system, std::addressof(smc_args));
 
     for (int i = 0; i < 8; i++) {
-        core.SetReg(i, args.r[i]);
+        args[i] = smc_args.r[i];
     }
 }
 
-void SvcWrap_CallSecureMonitor64From32(Core::System& system) {
-    auto& core = system.CurrentPhysicalCore().ArmInterface();
-    ilp32::SecureMonitorArguments args{};
+void SvcWrap_CallSecureMonitor64From32(Core::System& system, std::span<uint64_t, 8> args) {
+    ilp32::SecureMonitorArguments smc_args{};
     for (int i = 0; i < 8; i++) {
-        args.r[i] = static_cast<u32>(core.GetReg(i));
+        smc_args.r[i] = static_cast<u32>(args[i]);
     }
 
-    CallSecureMonitor64From32(system, std::addressof(args));
+    CallSecureMonitor64From32(system, std::addressof(smc_args));
 
     for (int i = 0; i < 8; i++) {
-        core.SetReg(i, args.r[i]);
+        args[i] = smc_args.r[i];
     }
 }
 
diff --git a/src/core/hle/kernel/svc/svc_thread.cpp b/src/core/hle/kernel/svc/svc_thread.cpp
index 755fd62b5..7681afa33 100644
--- a/src/core/hle/kernel/svc/svc_thread.cpp
+++ b/src/core/hle/kernel/svc/svc_thread.cpp
@@ -90,8 +90,6 @@ Result StartThread(Core::System& system, Handle thread_handle) {
 
 /// Called when a thread exits
 void ExitThread(Core::System& system) {
-    LOG_DEBUG(Kernel_SVC, "called, pc=0x{:08X}", system.CurrentArmInterface().GetPC());
-
     auto* const current_thread = GetCurrentThreadPointer(system.Kernel());
     system.GlobalSchedulerContext().RemoveThread(current_thread);
     current_thread->Exit();
@@ -147,47 +145,19 @@ Result GetThreadContext3(Core::System& system, u64 out_context, Handle thread_ha
     R_UNLESS(thread.IsNotNull(), ResultInvalidHandle);
 
     // Require the handle be to a non-current thread in the current process.
-    const auto* current_process = GetCurrentProcessPointer(kernel);
-    R_UNLESS(current_process == thread->GetOwnerProcess(), ResultInvalidId);
-
-    // Verify that the thread isn't terminated.
-    R_UNLESS(thread->GetState() != ThreadState::Terminated, ResultTerminationRequested);
-
-    /// Check that the thread is not the current one.
-    /// NOTE: Nintendo does not check this, and thus the following loop will deadlock.
-    R_UNLESS(thread.GetPointerUnsafe() != GetCurrentThreadPointer(kernel), ResultInvalidId);
-
-    // Try to get the thread context until the thread isn't current on any core.
-    while (true) {
-        KScopedSchedulerLock sl{kernel};
-
-        // TODO(bunnei): Enforce that thread is suspended for debug here.
-
-        // If the thread's raw state isn't runnable, check if it's current on some core.
-        if (thread->GetRawState() != ThreadState::Runnable) {
-            bool current = false;
-            for (auto i = 0; i < static_cast<s32>(Core::Hardware::NUM_CPU_CORES); ++i) {
-                if (thread.GetPointerUnsafe() == kernel.Scheduler(i).GetSchedulerCurrentThread()) {
-                    current = true;
-                    break;
-                }
-            }
+    R_UNLESS(thread->GetOwnerProcess() == GetCurrentProcessPointer(kernel), ResultInvalidHandle);
+    R_UNLESS(thread.GetPointerUnsafe() != GetCurrentThreadPointer(kernel), ResultBusy);
 
-            // If the thread is current, retry until it isn't.
-            if (current) {
-                continue;
-            }
-        }
+    // Get the thread context.
+    Svc::ThreadContext context{};
+    R_TRY(thread->GetThreadContext3(std::addressof(context)));
 
-        // Get the thread context.
-        static thread_local Common::ScratchBuffer<u8> context;
-        R_TRY(thread->GetThreadContext3(context));
+    // Copy the thread context to user space.
+    R_UNLESS(
+        GetCurrentMemory(kernel).WriteBlock(out_context, std::addressof(context), sizeof(context)),
+        ResultInvalidPointer);
 
-        // Copy the thread context to user space.
-        GetCurrentMemory(kernel).WriteBlock(out_context, context.data(), context.size());
-
-        R_SUCCEED();
-    }
+    R_SUCCEED();
 }
 
 /// Gets the priority for the specified thread
diff --git a/src/core/hle/kernel/svc_generator.py b/src/core/hle/kernel/svc_generator.py
index 5531faac6..786189ab7 100644
--- a/src/core/hle/kernel/svc_generator.py
+++ b/src/core/hle/kernel/svc_generator.py
@@ -374,11 +374,11 @@ def get_registers(parse_result, bitness):
 
 # Collects possibly multiple source registers into the named C++ value.
 def emit_gather(sources, name, type_name, reg_size):
-    get_fn = f"GetReg{reg_size*8}"
+    get_fn = f"GetArg{reg_size*8}"
 
     if len(sources) == 1:
         s, = sources
-        line = f"{name} = Convert<{type_name}>({get_fn}(system, {s}));"
+        line = f"{name} = Convert<{type_name}>({get_fn}(args, {s}));"
         return [line]
 
     var_type = f"std::array<uint{reg_size*8}_t, {len(sources)}>"
@@ -387,7 +387,7 @@ def emit_gather(sources, name, type_name, reg_size):
     ]
     for i in range(0, len(sources)):
         lines.append(
-            f"{name}_gather[{i}] = {get_fn}(system, {sources[i]});")
+            f"{name}_gather[{i}] = {get_fn}(args, {sources[i]});")
 
     lines.append(f"{name} = Convert<{type_name}>({name}_gather);")
     return lines
@@ -396,12 +396,12 @@ def emit_gather(sources, name, type_name, reg_size):
 # Produces one or more statements which assign the named C++ value
 # into possibly multiple registers.
 def emit_scatter(destinations, name, reg_size):
-    set_fn = f"SetReg{reg_size*8}"
+    set_fn = f"SetArg{reg_size*8}"
     reg_type = f"uint{reg_size*8}_t"
 
     if len(destinations) == 1:
         d, = destinations
-        line = f"{set_fn}(system, {d}, Convert<{reg_type}>({name}));"
+        line = f"{set_fn}(args, {d}, Convert<{reg_type}>({name}));"
         return [line]
 
     var_type = f"std::array<{reg_type}, {len(destinations)}>"
@@ -411,7 +411,7 @@ def emit_scatter(destinations, name, reg_size):
 
     for i in range(0, len(destinations)):
         lines.append(
-            f"{set_fn}(system, {destinations[i]}, {name}_scatter[{i}]);")
+            f"{set_fn}(args, {destinations[i]}, {name}_scatter[{i}]);")
 
     return lines
 
@@ -433,7 +433,7 @@ def emit_lines(lines, indent='    '):
 def emit_wrapper(wrapped_fn, suffix, register_info, arguments, byte_size):
     return_write, output_writes, input_reads = register_info
     lines = [
-        f"static void SvcWrap_{wrapped_fn}{suffix}(Core::System& system) {{"
+        f"static void SvcWrap_{wrapped_fn}{suffix}(Core::System& system, std::span<uint64_t, 8> args) {{"
     ]
 
     # Get everything ready.
@@ -498,6 +498,8 @@ namespace Core {
 class System;
 }
 
+#include <span>
+
 #include "common/common_types.h"
 #include "core/hle/kernel/svc_types.h"
 #include "core/hle/result.h"
@@ -524,15 +526,15 @@ void CallSecureMonitor64From32(Core::System& system, ilp32::SecureMonitorArgumen
 void CallSecureMonitor64(Core::System& system, lp64::SecureMonitorArguments* args);
 
 // Defined in svc_light_ipc.cpp.
-void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system);
-void SvcWrap_ReplyAndReceiveLight64(Core::System& system);
+void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system, std::span<uint64_t, 8> args);
+void SvcWrap_ReplyAndReceiveLight64(Core::System& system, std::span<uint64_t, 8> args);
 
-void SvcWrap_SendSyncRequestLight64From32(Core::System& system);
-void SvcWrap_SendSyncRequestLight64(Core::System& system);
+void SvcWrap_SendSyncRequestLight64From32(Core::System& system, std::span<uint64_t, 8> args);
+void SvcWrap_SendSyncRequestLight64(Core::System& system, std::span<uint64_t, 8> args);
 
 // Defined in svc_secure_monitor_call.cpp.
-void SvcWrap_CallSecureMonitor64From32(Core::System& system);
-void SvcWrap_CallSecureMonitor64(Core::System& system);
+void SvcWrap_CallSecureMonitor64From32(Core::System& system, std::span<uint64_t, 8> args);
+void SvcWrap_CallSecureMonitor64(Core::System& system, std::span<uint64_t, 8> args);
 
 // Perform a supervisor call by index.
 void Call(Core::System& system, u32 imm);
@@ -550,20 +552,20 @@ PROLOGUE_CPP = """
 
 namespace Kernel::Svc {
 
-static uint32_t GetReg32(Core::System& system, int n) {
-    return static_cast<uint32_t>(system.CurrentArmInterface().GetReg(n));
+static uint32_t GetArg32(std::span<uint64_t, 8> args, int n) {
+    return static_cast<uint32_t>(args[n]);
 }
 
-static void SetReg32(Core::System& system, int n, uint32_t result) {
-    system.CurrentArmInterface().SetReg(n, static_cast<uint64_t>(result));
+static void SetArg32(std::span<uint64_t, 8> args, int n, uint32_t result) {
+    args[n] = result;
 }
 
-static uint64_t GetReg64(Core::System& system, int n) {
-    return system.CurrentArmInterface().GetReg(n);
+static uint64_t GetArg64(std::span<uint64_t, 8> args, int n) {
+    return args[n];
 }
 
-static void SetReg64(Core::System& system, int n, uint64_t result) {
-    system.CurrentArmInterface().SetReg(n, result);
+static void SetArg64(std::span<uint64_t, 8> args, int n, uint64_t result) {
+    args[n] = result;
 }
 
 // Like bit_cast, but handles the case when the source and dest
@@ -590,15 +592,20 @@ EPILOGUE_CPP = """
 
 void Call(Core::System& system, u32 imm) {
     auto& kernel = system.Kernel();
+    auto& process = GetCurrentProcess(kernel);
+
+    std::array<uint64_t, 8> args;
+    kernel.CurrentPhysicalCore().SaveSvcArguments(process, args);
     kernel.EnterSVCProfile();
 
-    if (GetCurrentProcess(system.Kernel()).Is64Bit()) {
-        Call64(system, imm);
+    if (process.Is64Bit()) {
+        Call64(system, imm, args);
     } else {
-        Call32(system, imm);
+        Call32(system, imm, args);
     }
 
     kernel.ExitSVCProfile();
+    kernel.CurrentPhysicalCore().LoadSvcArguments(process, args);
 }
 
 } // namespace Kernel::Svc
@@ -609,13 +616,13 @@ def emit_call(bitness, names, suffix):
     bit_size = REG_SIZES[bitness]*8
     indent = "    "
     lines = [
-        f"static void Call{bit_size}(Core::System& system, u32 imm) {{",
+        f"static void Call{bit_size}(Core::System& system, u32 imm, std::span<uint64_t, 8> args) {{",
         f"{indent}switch (static_cast<SvcId>(imm)) {{"
     ]
 
     for _, name in names:
         lines.append(f"{indent}case SvcId::{name}:")
-        lines.append(f"{indent*2}return SvcWrap_{name}{suffix}(system);")
+        lines.append(f"{indent*2}return SvcWrap_{name}{suffix}(system, args);")
 
     lines.append(f"{indent}default:")
     lines.append(