From 9bf17b0b41cd0f21b11ebdea545b92befab1b73d Mon Sep 17 00:00:00 2001
From: GRAnimated <devin@nhscan.com>
Date: Sat, 11 Jul 2026 06:03:34 +0000
Subject: [PATCH 1/5] SMO matching and cleanup changes

---
 include/container/seadTreeMap.h               |   5 +-
 include/controller/seadControllerMgr.h        |   2 +-
 include/filedevice/seadFileDeviceMgr.h        |   2 +-
 include/framework/seadGameFramework.h         |   4 +-
 include/framework/seadMethodTree.h            |  12 +-
 include/mc/seadJobQueue.h                     |  11 +-
 include/prim/seadDelegateEventSlot.h          |   2 +
 modules/src/basis/seadNew.cpp                 |  10 +-
 modules/src/container/seadPtrArray.cpp        |  43 +++++-
 modules/src/container/seadTreeNode.cpp        |  32 ++---
 modules/src/controller/seadControllerMgr.cpp  |  13 +-
 .../nin/seadNinFileDeviceBaseNin.cpp          |  29 +++-
 .../src/filedevice/seadArchiveFileDevice.cpp  |   4 +-
 modules/src/filedevice/seadFileDevice.cpp     |   2 +-
 modules/src/filedevice/seadFileDeviceMgr.cpp  |  14 +-
 modules/src/filedevice/seadPath.cpp           |   7 +-
 modules/src/framework/seadFramework.cpp       |   2 +-
 modules/src/framework/seadGameFramework.cpp   |   8 +-
 modules/src/framework/seadMethodTree.cpp      |   4 +-
 modules/src/gfx/nvn/seadDebugFontMgrNvn.cpp   | 111 ++++++++-------
 modules/src/gfx/seadColor.cpp                 |  11 +-
 modules/src/hostio/seadHostIOCurve.cpp        | 103 +++++++++-----
 modules/src/math/seadMatrix.cpp               |  63 +++++++++
 modules/src/mc/seadCoreInfo.cpp               |  12 +-
 modules/src/mc/seadJobQueue.cpp               | 127 +++++++++---------
 modules/src/prim/seadBitFlag.cpp              |  21 ++-
 modules/src/prim/seadSafeString.cpp           | 115 ++++++++--------
 modules/src/prim/seadStringBuilder.cpp        |  78 ++++++-----
 modules/src/resource/seadSZSDecompressor.cpp  |  76 +++++------
 modules/src/thread/seadThread.cpp             | 126 ++---------------
 modules/src/time/seadCalendarTime.cpp         |  14 +-
 modules/src/time/seadDateUtil.cpp             |  30 +++--
 32 files changed, 573 insertions(+), 520 deletions(-)

diff --git a/include/container/seadTreeMap.h b/include/container/seadTreeMap.h
index 0ee17a7f..7db461df 100644
--- a/include/container/seadTreeMap.h
+++ b/include/container/seadTreeMap.h
@@ -452,7 +452,7 @@ inline TreeMapNode<Key>* TreeMapImpl<Key>::findMin(Node* node)
     return node;
 }
 
-// NON_MATCHING: this version matches the LLRB tree implementation and is better optimized
+// The compiler barrier preserves the original recursive-result store schedule.
 template <typename Key>
 inline TreeMapNode<Key>* TreeMapImpl<Key>::eraseMin(Node* node)
 {
@@ -462,10 +462,11 @@ inline TreeMapNode<Key>* TreeMapImpl<Key>::eraseMin(Node* node)
     if (!isRed(node->mLeft) && !isRed(node->mLeft->mLeft))
         node = moveRedLeft(node);
 
-    node->mLeft = eraseMin(node->mLeft);
+    Node* newLeft = eraseMin(node->mLeft);
 #ifdef MATCHING_HACK_NX_CLANG
     asm("");
 #endif
+    node->mLeft = newLeft;
     return fixUp(node);
 }
 
diff --git a/include/controller/seadControllerMgr.h b/include/controller/seadControllerMgr.h
index abf76103..f253efe3 100644
--- a/include/controller/seadControllerMgr.h
+++ b/include/controller/seadControllerMgr.h
@@ -24,7 +24,7 @@ class ControllerMgr : public CalculateTask
     class ConstructArg : public TaskConstructArg
     {
     public:
-        ConstructArg() : TaskConstructArg(), mHeapArray() { heap_array = &mHeapArray; }
+        ConstructArg() : TaskConstructArg() { heap_array = &mHeapArray; }
 
     private:
         HeapArray mHeapArray;
diff --git a/include/filedevice/seadFileDeviceMgr.h b/include/filedevice/seadFileDeviceMgr.h
index 89c2ece3..f6ca7b41 100644
--- a/include/filedevice/seadFileDeviceMgr.h
+++ b/include/filedevice/seadFileDeviceMgr.h
@@ -72,7 +72,7 @@ class FileDeviceMgr
 #elif defined(NNSDK)
     u8* mRomCache = nullptr;
     bool mMountedHost = false;
-    bool mMountedSd = false;
+    bool mMountedSd;
 #endif
 };
 
diff --git a/include/framework/seadGameFramework.h b/include/framework/seadGameFramework.h
index 752db08a..3ba7a7b5 100644
--- a/include/framework/seadGameFramework.h
+++ b/include/framework/seadGameFramework.h
@@ -7,6 +7,8 @@
 
 namespace sead
 {
+class Thread;
+
 class GameFramework : public Framework
 {
     SEAD_RTTI_OVERRIDE(GameFramework, Framework);
@@ -42,7 +44,7 @@ class GameFramework : public Framework
     sead::SafeString mUnk1 = "";
     sead::SafeString mUnk2 = "";
     sead::SafeString mUnk3 = "";
-    [[maybe_unused]] void* mUnk4 = nullptr;  // TODO: remove [[maybe_unused]] once mUnk4 is used
+    Thread* mUnk4 = nullptr;
     void (*mUnk5)(bool) = nullptr;
     void (*mUnk6)(bool);
 };
diff --git a/include/framework/seadMethodTree.h b/include/framework/seadMethodTree.h
index 98684972..8e6621f3 100644
--- a/include/framework/seadMethodTree.h
+++ b/include/framework/seadMethodTree.h
@@ -16,7 +16,7 @@ class CriticalSection;
 template <typename T, typename U>
 class IDelegate2;
 
-class MethodTreeNode : public IDisposer, public TTreeNode<MethodTreeNode*>, public INamable
+class MethodTreeNode : public TTreeNode<MethodTreeNode*>, public INamable, public IDisposer
 {
     SEAD_RTTI_BASE(MethodTreeNode)
 
@@ -31,13 +31,13 @@ class MethodTreeNode : public IDisposer, public TTreeNode<MethodTreeNode*>, publ
 
     using PauseEventDelegate = IDelegate2<MethodTreeNode*, PauseFlag>;
 
-    // NON_MATCHING: stores for mPauseFlag, mPauseEventDelegate, mUserID
-    explicit MethodTreeNode(CriticalSection* cs) : TTreeNode(this)
+    explicit MethodTreeNode(CriticalSection* cs) : TTreeNode(this), INamable("")
     {
-        mCriticalSection = cs;
         mPauseEventDelegate = nullptr;
-        mUserID = nullptr;
+        mCriticalSection = cs;
         mDelegateHolder.construct(sead::Delegate<MethodTreeNode>());
+        mUserID = nullptr;
+        mPauseFlag = cPause_None;
         setPauseFlag(cPause_Both);
     }
 
@@ -78,7 +78,7 @@ class MethodTreeNode : public IDisposer, public TTreeNode<MethodTreeNode*>, publ
     StorageFor<sead::AnyDelegate> mDelegateHolder;
     mutable CriticalSection* mCriticalSection;
     [[maybe_unused]] u32 mPriority;
-    BitFlag32 mPauseFlag;
+    u32 mPauseFlag;
     PauseEventDelegate* mPauseEventDelegate;
     void* mUserID;
 };
diff --git a/include/mc/seadJobQueue.h b/include/mc/seadJobQueue.h
index b3b10143..f23e2320 100644
--- a/include/mc/seadJobQueue.h
+++ b/include/mc/seadJobQueue.h
@@ -36,9 +36,9 @@ class PerfJobQueue
     void detachProcessMeter();
 
 private:
-    Buffer<MultiProcessMeterBar<512>> mBars;
+    Buffer<SafeString> mBars;
     Buffer<u32> mInts;
-    MultiProcessMeterBar<1> mProcessMeterBar;
+    SafeString mProcessMeterBar;
 };
 
 class JobQueueLock
@@ -112,15 +112,13 @@ class JobQueue : public hostio::Node, public INamable
     CoreIdMask mMask;
     Event mFinishEvent{true};
     SafeArray<u32, 3> mGranularity;
-    SafeArray<u32, 3> mCoreEnabled;
+    SafeArray<volatile u32, 3> mCoreEnabled;
     Atomic<u32> mNumDoneJobs = 0;
 
     Atomic<Status> mStatus = Status::_0;
     const char* mDescription = "NoName";
 
-#ifdef SEAD_DEBUG
     PerfJobQueue mPerf;
-#endif
 };
 
 class FixedSizeJQ : public JobQueue
@@ -155,4 +153,7 @@ class FixedSizeJQ : public JobQueue
     u32 mNumProcessedJobs;
     bool _230;
 };
+static_assert(sizeof(PerfJobQueue) == 0x30);
+static_assert(sizeof(JobQueue) == 0xB0);
+static_assert(sizeof(FixedSizeJQ) == 0xD0);
 }  // namespace sead
diff --git a/include/prim/seadDelegateEventSlot.h b/include/prim/seadDelegateEventSlot.h
index 666240b8..38293f81 100644
--- a/include/prim/seadDelegateEventSlot.h
+++ b/include/prim/seadDelegateEventSlot.h
@@ -61,6 +61,8 @@ class DelegateEvent
         bool mConnectedToDelegateEvent = false;
     };
 
+    DelegateEvent() {}
+
     virtual ~DelegateEvent()
     {
         auto it = mList.begin();
diff --git a/modules/src/basis/seadNew.cpp b/modules/src/basis/seadNew.cpp
index 1ae07c67..a983ed0d 100644
--- a/modules/src/basis/seadNew.cpp
+++ b/modules/src/basis/seadNew.cpp
@@ -26,15 +26,7 @@ void* NewImpl(Heap* heap, size_t size, s32 alignment, bool abortOnFailure)
         }
     }
 
-    void* result = heap->tryAlloc(size, alignment);
-    if (!result && abortOnFailure)
-    {
-        SEAD_ASSERT_MSG(
-            false, "alloc failed. size: %zu, allocatable size: %zu, alignment: %d, heap: %s", size,
-            heap->getMaxAllocatableSize(alignment), alignment, heap->getName().cstr());
-        return nullptr;
-    }
-    return result;
+    return heap->tryAlloc(size, alignment);
 }
 
 void DeleteImpl(void* ptr)
diff --git a/modules/src/container/seadPtrArray.cpp b/modules/src/container/seadPtrArray.cpp
index 87ea5435..a499b497 100644
--- a/modules/src/container/seadPtrArray.cpp
+++ b/modules/src/container/seadPtrArray.cpp
@@ -93,10 +93,10 @@ void PtrArrayImpl::erase(s32 pos, s32 count)
     mPtrNum -= count;
 }
 
-// NON_MATCHING: semantically equivalent
 void PtrArrayImpl::reverse()
 {
-    for (s32 i = 0; i < mPtrNum / 2; ++i)
+    const s32 half = mPtrNum / 2;
+    for (s32 i = 0; i < half; ++i)
         swap(mPtrNum - i - 1, i);
 }
 
@@ -145,8 +145,43 @@ bool PtrArrayImpl::checkInsert(s32 pos, s32 num)
 
 void PtrArrayImpl::sort(CompareCallbackImpl cmp)
 {
-    // Note: Nintendo did not use <algorithm>
-    std::sort(mPtrs, mPtrs + size(), [&](const void* a, const void* b) { return cmp(a, b) < 0; });
+    if (mPtrNum < 2)
+        return;
+
+    void** ptrs = mPtrs;
+    s32 begin = 0;
+    s32 end = mPtrNum - 1;
+    do
+    {
+        s32 last = begin;
+        for (s32 i = begin; i < end; ++i)
+        {
+            if (cmp(ptrs[i], ptrs[i + 1]) > 0)
+            {
+                void* tmp = ptrs[i + 1];
+                ptrs[i + 1] = ptrs[i];
+                ptrs[i] = tmp;
+                last = i;
+            }
+        }
+
+        end = last;
+        if (begin == end)
+            break;
+
+        last = end;
+        for (s32 i = end; i > begin; --i)
+        {
+            if (cmp(ptrs[i], ptrs[i - 1]) < 0)
+            {
+                void* tmp = ptrs[i - 1];
+                ptrs[i - 1] = ptrs[i];
+                ptrs[i] = tmp;
+                last = i;
+            }
+        }
+        begin = last;
+    } while (begin != end);
 }
 
 // TODO: PtrArrayImpl::heapSort
diff --git a/modules/src/container/seadTreeNode.cpp b/modules/src/container/seadTreeNode.cpp
index 7779662e..89c13a0d 100644
--- a/modules/src/container/seadTreeNode.cpp
+++ b/modules/src/container/seadTreeNode.cpp
@@ -78,34 +78,18 @@ void TreeNode::detachSubTree()
 
 TreeNode* TreeNode::findRoot()
 {
-    if (!mParent)
-        return this;
-
-    TreeNode* p = mParent;
-    TreeNode* root;
-    do
-    {
-        root = p;
-        SEAD_ASSERT(p != this);
-        p = p->mParent;
-    } while (p);
-    return root;
+    TreeNode* node = this;
+    while (node->mParent)
+        node = node->mParent;
+    return node;
 }
 
 const TreeNode* TreeNode::findRoot() const
 {
-    if (!mParent)
-        return this;
-
-    TreeNode* p = mParent;
-    TreeNode* root;
-    do
-    {
-        root = p;
-        SEAD_ASSERT(p != this);
-        p = p->mParent;
-    } while (p);
-    return root;
+    const TreeNode* node = this;
+    while (node->mParent)
+        node = node->mParent;
+    return node;
 }
 
 void TreeNode::insertAfterSelf(TreeNode* node)
diff --git a/modules/src/controller/seadControllerMgr.cpp b/modules/src/controller/seadControllerMgr.cpp
index 2ab8039f..c7df3150 100644
--- a/modules/src/controller/seadControllerMgr.cpp
+++ b/modules/src/controller/seadControllerMgr.cpp
@@ -10,7 +10,6 @@ namespace sead
 {
 SEAD_TASK_SINGLETON_IMPL(ControllerMgr)
 
-// NON_MATCHING: storing too much 00s into stack (for ConstructArg)
 ControllerMgr::ControllerMgr() : CalculateTask(ConstructArg(), "sead::ControllerMgr")
 {
     mDevices.initOffset(offsetof(ControlDevice, mListNode));
@@ -67,15 +66,11 @@ void ControllerMgr::initializeDefault(Heap* heap)
 void ControllerMgr::finalizeDefault()
 {
 #ifdef NNSDK
-    // NON_MATCHING: missing cbz instruction within loop
-    for (auto& device : mDevices)
+    ControlDevice* device = getControlDevice(ControllerDefine::DeviceId(13));
+    if (device)
     {
-        if (device.getId() == 13)
-        {
-            mDevices.erase(&device);
-            delete &device;
-            break;
-        }
+        mDevices.erase(device);
+        delete device;
     }
 #endif  // cafe
 
diff --git a/modules/src/filedevice/nin/seadNinFileDeviceBaseNin.cpp b/modules/src/filedevice/nin/seadNinFileDeviceBaseNin.cpp
index 4caeab51..eb1c8641 100644
--- a/modules/src/filedevice/nin/seadNinFileDeviceBaseNin.cpp
+++ b/modules/src/filedevice/nin/seadNinFileDeviceBaseNin.cpp
@@ -24,7 +24,9 @@ NinFileDeviceBase::NinFileDeviceBase(const SafeString& name, const SafeString& m
 {
 }
 
-// NON_MATCHING: inverted branching for should_set_size
+// NON_MATCHING: every instruction matches except retail uses CBZ w8 for the is-file test while LLVM
+// selects TBZ w8,#0. Signedness and source-branch inversion emitted identical code and were reverted;
+// next hypothesis is the original integer/range-producing helper that prevents bit-test folding.
 FileDevice* NinFileDeviceBase::doOpen_(FileHandle* handle, const SafeString& path,
                                        FileDevice::FileOpenFlag flag)
 {
@@ -64,14 +66,14 @@ FileDevice* NinFileDeviceBase::doOpen_(FileHandle* handle, const SafeString& pat
             return nullptr;
         }
 
-        should_set_size = flag == cFileOpenFlag_Create || !is_file;
-        if (flag == cFileOpenFlag_Create || !is_file)
+        if (flag == cFileOpenFlag_Create)
         {
             if (is_file)
             {
                 mLastError = nn::fs::ResultPathAlreadyExists();
                 return nullptr;
             }
+
             const auto create_result = nn::fs::CreateFile(fs_path.cstr(), 0);
             if (create_result.IsFailure())
             {
@@ -83,6 +85,27 @@ FileDevice* NinFileDeviceBase::doOpen_(FileHandle* handle, const SafeString& pat
                 return nullptr;
             }
         }
+        else
+        {
+            if (is_file)
+            {
+                should_set_size = false;
+            }
+            else
+            {
+                const auto create_result = nn::fs::CreateFile(fs_path.cstr(), 0);
+                if (create_result.IsFailure())
+                {
+                    SEAD_WARN(
+                        "nn::fs::CreateFile failed. module = %d desc = %d inner_value = 0x%08x "
+                        "path = %s",
+                        create_result.GetModule(), create_result.GetDescription(),
+                        create_result.GetInnerValueForDebug(), fs_path.cstr());
+                    mLastError = create_result;
+                    return nullptr;
+                }
+            }
+        }
     }
 
     auto* handle_inner = getFileHandleInner_(handle, true);
diff --git a/modules/src/filedevice/seadArchiveFileDevice.cpp b/modules/src/filedevice/seadArchiveFileDevice.cpp
index 7b9bc1f2..94d9431f 100644
--- a/modules/src/filedevice/seadArchiveFileDevice.cpp
+++ b/modules/src/filedevice/seadArchiveFileDevice.cpp
@@ -184,7 +184,7 @@ u8* ArchiveFileDevice::doLoadWithEntryID_(s32 entry_id, LoadArg& arg)
         if (!buffer)
         {
             const s32 aligment_sign = Mathi::sign(arg.alignment);
-            const s32 alignment = std::max(Mathi::abs(arg.alignment), 32);
+            const s32 alignment = Mathi::abs(arg.alignment) > 32 ? Mathi::abs(arg.alignment) : 32;
             buffer = new (arg.heap, alignment * aligment_sign) u8[buffer_size];
             buffer_allocated = true;
         }
@@ -199,8 +199,8 @@ u8* ArchiveFileDevice::doLoadWithEntryID_(s32 entry_id, LoadArg& arg)
         }
 
         arg.read_size = bytes_read;
-        arg.need_unload = buffer_allocated;
         arg.roundup_size = buffer_size;
+        arg.need_unload = buffer_allocated;
         return buffer;
     }
 
diff --git a/modules/src/filedevice/seadFileDevice.cpp b/modules/src/filedevice/seadFileDevice.cpp
index 30459447..f1bceedc 100644
--- a/modules/src/filedevice/seadFileDevice.cpp
+++ b/modules/src/filedevice/seadFileDevice.cpp
@@ -268,7 +268,7 @@ u8* FileDevice::doLoad_(LoadArg& arg)
     {
         const s32 sign = (arg.alignment < 0) ? -1 : 1;
         s32 alignment = Mathi::abs(arg.alignment);
-        alignment = sign * ((alignment < cBufferMinAlignment) ? cBufferMinAlignment : alignment);
+        alignment = sign * ((alignment > cBufferMinAlignment) ? alignment : cBufferMinAlignment);
 
         Heap* heap = arg.heap;
         if (!heap)
diff --git a/modules/src/filedevice/seadFileDeviceMgr.cpp b/modules/src/filedevice/seadFileDeviceMgr.cpp
index 7af51f9a..443775d5 100644
--- a/modules/src/filedevice/seadFileDeviceMgr.cpp
+++ b/modules/src/filedevice/seadFileDeviceMgr.cpp
@@ -339,19 +339,9 @@ bool FileDeviceMgr::trySave(FileDevice::SaveArg& arg)
 }
 
 #ifdef NNSDK
-void FileDeviceMgr::mountSaveDataForDebug(Heap*)
-{
-    const auto result = nn::fs::MountSaveDataForDebug("save");
-    SEAD_ASSERT_MSG(
-        result.IsSuccess(),
-        "nn::fs::MountSaveDataForDebug() failed. module = %d desc = %d innervalue = 0x%08x",
-        result.GetModule(), result.GetDescription(), result.GetInnerValueForDebug());
-}
+void FileDeviceMgr::mountSaveDataForDebug(Heap*) {}
 
-void FileDeviceMgr::unmountSaveDataForDebug()
-{
-    nn::fs::Unmount("save");
-}
+void FileDeviceMgr::unmountSaveDataForDebug() {}
 #endif
 
 #ifdef cafe
diff --git a/modules/src/filedevice/seadPath.cpp b/modules/src/filedevice/seadPath.cpp
index 7dcac9e8..d6f92162 100644
--- a/modules/src/filedevice/seadPath.cpp
+++ b/modules/src/filedevice/seadPath.cpp
@@ -49,15 +49,16 @@ char getLastChar(const SafeString& str)
 }
 }  // namespace
 
-// NON_MATCHING: redundant checks for dot_index < 0 in SafeString::getPart() are optimized out
+// NON_MATCHING: Exact size and repeated getPart guards are restored with an unsigned index.
+// Search-loop register lifetimes and final slice formation still differ.
 bool Path::getExt(BufferedSafeString* ext, const SafeString& path)
 {
     SEAD_ASSERT_MSG(ext, "destination buffer is null");
 
     ext->trim(0);
 
-    const s32 dot_index = rfindCharIndex(path, '.');
-    if (dot_index < 0)
+    const u32 dot_index = rfindCharIndex(path, '.');
+    if (dot_index == u32(-1))
         return false;
 
     if (path.getPart(dot_index).include('/') || path.getPart(dot_index).include('\\'))
diff --git a/modules/src/framework/seadFramework.cpp b/modules/src/framework/seadFramework.cpp
index ed94c205..9bee9271 100644
--- a/modules/src/framework/seadFramework.cpp
+++ b/modules/src/framework/seadFramework.cpp
@@ -8,7 +8,7 @@
 namespace sead
 {
 Framework::CreateSystemTaskArg::CreateSystemTaskArg()
-    : hostio_parameter(NULL), infloop_detection_span()
+    : hostio_parameter(nullptr), heap(nullptr), infloop_detection_span(), infloop_unk(0x1000)
 {
 }
 
diff --git a/modules/src/framework/seadGameFramework.cpp b/modules/src/framework/seadGameFramework.cpp
index de4dfb53..9b8c9562 100644
--- a/modules/src/framework/seadGameFramework.cpp
+++ b/modules/src/framework/seadGameFramework.cpp
@@ -10,6 +10,7 @@
 #include <heap/seadHeapMgr.h>
 #include <resource/seadResourceMgr.h>
 #include <time/seadTickSpan.h>
+#include <thread/seadThread.h>
 
 namespace sead
 {
@@ -23,10 +24,13 @@ GameFramework::GameFramework()
     };
 }
 
-// NON_MATCHING: missing body
 GameFramework::~GameFramework()
 {
-    // required for RTTI functions to generate
+    if (mUnk4)
+    {
+        mUnk4->quitAndDestroySingleThread(false);
+        delete mUnk4;
+    }
 }
 
 void GameFramework::startDisplay()
diff --git a/modules/src/framework/seadMethodTree.cpp b/modules/src/framework/seadMethodTree.cpp
index 735610d8..e361fc2b 100644
--- a/modules/src/framework/seadMethodTree.cpp
+++ b/modules/src/framework/seadMethodTree.cpp
@@ -84,11 +84,11 @@ void MethodTreeNode::call()
 
 void MethodTreeNode::callRec_()
 {
-    if (!mPauseFlag.isOn(cPause_Self))
+    if (!(mPauseFlag & cPause_Self))
         (*mDelegateHolder.data())();
 
     auto* node = child();
-    if (node && !mPauseFlag.isOn(cPause_Child))
+    if (node && !(mPauseFlag & cPause_Child))
     {
         while (node)
         {
diff --git a/modules/src/gfx/nvn/seadDebugFontMgrNvn.cpp b/modules/src/gfx/nvn/seadDebugFontMgrNvn.cpp
index 35f2729a..65333dad 100644
--- a/modules/src/gfx/nvn/seadDebugFontMgrNvn.cpp
+++ b/modules/src/gfx/nvn/seadDebugFontMgrNvn.cpp
@@ -10,7 +10,7 @@
 namespace sead
 {
 SEAD_SINGLETON_DISPOSER_IMPL(DebugFontMgrJis1Nvn)
-DebugFontMgrJis1Nvn::~DebugFontMgrJis1Nvn() = default;
+DebugFontMgrJis1Nvn::~DebugFontMgrJis1Nvn() {}
 
 DebugFontMgrJis1Nvn::DebugFontMgrJis1Nvn() = default;
 
@@ -37,8 +37,6 @@ void DebugFontMgrJis1Nvn::initialize(Heap* heap, const char* shader_path, const
                          unk);
 }
 
-// SMO
-// NON_MATCHING: Stack
 void DebugFontMgrJis1Nvn::initializeFromBinary(Heap* heap, void* shader_binary, u64 shader_size,
                                                void* font_binary, u64 font_size,
                                                const void* table_binary, u32 unk3)
@@ -58,47 +56,55 @@ void DebugFontMgrJis1Nvn::initializeFromBinary(Heap* heap, void* shader_binary,
 
     nvnProgramInitialize(&mNvnProgram, device);
 
-    NVNmemoryPoolBuilder poolBuilder;
-    nvnMemoryPoolBuilderSetDefaults(&poolBuilder);
-    nvnMemoryPoolBuilderSetDevice(&poolBuilder, device);
-    nvnMemoryPoolBuilderSetFlags(&poolBuilder, NVN_MEMORY_POOL_FLAGS_CPU_UNCACHED |
-                                                   NVN_MEMORY_POOL_FLAGS_GPU_CACHED |
-                                                   NVN_MEMORY_POOL_FLAGS_SHADER_CODE);
-
-    size_t paddedShaderSize = (shader_size + 0xFFF) & ~0xFFF;
-
-    nvnMemoryPoolBuilderSetStorage(&poolBuilder, shader_binary, paddedShaderSize);
-    nvnMemoryPoolInitialize(&mPool2, &poolBuilder);
-
-    NVNbufferBuilder bufferBuilder;
-    nvnBufferBuilderSetDevice(&bufferBuilder, device);
-    nvnBufferBuilderSetDefaults(&bufferBuilder);
-    nvnBufferBuilderSetStorage(&bufferBuilder, &mPool2, 0, paddedShaderSize);
-    nvnBufferInitialize(&mBuffer1, &bufferBuilder);
-
-    NVNbufferAddress bufferAddress = nvnBufferGetAddress(&mBuffer1);
-
-    ShaderBinaryHeader* header = reinterpret_cast<ShaderBinaryHeader*>(shader_binary);
-    NVNshaderData data[2]{
-        {bufferAddress + header->shaderDataOffset,
-         reinterpret_cast<void*>(uintptr_t(shader_binary) + ptrdiff_t(header->offset1))},
-        {bufferAddress + header->offset4,
-         reinterpret_cast<void*>(uintptr_t(shader_binary) + ptrdiff_t(header->offset2))}};
-    nvnProgramSetShaders(&mNvnProgram, sizeof(data) / sizeof(NVNshaderData), data);
-    static size_t sPaddedBuffer1Size = (size_t(mBuffer1Size + 0x200) + 0xFFF) & ~0xFFF;
-
-    nvnMemoryPoolBuilderSetDefaults(&poolBuilder);
-    nvnMemoryPoolBuilderSetDevice(&poolBuilder, device);
-    nvnMemoryPoolBuilderSetFlags(&poolBuilder, NVN_MEMORY_POOL_FLAGS_CPU_UNCACHED |
-                                                   NVN_MEMORY_POOL_FLAGS_GPU_CACHED);
-    void* storage = new (heap) char[sPaddedBuffer1Size];
-    nvnMemoryPoolBuilderSetStorage(&poolBuilder, storage, sPaddedBuffer1Size);
-    nvnMemoryPoolInitialize(&mPool3, &poolBuilder);
-
-    nvnBufferBuilderSetDefaults(&bufferBuilder);
-    nvnBufferBuilderSetDevice(&bufferBuilder, device);
-    nvnBufferBuilderSetStorage(&bufferBuilder, &mPool3, 0, mBuffer1Size);
-    nvnBufferInitialize(&mBuffer2, &bufferBuilder);
+    union PoolBufferBuilder
+    {
+        NVNmemoryPoolBuilder pool;
+        NVNbufferBuilder buffer;
+    };
+
+    {
+        PoolBufferBuilder builder1;
+        PoolBufferBuilder builder2;
+        nvnMemoryPoolBuilderSetDefaults(&builder1.pool);
+        nvnMemoryPoolBuilderSetDevice(&builder1.pool, device);
+        nvnMemoryPoolBuilderSetFlags(&builder1.pool, NVN_MEMORY_POOL_FLAGS_CPU_UNCACHED |
+                                                         NVN_MEMORY_POOL_FLAGS_GPU_CACHED |
+                                                         NVN_MEMORY_POOL_FLAGS_SHADER_CODE);
+
+        size_t paddedShaderSize = (shader_size + 0xFFF) & ~0xFFF;
+
+        nvnMemoryPoolBuilderSetStorage(&builder1.pool, shader_binary, paddedShaderSize);
+        nvnMemoryPoolInitialize(&mPool2, &builder1.pool);
+
+        nvnBufferBuilderSetDevice(&builder2.buffer, device);
+        nvnBufferBuilderSetDefaults(&builder2.buffer);
+        nvnBufferBuilderSetStorage(&builder2.buffer, &mPool2, 0, paddedShaderSize);
+        nvnBufferInitialize(&mBuffer1, &builder2.buffer);
+
+        NVNbufferAddress bufferAddress = nvnBufferGetAddress(&mBuffer1);
+
+        ShaderBinaryHeader* header = reinterpret_cast<ShaderBinaryHeader*>(shader_binary);
+        NVNshaderData data[2]{
+            {bufferAddress + header->shaderDataOffset,
+             reinterpret_cast<void*>(uintptr_t(shader_binary) + ptrdiff_t(header->offset1))},
+            {bufferAddress + header->offset4,
+             reinterpret_cast<void*>(uintptr_t(shader_binary) + ptrdiff_t(header->offset2))}};
+        nvnProgramSetShaders(&mNvnProgram, sizeof(data) / sizeof(NVNshaderData), data);
+        static size_t sPaddedBuffer1Size = (size_t(mBuffer1Size + 0x200) + 0xFFF) & ~0xFFF;
+
+        nvnMemoryPoolBuilderSetDefaults(&builder1.pool);
+        nvnMemoryPoolBuilderSetDevice(&builder1.pool, device);
+        nvnMemoryPoolBuilderSetFlags(&builder1.pool, NVN_MEMORY_POOL_FLAGS_CPU_UNCACHED |
+                                                         NVN_MEMORY_POOL_FLAGS_GPU_CACHED);
+        void* storage = new (heap, 0x1000) char[sPaddedBuffer1Size];
+        nvnMemoryPoolBuilderSetStorage(&builder1.pool, storage, sPaddedBuffer1Size);
+        nvnMemoryPoolInitialize(&mPool3, &builder1.pool);
+
+        nvnBufferBuilderSetDefaults(&builder1.buffer);
+        nvnBufferBuilderSetDevice(&builder1.buffer, device);
+        nvnBufferBuilderSetStorage(&builder1.buffer, &mPool3, 0, mBuffer1Size);
+        nvnBufferInitialize(&mBuffer2, &builder1.buffer);
+    }
     mBuffer2Map = nvnBufferMap(&mBuffer2);
 
     NVNtextureBuilder texBuilder;
@@ -110,12 +116,15 @@ void DebugFontMgrJis1Nvn::initializeFromBinary(Heap* heap, void* shader_binary,
     nvnTextureBuilderSetPackagedTextureData(
         &texBuilder, reinterpret_cast<void*>(uintptr_t(font_binary) + 0x200));
 
-    nvnMemoryPoolBuilderSetDefaults(&poolBuilder);
-    nvnMemoryPoolBuilderSetDevice(&poolBuilder, device);
-    nvnMemoryPoolBuilderSetFlags(&poolBuilder, NVN_MEMORY_POOL_FLAGS_CPU_NO_ACCESS |
-                                                   NVN_MEMORY_POOL_FLAGS_GPU_CACHED);
-    nvnMemoryPoolBuilderSetStorage(&poolBuilder, font_binary, (font_size + 0xFFF) & ~0xFFF);
-    nvnMemoryPoolInitialize(&mPool1, &poolBuilder);
+    {
+        NVNmemoryPoolBuilder poolBuilder;
+        nvnMemoryPoolBuilderSetDefaults(&poolBuilder);
+        nvnMemoryPoolBuilderSetDevice(&poolBuilder, device);
+        nvnMemoryPoolBuilderSetFlags(&poolBuilder, NVN_MEMORY_POOL_FLAGS_CPU_NO_ACCESS |
+                                                       NVN_MEMORY_POOL_FLAGS_GPU_CACHED);
+        nvnMemoryPoolBuilderSetStorage(&poolBuilder, font_binary, (font_size + 0xFFF) & ~0xFFF);
+        nvnMemoryPoolInitialize(&mPool1, &poolBuilder);
+    }
 
     nvnTextureBuilderSetStorage(&texBuilder, &mPool1, 0x200);
     nvnTextureInitialize(&mNvnTexture, &texBuilder);
@@ -168,7 +177,7 @@ void DebugFontMgrJis1Nvn::end(DrawContext*) const {}
 // missing print and searchCharIndexFormCharCode_
 
 SEAD_SINGLETON_DISPOSER_IMPL(DebugFontMgrNvn)
-DebugFontMgrNvn::~DebugFontMgrNvn() = default;
+DebugFontMgrNvn::~DebugFontMgrNvn() {}
 
 DebugFontMgrNvn::DebugFontMgrNvn() = default;
 
diff --git a/modules/src/gfx/seadColor.cpp b/modules/src/gfx/seadColor.cpp
index c97c8569..5ef86cf0 100644
--- a/modules/src/gfx/seadColor.cpp
+++ b/modules/src/gfx/seadColor.cpp
@@ -209,10 +209,9 @@ Color4u8& Color4u8::operator-=(u8 x)
     return apply_([&](auto m) { this->*m = this->*m >= x ? this->*m - x : 0; });
 }
 
-// NON_MATCHING: regalloc, one harmless reordering
 Color4u8& Color4u8::operator*=(float x)
 {
-    return apply_([&](auto m) { this->*m = std::max(0.0f, this->*m * x); });
+    return apply_([&](auto m) { this->*m = std::fmax(0.0f, float(this->*m) * x); });
 }
 
 Color4u8& Color4u8::operator/=(float x)
@@ -224,12 +223,14 @@ Color4u8& Color4u8::operator/=(float x)
             return;
         }
         const float q = float(this->*m) / x;
+        u8 value;
         if (q < 0.0f)
-            this->*m = 0;
+            value = 0;
         else if (q > 255.0f)
-            this->*m = 255;
+            value = 255;
         else
-            this->*m = q;
+            value = q;
+        this->*m = value;
     });
 }
 
diff --git a/modules/src/hostio/seadHostIOCurve.cpp b/modules/src/hostio/seadHostIOCurve.cpp
index fdcfb4c0..084f41eb 100644
--- a/modules/src/hostio/seadHostIOCurve.cpp
+++ b/modules/src/hostio/seadHostIOCurve.cpp
@@ -63,10 +63,12 @@ T curveLinear_(f32 t, const CurveDataInfo* info, const T* f)
     const int i = n * t;
     if (i >= n)
         return f[n];
-    return f[i] + (fracPart(n * t) * (f[i + 1] - f[i]));
+    const f32 fraction = fracPart(n * t);
+    const T value = f[i];
+    const T next_value = f[i + 1];
+    return value + (next_value - value) * T(fraction);
 }
 
-// NON_MATCHING: instruction ordering
 template <typename T>
 T curveHermit_(f32 t, const CurveDataInfo* info, const T* f)
 {
@@ -84,11 +86,16 @@ T curveHermit_(f32 t, const CurveDataInfo* info, const T* f)
     const auto x = fracPart(n * t);
     const auto coeff = &f[j];
 
-    return ((2 * x * x * x) - (3 * x * x) + 1) * coeff[0]  // (2t^3 - 3t^2 + 1)p0
-           + ((-2 * x * x * x) + (3 * x * x)) * coeff[2]   // (-2t^3 + 2t^2)p1
-           + ((x * x * x) - (x * x)) * coeff[3]            // (t^3 - t^2)m1
-           + ((x * x * x) - (2 * x * x) + x) * f[j | 1]    // (t^3 - 2t^2 + t)m0
-        ;
+    const auto h00 = (2 * x * x * x) - (3 * x * x) + 1;
+    const auto h01 = (-2 * x * x * x) + (3 * x * x);
+    const auto h10 = (x * x * x) - (2 * x * x) + x;
+    const auto h11 = (x * x * x) - (x * x);
+
+    const T h00_t = h00;
+    const T h01_t = h01;
+    const T h10_t = h10;
+    const T h11_t = h11;
+    return coeff[0] * h00_t + coeff[2] * h01_t + f[j | 1] * h10_t + coeff[3] * h11_t;
 }
 
 template <typename T>
@@ -120,71 +127,107 @@ T curveSinPow2_(f32 t_, const CurveDataInfo*, const T* f)
     return y * y * f[1];
 }
 
-// NON_MATCHING: instruction reordering (which results in localized regalloc differences)
+// NON_MATCHING: Exact target size and endpoint pre-indexed load now match; only the compare-side address differs (SUB+indexed LDR instead of ADD pointer+LDUR). Next hypothesis: recover the original count/index wrapper that keeps the doubled index while materializing the compare pointer.
 template <typename T>
 T curveLinear2D_(f32 t_, const CurveDataInfo* info, const T* f)
 {
     const T t = t_;
-    if (f[0] >= t)
+    if (t <= f[0])
         return f[1];
 
-    const auto n = info->numUse / 2;
-    if (f[2 * (n - 1)] <= t)
-        return f[2 * (n - 1) + 1];
+    const s32 n = info->numUse / 2;
+    const u32 end = 2 * n;
+    if (t >= f[end - 2])
+    {
+        const T* end_ptr = f + end;
+        return *--end_ptr;
+    }
 
     for (s32 i = 0; i < n; ++i)
     {
         const auto j = 2 * i;
-        if (f[j + 2] > t)
-            return f[j + 1] + ((t - f[j]) / (f[j + 2] - f[j])) * (f[j + 3] - f[j + 1]);
+        if (t < f[j + 2])
+        {
+            const T x0 = f[j];
+            const T ratio = (t - x0) / (f[j + 2] - x0);
+            const T y0 = f[j | 1];
+            return y0 + ratio * (f[j + 3] - y0);
+        }
     }
     return 0;
 }
 
-// NON_MATCHING: same as curveHermit_<T>
 template <typename T>
 T curveHermit2D_(f32 t_, const CurveDataInfo* info, const T* f)
 {
-    const T t = t_;
     const s8 n = info->numUse / 3;
-    if (f[0] >= t)
+    const s32 end = 3 * n;
+    const T t = t_;
+    if constexpr (sizeof(T) == sizeof(f64))
+    {
+        if (t <= f[0])
+            return f[1];
+    }
+    else if (f[0] >= t)
         return f[1];
 
-    if (f[3 * (n - 1)] <= t)
-        return f[3 * (n - 1) + 1];
+    if constexpr (sizeof(T) == sizeof(f64))
+    {
+        if (t >= f[end - 3])
+            return f[end - 2];
+    }
+    else if (f[end - 3] <= t)
+        return f[end - 2];
 
     for (s32 i = 0; i < n; ++i)
     {
         const auto j = 3 * i;
-        if (f[j + 3] > t)
+        bool in_segment;
+        if constexpr (sizeof(T) == sizeof(f64))
+            in_segment = t < f[j + 3];
+        else
+            in_segment = f[j + 3] > t;
+        if (in_segment)
         {
             const auto x = (t - f[j]) / (f[j + 3] - f[j]);
-            return ((2 * x * x * x) - (3 * x * x) + 1) * f[j + 1]  // (2t^3 - 3t^2 + 1)p0
-                   + ((-2 * x * x * x) + (3 * x * x)) * f[j + 4]   // (-2t^3 + 2t^2)p1
-                   + ((x * x * x) - (x * x)) * f[j + 5]            // (t^3 - t^2)m1
-                   + ((x * x * x) - (2 * x * x) + x) * f[j + 2]    // (t^3 - 2t^2 + t)m0
-                ;
+            const auto h00 = (2 * x * x * x) - (3 * x * x) + 1;
+            const auto h01 = (-2 * x * x * x) + (3 * x * x);
+            const auto h10 = (x * x * x) - (2 * x * x) + x;
+            const auto h11 = (x * x * x) - (x * x);
+
+            const T h00_t = h00;
+            const T h01_t = h01;
+            const T h10_t = h10;
+            const T h11_t = h11;
+            return f[j + 1] * h00_t + f[j + 4] * h01_t + f[j + 2] * h10_t +
+                   f[j + 5] * h11_t;
         }
     }
 
     return 0;
 }
 
+// NON_MATCHING: Exact-size endpoint form recovered; compare-side address still uses a subtracted index rather than the retail pointer-plus-LDUR shape. Next hypothesis: recover the original count/index wrapper shared with curveLinear2D_.
 template <typename T>
 T curveStep2D_(f32 t_, const CurveDataInfo* info, const T* f)
 {
     const T t = t_;
-    const s8 n = info->numUse / 2;
     if (t <= f[0])
         return f[1];
 
-    if (t >= f[2 * (n - 1)])
-        return f[2 * (n - 1) + 1];
+    const s32 n = info->numUse / 2;
+    const u32 end = 2 * n;
+    if (t >= f[end - 2])
+    {
+        const T* end_ptr = f + end;
+        return *--end_ptr;
+    }
 
     for (s32 i = 0; i < n; ++i)
     {
-        if (t < f[2 * i + 2])
-            return f[2 * i + 1];
+        const s32 j = 2 * i;
+        if (t < f[j + 2])
+            return f[j + 1];
     }
     return 0;
 }
diff --git a/modules/src/math/seadMatrix.cpp b/modules/src/math/seadMatrix.cpp
index d148a418..ea2fa920 100644
--- a/modules/src/math/seadMatrix.cpp
+++ b/modules/src/math/seadMatrix.cpp
@@ -54,4 +54,67 @@ const Matrix44<f64> Matrix44<f64>::zero(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 template <>
 const Matrix44<f64> Matrix44<f64>::ident(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
 
+template <>
+void Matrix34CalcCommon<f32>::toQuat(BaseQuat<f32>& result, const BaseMtx34<f32>& matrix)
+{
+    const f32 w2 =
+        (matrix.m[0][0] + matrix.m[1][1] + matrix.m[2][2] + 1.0f) * 0.25f;
+    const f32 x2 = w2 - (matrix.m[1][1] + matrix.m[2][2]) * 0.5f;
+    const f32 y2 = w2 - (matrix.m[2][2] + matrix.m[0][0]) * 0.5f;
+    const f32 z2 = w2 - (matrix.m[0][0] + matrix.m[1][1]) * 0.5f;
+
+    const u8 index =
+        w2 > x2
+            ? (w2 > y2 ? (w2 > z2 ? 0 : 3) : (y2 > z2 ? 2 : 3))
+            : (x2 > y2 ? (x2 > z2 ? 1 : 3) : (y2 > z2 ? 2 : 3));
+
+    f32 last;
+    f32 scale;
+    switch (index & 3)
+    {
+    case 3:
+    {
+        const f32 root = MathCalcCommon<f32>::sqrt(z2);
+        result.z = root;
+        const f32 scale3 = 0.25f / root;
+        result.w = scale3 * (matrix.m[1][0] - matrix.m[0][1]);
+        result.x = scale3 * (matrix.m[2][0] + matrix.m[0][2]);
+        result.y = scale3 * (matrix.m[2][1] + matrix.m[1][2]);
+        return;
+    }
+    case 1:
+    {
+        const f32 root = MathCalcCommon<f32>::sqrt(x2);
+        result.x = root;
+        scale = 0.25f / root;
+        result.w = scale * (matrix.m[2][1] - matrix.m[1][2]);
+        result.y = scale * (matrix.m[0][1] + matrix.m[1][0]);
+        last = matrix.m[0][2] + matrix.m[2][0];
+        break;
+    }
+    case 2:
+    {
+        const f32 root = MathCalcCommon<f32>::sqrt(y2);
+        result.y = root;
+        const f32 scale2 = 0.25f / root;
+        result.w = scale2 * (matrix.m[0][2] - matrix.m[2][0]);
+        result.z = scale2 * (matrix.m[1][2] + matrix.m[2][1]);
+        result.x = scale2 * (matrix.m[1][0] + matrix.m[0][1]);
+        return;
+    }
+    default:
+    {
+        const f32 root = MathCalcCommon<f32>::sqrt(w2);
+        scale = 0.25f / root;
+        result.w = root;
+        result.x = scale * (matrix.m[2][1] - matrix.m[1][2]);
+        result.y = scale * (matrix.m[0][2] - matrix.m[2][0]);
+        last = matrix.m[1][0] - matrix.m[0][1];
+        break;
+    }
+    }
+
+    result.z = scale * last;
+}
+
 }  // namespace sead
diff --git a/modules/src/mc/seadCoreInfo.cpp b/modules/src/mc/seadCoreInfo.cpp
index 4cd598df..59a7df9f 100644
--- a/modules/src/mc/seadCoreInfo.cpp
+++ b/modules/src/mc/seadCoreInfo.cpp
@@ -55,17 +55,7 @@ void CoreInfo::configure()
 #endif
 }
 
-void CoreInfo::dump()
-{
-    system::Print("* num cores %d\n", sNumCores);
-    for (u32 i = 0; i < sNumCores; ++i)
-    {
-        system::Print("  [%d] : %s : PlatformCoreId=%d\n", i, i == 0 ? "Main" : "Sub ",
-                      sPlatformCoreId[i]);
-    }
-    system::Print("all mask : %x\n", u32(getMaskAll()));
-    system::Print("all sub mask : %x\n", u32(getMaskSubAll()));
-}
+void CoreInfo::dump() {}
 
 u32 CoreInfo::getPlatformMask(CoreId id)
 {
diff --git a/modules/src/mc/seadJobQueue.cpp b/modules/src/mc/seadJobQueue.cpp
index 33f40c4c..d8765743 100644
--- a/modules/src/mc/seadJobQueue.cpp
+++ b/modules/src/mc/seadJobQueue.cpp
@@ -8,10 +8,12 @@
 
 namespace sead
 {
-// NON_MATCHING
+// NON_MATCHING: Retail keeps the original this base and emits three positive-offset flag stores; Clang rebases this through a writeback store and uses negative offsets. Layout and initialized values match.
 JobQueue::JobQueue()
 {
-    mCoreEnabled.fill(0);
+    mCoreEnabled[0] = 0;
+    mCoreEnabled[1] = 0;
+    mCoreEnabled[2] = 0;
     mNumDoneJobs = 0;
     mGranularity.fill(8);
 }
@@ -33,15 +35,15 @@ void JobQueue::runAll(u32* finished_jobs)
 
 bool JobQueue::isAllParticipantThrough() const
 {
-    for (auto value : mCoreEnabled.mBuffer)
-        if (value)
+    for (s32 i = 0; i < mCoreEnabled.size(); ++i)
+        if (mCoreEnabled[i])
             return false;
     return true;
 }
 
 void JobQueue::setGranularity(CoreId core, u32 x)
 {
-    mGranularity[core] = x ? x : 1;
+    mGranularity[core] = x == 0 ? 1 : x;
 }
 
 void JobQueue::setGranularity(u32 x)
@@ -50,14 +52,16 @@ void JobQueue::setGranularity(u32 x)
         setGranularity(i, x);
 }
 
-// NON_MATCHING: CMP (AND x y), #0 gets optimized into a TST
 void JobQueue::setCoreMaskAndWaitType(CoreIdMask mask, SyncType type)
 {
     mStatus = Status::_6;
     mMask = mask;
     for (u32 i = 0; i < CoreInfo::getNumCores(); ++i)
     {
-        mCoreEnabled[i] = mask.isOn(i);
+        if (mask.isOn(i))
+            mCoreEnabled[i] = 1;
+        else
+            mCoreEnabled[i] = 0;
         mNumDoneJobs = 0;
     }
     mSyncType = type;
@@ -90,32 +94,42 @@ void JobQueue::wait_AT_WORKER()
     }
 }
 
+// NON_MATCHING: Retail preserves separate B.LO and B.NE enum tests sharing one compare; Clang folds the equivalent switch cases into a single range branch.
 void JobQueue::wait()
 {
-    if (u32(mSyncType) >= 2)
+    switch (mSyncType)
     {
-        if (mSyncType != SyncType::cThread)
-            return;
+    case SyncType::cNoSync:
+    case SyncType::cCore:
+        break;
+    case SyncType::cThread:
         SEAD_ASSERT_MSG(false, "NOT IMPLEMENTED.\n");
+        break;
+    default:
+        return;
     }
+
     if (!isDone_())
         mFinishEvent.wait();
 }
 
-// NON_MATCHING: stack
+// NON_MATCHING: Instruction count and behavior match, but Clang assigns the queue/name live ranges to x19/x20 opposite retail. Next hypothesis is the original SafeString temporary lifetime/order.
 void PerfJobQueue::initialize(const char* name, Heap* heap)
 {
     mBars.allocBufferAssert(CoreInfo::getNumCores(), heap);
     mInts.allocBufferAssert(CoreInfo::getNumCores(), heap);
 
     for (s32 i = 0; i < mInts.size(); ++i)
-        mInts[CoreId(i)] = 0;
+    {
+        CoreId core(i);
+        mInts[core] = 0;
+    }
 
     for (s32 i = 0; i < mBars.size(); ++i)
-        mBars[i].setName(CoreId(i).text());
+        mBars[i].SafeStringBase<char>::operator=(SafeString("?"));
 
-    mProcessMeterBar.setColor({1, 1, 0, 1});
-    mProcessMeterBar.setName(name);
+    SafeString queue_name(name);
+    mProcessMeterBar.SafeStringBase<char>::operator=(queue_name);
 }
 
 void PerfJobQueue::finalize()
@@ -130,36 +144,49 @@ void PerfJobQueue::reset()
         mInts[CoreId(i)] = 0;
 }
 
-// NON_MATCHING: stack
 void PerfJobQueue::measureBeginDeque()
 {
-    auto& bar = mBars[CoreInfo::getCurrentCoreId()];
-    static_cast<void>(mInts[CoreInfo::getCurrentCoreId()]);
-    bar.measureBegin(Color4f::cWhite);
+    union UninitializedCoreId
+    {
+        CoreId value;
+        UninitializedCoreId() {}
+        ~UninitializedCoreId() {}
+    } core;
+
+    static_cast<void>(mBars[CoreInfo::getCurrentCoreId()]);
+    core.value = CoreInfo::getCurrentCoreId();
+    static_cast<void>(mInts[core.value]);
 }
 
 void PerfJobQueue::measureEndDeque()
 {
-    mBars[CoreInfo::getCurrentCoreId()].measureEnd();
+    static_cast<void>(mBars[CoreInfo::getCurrentCoreId()]);
 }
 
 void PerfJobQueue::measureBeginRun()
 {
-    auto& bar = mBars[CoreInfo::getCurrentCoreId()];
-    auto& idx = mInts[CoreInfo::getCurrentCoreId()];
-    bar.measureBegin(getBarColor(idx));
+    union UninitializedCoreId
+    {
+        CoreId value;
+        UninitializedCoreId() {}
+        ~UninitializedCoreId() {}
+    } core;
+
+    static_cast<void>(mBars[CoreInfo::getCurrentCoreId()]);
+    core.value = CoreInfo::getCurrentCoreId();
+    auto& idx = mInts[core.value];
+    static_cast<void>(getBarColor(idx));
     idx = (idx + 1) % 9;
 }
 
 void PerfJobQueue::measureEndRun()
 {
-    mBars[CoreInfo::getCurrentCoreId()].measureEnd();
+    static_cast<void>(mBars[CoreInfo::getCurrentCoreId()]);
 }
 
-// NON_MATCHING: loading sColors...
 const Color4f& PerfJobQueue::getBarColor(u32 idx) const
 {
-    static const SafeArray<Color4f, 9> sColors = {{
+    alignas(16) static const Color4f sColors[9] = {
         {0.2078431397676468, 0.8313725590705872, 0.6274510025978088, 1.0},
         {0.0, 0.6666666865348816, 0.4470588266849518, 1.0},
         {0.125490203499794, 0.49803921580314636, 0.3764705955982208, 1.0},
@@ -167,37 +194,19 @@ const Color4f& PerfJobQueue::getBarColor(u32 idx) const
         {1.0, 0.6000000238418579, 0.0, 1.0},
         {1.0, 0.6980392336845398, 0.250980406999588, 1.0},
         {0.6901960968971252, 0.1725490242242813, 0.29411765933036804, 1.0},
-        {0.0, 0.9176470637321472, 0.21568627655506134, 1.0},
+        {0.9176470637321472, 0.0, 0.21568627655506134, 1.0},
         {0.9607843160629272, 0.239215686917305, 0.40784314274787903, 1.0},
-    }};
-    return sColors.mBuffer[idx];
+    };
+    return sColors[idx];
 }
 
-void PerfJobQueue::attachProcessMeter()
-{
-    if (!ProcessMeter::instance())
-        return;
-
-    for (s32 i = 0; i < mBars.size(); ++i)
-        ProcessMeter::instance()->attachProcessMeterBar(&mBars[i]);
-
-    ProcessMeter::instance()->attachProcessMeterBar(&mProcessMeterBar);
-}
+void PerfJobQueue::attachProcessMeter() {}
 
-void PerfJobQueue::detachProcessMeter()
-{
-    if (!ProcessMeter::instance())
-        return;
-
-    for (s32 i = 0; i < mBars.size(); ++i)
-        ProcessMeter::instance()->detachProcessMeterBar(&mBars[i]);
-
-    ProcessMeter::instance()->detachProcessMeterBar(&mProcessMeterBar);
-}
+void PerfJobQueue::detachProcessMeter() {}
 
+// NON_MATCHING: Base JobQueue values and derived fields are correct; the remaining diff inherits the base-constructor this-rebasing/addressing-mode choice.
 FixedSizeJQ::FixedSizeJQ()
 {
-    _230 = true;
     mStatus = Status::_0;
     mNumJobs = 0;
     mNumProcessedJobs = 0;
@@ -207,15 +216,13 @@ void FixedSizeJQ::begin() {}
 
 // TODO: Splatoon 2 and BotW sead have a different implementation which checks _230 and the current
 // core number...
+// NON_MATCHING: Retail materializes ret/end/begin before the size tests and assigns different whole-function registers; equivalent nested/source-order rewrites are flattened by Clang. Next hypothesis is the exact original branch nesting around size and mNumJobs.
 bool FixedSizeJQ::run(u32 size, u32* finished_jobs, Worker* worker)
 {
     *finished_jobs = 0;
 
-#ifdef SEAD_DEBUG
     mPerf.measureBeginDeque();
-#endif
     u32 num_finished = 0;
-    // NON_MATCHING: Clang refuses to materialize these variables here...
     bool ret = true;
     s32 begin = 0;
     s32 end = -1;
@@ -238,13 +245,9 @@ bool FixedSizeJQ::run(u32 size, u32* finished_jobs, Worker* worker)
         end = num_finished + begin - 1;
         ret = num_finished + begin >= num_jobs;
     }
-#ifdef SEAD_DEBUG
     mPerf.measureEndDeque();
-#endif
 
-#ifdef SEAD_DEBUG
     mPerf.measureBeginRun();
-#endif
     if (worker)
         worker->setState(Worker::State::cRunning_Run);
 
@@ -253,9 +256,7 @@ bool FixedSizeJQ::run(u32 size, u32* finished_jobs, Worker* worker)
 
     if (worker)
         worker->setState(Worker::State::cRunning_AfterRun);
-#ifdef SEAD_DEBUG
     mPerf.measureEndRun();
-#endif
 
     if (ret)
     {
@@ -274,9 +275,7 @@ bool FixedSizeJQ::run(u32 size, u32* finished_jobs, Worker* worker)
 
 void FixedSizeJQ::initialize(u32 size, Heap* heap)
 {
-#ifdef SEAD_DEBUG
     mPerf.initialize(getName().cstr(), heap);
-#endif
 
     ScopedLock<JobQueueLock> lock(&mLock);
     mJobs.allocBufferAssert(size, heap);
@@ -287,9 +286,7 @@ void FixedSizeJQ::initialize(u32 size, Heap* heap)
 
 void FixedSizeJQ::finalize()
 {
-#ifdef SEAD_DEBUG
     mPerf.finalize();
-#endif
     mJobs.freeBuffer();
 }
 
@@ -341,9 +338,7 @@ u32 FixedSizeJQ::deque(Job** jobs, u32 count)
 
 bool FixedSizeJQ::rewind()
 {
-#ifdef SEAD_DEBUG
     mPerf.reset();
-#endif
     mNumProcessedJobs = 0;
     return true;
 }
@@ -351,9 +346,7 @@ bool FixedSizeJQ::rewind()
 void FixedSizeJQ::clear()
 {
     mStatus = Status::_5;
-#ifdef SEAD_DEBUG
     mPerf.reset();
-#endif
     mNumJobs = 0;
     mNumProcessedJobs = 0;
     mSyncType = SyncType::cNoSync;
diff --git a/modules/src/prim/seadBitFlag.cpp b/modules/src/prim/seadBitFlag.cpp
index 0367d3ff..5437a775 100644
--- a/modules/src/prim/seadBitFlag.cpp
+++ b/modules/src/prim/seadBitFlag.cpp
@@ -25,13 +25,17 @@ int BitFlagUtil::findOnBitFromRight(u32 x, int num)
     if (!x)
         return -1;
 
-    while (--num > 0)
+    s32 i = num;
+    const s32 result = -1;
+    while (true)
     {
+        --i;
+        if (i <= 0)
+            return countContinuousOffBitFromRight(x);
         x &= x - 1;
         if (!x)
-            return -1;
+            return result;
     }
-    return countContinuousOffBitFromRight(x);
 }
 
 int BitFlagUtil::countRightOnBit64(u64 x, int bit)
@@ -47,13 +51,18 @@ int BitFlagUtil::findOnBitFromRight64(u64 x, int num)
     if (!x)
         return -1;
 
-    while (--num > 0)
+    s32 i = num;
+    const s32 result = -1;
+    while (true)
     {
+        --i;
+        if (i <= 0)
+            return countContinuousOffBitFromRight64(x);
         x &= x - 1;
         if (!x)
-            return -1;
+            return result;
     }
-    return countContinuousOffBitFromRight64(x);
 }
 
+
 }  // namespace sead
diff --git a/modules/src/prim/seadSafeString.cpp b/modules/src/prim/seadSafeString.cpp
index 6ba9d330..3ed09c31 100644
--- a/modules/src/prim/seadSafeString.cpp
+++ b/modules/src/prim/seadSafeString.cpp
@@ -68,15 +68,15 @@ HeapSafeStringBase<char16>::operator=(const SafeStringBase<char16>& other)
 template <>
 void BufferedSafeStringBase<char>::assureTerminationImpl_() const
 {
-    auto* mutableSafeString = const_cast<BufferedSafeStringBase<char>*>(this);
-    mutableSafeString->getMutableStringTop_()[mBufferSize - 1] = cNullChar;
+    char* string_top = const_cast<char*>(this->mStringTop);
+    string_top[mBufferSize - 1] = cNullChar;
 }
 
 template <>
 void BufferedSafeStringBase<char16>::assureTerminationImpl_() const
 {
-    auto* mutableSafeString = const_cast<BufferedSafeStringBase<char16>*>(this);
-    mutableSafeString->getMutableStringTop_()[mBufferSize - 1] = cNullChar;
+    char16* string_top = const_cast<char16*>(this->mStringTop);
+    string_top[mBufferSize - 1] = cNullChar;
 }
 
 template <>
@@ -169,7 +169,7 @@ s32 BufferedSafeStringBase<char16>::appendWithFormat(const char16* format, ...)
     return ret;
 }
 
-// NON_MATCHING
+// NON_MATCHING: Retail nested forward/backward overlap scans and byte-scaled memory operations are reconstructed. char16 is exact-size (1312 bytes); char is 16 bytes short. Remaining differences are stack/register lifetimes, especially the backward scan spill set and char-only source-pointer lifetime.
 template <typename T>
 s32 replaceStringImpl_(T* dst, s32* length, s32 dst_size, const T* src, s32 src_size,
                        const SafeStringBase<T>& old_str, const SafeStringBase<T>& new_str,
@@ -190,14 +190,14 @@ s32 replaceStringImpl_(T* dst, s32* length, s32 dst_size, const T* src, s32 src_
         *is_buffer_overflow = src_size >= dst_size;
         if (src_size >= dst_size)
         {
-            MemUtil::copy(dst, src, dst_max_idx);
+            MemUtil::copy(dst, src, sizeof(T) * dst_max_idx);
             dst[dst_max_idx] = SafeStringBase<T>::cNullChar;
             if (length)
                 *length = dst_max_idx;
         }
         else
         {
-            MemUtil::copy(dst, src, src_size + 1);
+            MemUtil::copy(dst, src, sizeof(T) * (src_size + 1));
             if (length)
                 *length = src_size;
         }
@@ -215,7 +215,7 @@ s32 replaceStringImpl_(T* dst, s32* length, s32 dst_size, const T* src, s32 src_
         // First, terminate the string and check for buffer overflow.
         while (src_final_size < src_size)
         {
-            const s32 cmp = MemUtil::compare(&dst[src_final_size], old_cstr, old_str_len);
+            const s32 cmp = MemUtil::compare(&dst[src_final_size], old_cstr, sizeof(T) * old_str_len);
             src_final_size += cmp == 0 ? old_str_len : 1;
             dst_final_size += cmp == 0 ? new_str_len : 1;
             if (dst_final_size >= dst_size)
@@ -238,37 +238,31 @@ s32 replaceStringImpl_(T* dst, s32* length, s32 dst_size, const T* src, s32 src_
                 *length = dst_final_size;
         }
 
-        s32 dst_i = dst_final_size - 1;
+        u32 dst_i = dst_final_size - 1;
         s32 src_i = src_final_size - 1;
         while (src_i >= 0)
         {
-            const s32 cmp = MemUtil::compare(&dst[src_i + 1 - old_str_len], old_cstr, old_str_len);
-            if (cmp == 0)
+            s64 offset = 0;
+            while (MemUtil::compare(&dst[src_i + offset + 1 - old_str_len], old_cstr,
+                                    sizeof(T) * old_str_len) != 0)
             {
-                dst_i -= new_str_len;
-                const s32 copy_size = std::min(new_str_len, dst_size - 2 - dst_i);
-                if (copy_size > 0)
-                {
-                    MemUtil::copy(&dst[dst_i + 1], new_cstr, copy_size);
-                    ret += 1;
-                }
-                src_i -= old_str_len;
+                if (static_cast<s32>(dst_i) + offset < dst_max_idx)
+                    dst[static_cast<s32>(dst_i) + offset] = dst[src_i + offset];
+                --offset;
+                if (src_i + offset + 1 <= 0)
+                    return ret;
             }
-            else
+
+            dst_i = static_cast<u32>(static_cast<s32>(dst_i) + offset - new_str_len);
+            const s32 copy_size =
+                std::min(new_str_len, dst_size - 2 - static_cast<s32>(dst_i));
+            if (copy_size > 0)
             {
-                if (dst_i < dst_max_idx)
-                    dst[dst_i] = dst[src_i];
-                if (src_i < 1)
-                {
-                    --src_i;
-                    --dst_i;
-                    break;
-                }
+                MemUtil::copy(&dst[static_cast<s32>(dst_i) + 1], new_cstr, sizeof(T) * copy_size);
+                ++ret;
             }
+            src_i += offset - old_str_len;
         }
-
-        SEAD_ASSERT(dst_i == -1);
-        SEAD_ASSERT(src_i == -1);
     }
     // Simpler case.
     else
@@ -277,41 +271,46 @@ s32 replaceStringImpl_(T* dst, s32* length, s32 dst_size, const T* src, s32 src_
         s32 buffer_i = 0;
         while (target_i < src_size)
         {
-            const s32 cmp = MemUtil::compare(&src[target_i], old_cstr, old_str_len);
-            // Not old_str, copy one character to the buffer.
-            if (cmp != 0)
+            s32 offset = 0;
+            while (MemUtil::compare(&src[target_i + offset], old_cstr, sizeof(T) * old_str_len) != 0)
             {
-                if (buffer_i < dst_max_idx)
+                if (buffer_i + offset >= dst_max_idx)
                 {
-                    dst[buffer_i++] = src[target_i++];
-                    continue;
+                    *is_buffer_overflow = true;
+                    dst[dst_max_idx] = SafeStringBase<T>::cNullChar;
+                    if (length)
+                        *length = dst_max_idx;
+                    return ret;
                 }
-            }
-            // Found old_str, copy new_str to the buffer.
-            else
-            {
-                const s32 copy_size = std::min(new_str_len, dst_max_idx - buffer_i);
-                if (copy_size >= 1)
-                    MemUtil::copy(&dst[buffer_i], new_cstr, copy_size);
-                ret += new_str_len == 0 || copy_size > 0;
-                if (copy_size >= new_str_len)
+
+                dst[buffer_i + offset] = src[target_i + offset];
+                ++offset;
+                if (target_i + offset >= src_size)
                 {
-                    buffer_i += new_str_len;
-                    target_i += old_str_len;
-                    continue;
+                    buffer_i += offset;
+                    dst[buffer_i] = SafeStringBase<T>::cNullChar;
+                    if (length)
+                        *length = buffer_i;
+                    return ret;
                 }
             }
 
-            // Buffer overflow.
-            *is_buffer_overflow = true;
-            dst[dst_max_idx] = SafeStringBase<T>::cNullChar;
-            if (length)
-                *length = dst_max_idx;
-            return ret;
-        }
+            const s32 copy_size = std::min(new_str_len, dst_max_idx - buffer_i - offset);
+            if (copy_size >= 1)
+                MemUtil::copy(&dst[buffer_i + offset], new_cstr, sizeof(T) * copy_size);
+            ret += new_str_len == 0 || copy_size > 0;
+            if (copy_size < new_str_len)
+            {
+                *is_buffer_overflow = true;
+                dst[dst_max_idx] = SafeStringBase<T>::cNullChar;
+                if (length)
+                    *length = dst_max_idx;
+                return ret;
+            }
 
-        SEAD_ASSERT(buffer_i <= dst_size);
-        SEAD_ASSERT(target_i == src_size);
+            buffer_i += offset + new_str_len;
+            target_i += offset + old_str_len;
+        }
 
         dst[buffer_i] = SafeStringBase<T>::cNullChar;
         if (length)
diff --git a/modules/src/prim/seadStringBuilder.cpp b/modules/src/prim/seadStringBuilder.cpp
index e02bb842..c050cb04 100644
--- a/modules/src/prim/seadStringBuilder.cpp
+++ b/modules/src/prim/seadStringBuilder.cpp
@@ -388,9 +388,8 @@ s32 StringBuilderBase<T>::append(const T* str, s32 append_length)
 template s32 StringBuilder::append(const char* str, s32 append_length);
 template s32 WStringBuilder::append(const char16* str, s32 append_length);
 
-// NON_MATCHING: regalloc differences
 template <typename T>
-s32 appendImpl_(T* buffer_, s32* length_, const s32 buffer_size_, T c, s32 num)
+s32 appendImpl_(T* volatile* buffer_, s32* length_, const s32 buffer_size_, T c, s32 num)
 {
     const s32 length = *length_;
 
@@ -401,10 +400,14 @@ s32 appendImpl_(T* buffer_, s32* length_, const s32 buffer_size_, T c, s32 num)
         num = buffer_size_ - length - 1;
     }
 
+    if (num < 1)
+        return 0;
+
+    T* buffer = *buffer_;
     for (s32 i = 0; i < num; ++i)
-        buffer_[length + i] = c;
+        buffer[length + i] = c;
 
-    buffer_[length + num] = SafeStringBase<T>::cNullChar;
+    buffer[length + num] = SafeStringBase<T>::cNullChar;
     *length_ = length + num;
     return num;
 }
@@ -421,7 +424,7 @@ s32 StringBuilderBase<T>::append(T c, s32 num)
     if (num == 0)
         return 0;
 
-    return appendImpl_(mBuffer, &mLength, mBufferSize, c, num);
+    return appendImpl_(&mBuffer, &mLength, mBufferSize, c, num);
 }
 
 template s32 StringBuilder::append(char c, s32 n);
@@ -430,24 +433,13 @@ template s32 WStringBuilder::append(char16 c, s32 n);
 template <typename T>
 s32 StringBuilderBase<T>::chop(s32 chop_num)
 {
-    s32 length = this->calcLength();
-    T* buffer = getMutableStringTop_();
-    const auto fail = [=] {
-        SEAD_ASSERT_MSG(false, "chop_num(%d) out of range[0, %d]", chop_num, length);
-    };
-
     if (chop_num < 0)
-    {
-        fail();
         return 0;
-    }
 
-    if (chop_num > length)
-    {
-        fail();
-        length = mLength;
-        chop_num = mLength;
-    }
+    T* buffer = mBuffer;
+    const s32 length = mLength;
+    if (length < chop_num)
+        chop_num = length;
 
     const s32 new_length = length - chop_num;
     buffer[new_length] = SafeStringBase<T>::cNullChar;
@@ -555,7 +547,7 @@ s32 StringBuilderBase<T>::rstrip(const T* characters)
 template s32 StringBuilder::rstrip(const char* characters);
 template s32 WStringBuilder::rstrip(const char16* characters);
 
-// NON_MATCHING: equivalent, two instruction reorders
+// NON_MATCHING: Retail schedules the packed-length ADD before the speculative index SUB; Clang emits the same independent recurrence updates in reverse order. Next hypothesis is the original loop form that keeps the packed length as the primary induction variable.
 template <typename T>
 s32 StringBuilderBase<T>::rstripUnprintableAsciiChars()
 {
@@ -636,19 +628,45 @@ template s32 WStringBuilder::trimMatchedString(const char16* str);
 template <typename T>
 s32 StringBuilderBase<T>::replaceChar(T old_char, T new_char)
 {
-    const s32 length = this->calcLength();
-    T* buffer = getMutableStringTop_();
-
-    s32 replaced_count = 0;
-    for (s32 i = 0; i < length; ++i)
+    if constexpr (sizeof(T) == 1)
     {
-        if (buffer[i] == old_char)
+        const s32 length = this->calcLength();
+        T* buffer = getMutableStringTop_();
+
+        s32 replaced_count = 0;
+        for (s32 i = 0; i < length; ++i)
         {
-            ++replaced_count;
-            buffer[i] = new_char;
+            if (buffer[i] == old_char)
+            {
+                ++replaced_count;
+                buffer[i] = new_char;
+            }
         }
+        return replaced_count;
+    }
+    else
+    {
+        s32 remaining = this->calcLength();
+        if (remaining < 1)
+            return 0;
+
+        T* buffer = getMutableStringTop_();
+        s32 replaced_count = 0;
+#pragma clang loop unroll(disable)
+        do
+        {
+            if (*buffer == old_char)
+            {
+                ++replaced_count;
+                *buffer = new_char;
+            }
+
+            --remaining;
+            ++buffer;
+        } while (remaining != 0);
+
+        return replaced_count;
     }
-    return replaced_count;
 }
 
 template s32 StringBuilder::replaceChar(char old_char, char new_char);
diff --git a/modules/src/resource/seadSZSDecompressor.cpp b/modules/src/resource/seadSZSDecompressor.cpp
index 8534d124..b495f1ed 100644
--- a/modules/src/resource/seadSZSDecompressor.cpp
+++ b/modules/src/resource/seadSZSDecompressor.cpp
@@ -119,10 +119,10 @@ __attribute__((aligned(0x20))) s32 decodeSZSCafeAsm_(void* dst, const void* src)
 }  // namespace
 
 #ifdef SWITCH
-s32 decodeSZSNxAsm64_(void* dst, const void* src)
+__attribute__((noinline, not_tail_called)) s32 decodeSZSNxAsm64_(void* dst, const void* src)
 {
     register s32 error asm("w2");
-    asm("ldr w5, [%[src],#4]\n"
+    asm volatile("ldr w5, [%[src],#4]\n"
         "rev w4, w5\n"
         "mov %w[error], w4\n"
         "add %[src], %[src], #0x10\n"
@@ -187,12 +187,12 @@ void SZSDecompressor::DecompContext::initialize(void* dst)
     destp = static_cast<u8*>(dst);
     destCount = 0;
     forceDestCount = 0;
-    flagMask = 0;
-    flags = 0;
-    packHigh = 0;
+    headerSize = 0x10;
     step = SZSDecompressor::cStepNormal;
     lzOffset = 0;
-    headerSize = 0x10;
+    packHigh = 0;
+    flags = 0;
+    flagMask = 0;
 }
 
 SZSDecompressor::SZSDecompressor(u32 workSize, u8* workBuffer) : Decompressor("szs")
@@ -333,54 +333,49 @@ u32 SZSDecompressor::getDecompSize(const void* src)
     return Endian::toHostU32(Endian::cBig, BitUtil::bitCastPtr<u32>(src, 4));
 }
 
+// NON_MATCHING: The retail loop carries both the raw decremented header count and a byte-masked copy; current codegen adds two redundant masks.
 s32 SZSDecompressor::readHeader_(DecompContext* context, const u8* src, u32 srcSize)
 {
     s32 len = 0;
 
     while (context->headerSize != 0)
     {
-        context->headerSize -= 1;
+        const u8 header_size = context->headerSize;
+        context->headerSize = header_size - 1;
 
-        if (context->headerSize == 0xF)
+        switch (header_size)
         {
+        case 0x10:
             if (*src != 0x59)
                 return -1;
-        }
-
-        else if (context->headerSize == 0xE)
-        {
+            break;
+        case 0xF:
             if (*src != 0x61)
                 return -1;
-        }
-
-        else if (context->headerSize == 0xD)
-        {
+            break;
+        case 0xE:
             if (*src != 0x7A)
                 return -1;
-        }
-
-        else if (context->headerSize == 0xC)
-        {
+            break;
+        case 0xD:
             if (*src != 0x30)
                 return -1;
+            break;
+        default:
+            if (context->headerSize >= 8)
+                context->destCount |= static_cast<u32>(*src) << (context->headerSize * 8 - 0x40);
+            break;
         }
 
-        else if (7 < context->headerSize)
-            context->destCount |= static_cast<u32>(*src) << (context->headerSize - 8) * 8;
-
-        src++;
-        len += 1;
+        ++src;
+        ++len;
         if (--srcSize == 0 && context->headerSize != 0)
-            return len;
+            return -1;
     }
 
-    if (context->forceDestCount < 1)
-        return len;
+    if (context->forceDestCount >= 1 && context->forceDestCount < context->destCount)
+        context->destCount = context->forceDestCount;
 
-    if (context->destCount <= context->forceDestCount)
-        return len;
-
-    context->destCount = context->forceDestCount;
     return len;
 }
 
@@ -476,20 +471,19 @@ s32 SZSDecompressor::decomp(void* dst, u32 dstSize, const void* src, u32)
     if (magic != 0x59617A30)
         return -1;
 
-    u32 decompSize = getDecompSize(src);
-    s32 error = -2;
-    if (dstSize >= decompSize)
-    {
+    const u32 decompSize = getDecompSize(src);
+    if (dstSize < decompSize)
+        return -2;
+
 #ifdef cafe
-        error = decodeSZSCafeAsm_(dst, src);
+    decodeSZSCafeAsm_(dst, src);
 #elif defined(SWITCH)
-        error = decodeSZSNxAsm64_(dst, src);
+    decodeSZSNxAsm64_(dst, src);
 #else
-        SEAD_ASSERT_MSG(false, "SZSDecompressor::decomp not implemented");
+    SEAD_ASSERT_MSG(false, "SZSDecompressor::decomp not implemented");
 #endif  // cafe
-    }
 
-    return error;
+    return decompSize;
 }
 
 }  // namespace sead
diff --git a/modules/src/thread/seadThread.cpp b/modules/src/thread/seadThread.cpp
index f7599b62..85dab3ea 100644
--- a/modules/src/thread/seadThread.cpp
+++ b/modules/src/thread/seadThread.cpp
@@ -79,57 +79,11 @@ s32 Thread::calcStackUsedSizePeak() const
 #endif
 }
 
-void Thread::checkStackOverFlow(const char* source_file, s32 source_line) const
-{
-    checkStackPointerOverFlow(source_file, source_line);
-    checkStackEndCorruption(source_file, source_line);
-}
-
-void Thread::checkStackEndCorruption(const char* source_file, s32 source_line) const
-{
-    if (ThreadMgr::instance()->getMainThread() == this)
-        return;
-
-    const uintptr_t start = getStackCheckStartAddress_();
-    if (!start)
-        return;
+void Thread::checkStackOverFlow(const char*, s32) const {}
 
-    SEAD_ASSERT_MSG(checkStackMagic(start),
-                    "sead::Thread Stack End Corruption! [%s:%p]\n"
-                    "  Source File: %s\n"
-                    "  Line Number: %d\n"
-                    "  Stack Size: %d",
-                    getName().cstr(), this,
-                    source_file ? source_file : SafeString::cEmptyString.cstr(), source_line,
-                    getStackSize());
-}
+void Thread::checkStackEndCorruption(const char*, s32) const {}
 
-void Thread::checkStackPointerOverFlow(const char* source_file, s32 source_line) const
-{
-    if (!ThreadMgr::instance() || ThreadMgr::instance()->getCurrentThread() != this)
-    {
-        SEAD_WARN("sead::Thread::checkStackPointerOverFlow cannot be called from other thread.");
-        return;
-    }
-
-    const uintptr_t ptr = ThreadUtil::GetCurrentStackPointer();
-    const uintptr_t start = getStackCheckStartAddress_();
-    if (start)
-    {
-        SEAD_ASSERT_MSG(start <= ptr,
-                        "sead::Thread Stack Pointer Overflow! [%s:%p]\n"
-                        "  Source File: %s\n"
-                        "  Line Number: %d\n"
-                        "  Stack Size: %d, Over Size: %ld",
-                        getName().cstr(), this,
-                        source_file ? source_file : SafeString::cEmptyString.cstr(), source_line,
-                        getStackSize(), start - ptr);
-    }
-    else
-    {
-        ThreadMgr::instance()->getCurrentThread();
-    }
-}
+void Thread::checkStackPointerOverFlow(const char*, s32) const {}
 
 void Thread::setStackOverflowExceptionEnable(bool)
 {
@@ -152,55 +106,9 @@ void Thread::run_()
     }
 }
 
-// NON_MATCHING: the first loop gets unrolled and the loop counter is not negated
-void Thread::initStackCheck_()
-{
-    void* const start = reinterpret_cast<void*>(getStackCheckStartAddress_());
-    void* const end = PtrUtil::addOffset(mStackTopForCheck, mStackSize);
-    u32* addr = static_cast<u32*>(start);
-
-    if (start >= end)
-        return;
-
-    const size_t len = uintptr_t(end) + (-uintptr_t(start) - 1);
-
-    for (u32 i = 0; i < ((len / 4 + 1) % 8); ++i)
-        *addr++ = cStackCanaryMagic;
-
-    if (len >= 0x1C)
-    {
-        do
-        {
-            for (s32 i = 0; i < 8; ++i)
-                *addr++ = cStackCanaryMagic;
-        } while (addr < end);
-    }
-}
-
-// NON_MATCHING: see Thread::initStackCheck_
-void Thread::initStackCheckWithCurrentStackPointer_()
-{
-    void* const start = reinterpret_cast<void*>(getStackCheckStartAddress_());
-    void* const end = reinterpret_cast<void*>(ThreadUtil::GetCurrentStackPointer());
-    u32* addr = static_cast<u32*>(start);
-
-    if (start >= end)
-        return;
+void Thread::initStackCheck_() {}
 
-    const size_t len = uintptr_t(end) + (-uintptr_t(start) - 1);
-
-    for (u32 i = 0; i < ((len / 4 + 1) % 8); ++i)
-        *addr++ = cStackCanaryMagic;
-
-    if (len >= 0x1C)
-    {
-        do
-        {
-            for (s32 i = 0; i < 8; ++i)
-                *addr++ = cStackCanaryMagic;
-        } while (addr < end);
-    }
-}
+void Thread::initStackCheckWithCurrentStackPointer_() {}
 
 SEAD_SINGLETON_DISPOSER_IMPL(ThreadMgr)
 
@@ -274,27 +182,9 @@ void ThreadMgr::quitAndWaitDoneMultipleThread(Thread** threads, s32 num, bool is
     waitDoneMultipleThread(threads, num);
 }
 
-void ThreadMgr::checkCurrentThreadStackOverFlow(const char* source_file, s32 source_line)
-{
-    if (!ThreadMgr::instance())
-        return;
-    if (Thread* thread = ThreadMgr::instance()->getCurrentThread())
-        thread->checkStackOverFlow(source_file, source_line);
-}
+void ThreadMgr::checkCurrentThreadStackOverFlow(const char*, s32) {}
 
-void ThreadMgr::checkCurrentThreadStackEndCorruption(const char* source_file, s32 source_line)
-{
-    if (!ThreadMgr::instance())
-        return;
-    if (Thread* thread = ThreadMgr::instance()->getCurrentThread())
-        thread->checkStackEndCorruption(source_file, source_line);
-}
+void ThreadMgr::checkCurrentThreadStackEndCorruption(const char*, s32) {}
 
-void ThreadMgr::checkCurrentThreadStackPointerOverFlow(const char* source_file, s32 source_line)
-{
-    if (!ThreadMgr::instance())
-        return;
-    if (Thread* thread = ThreadMgr::instance()->getCurrentThread())
-        thread->checkStackPointerOverFlow(source_file, source_line);
-}
+void ThreadMgr::checkCurrentThreadStackPointerOverFlow(const char*, s32) {}
 }  // namespace sead
diff --git a/modules/src/time/seadCalendarTime.cpp b/modules/src/time/seadCalendarTime.cpp
index 0b329de2..0c56ace3 100644
--- a/modules/src/time/seadCalendarTime.cpp
+++ b/modules/src/time/seadCalendarTime.cpp
@@ -43,18 +43,19 @@ void CalendarTime::Month::setValueOneOrigin(u32 m)
 
 s32 CalendarTime::Month::addSelf(u32 rhs)
 {
-    const s32 val = (s32(rhs) + mValue + -1) % 12;
-    mValue = val + 1;
+    const s32 value = s32(rhs) + mValue - 1;
+    const s32 year = value / 12;
+    mValue = value % 12 + 1;
     SEAD_ASSERT(1 <= mValue && mValue <= 12);
-    return val;
+    return year;
 }
 
 s32 CalendarTime::Month::subSelf(u32 rhs)
 {
-    const s32 val = (mValue - s32(rhs) % 12 + 12 - 1) % 12u;
-    mValue = val + 1;
+    const s32 year = (mValue - s32(rhs) - 13) / 12;
+    mValue = (mValue + 11 - rhs % 12) % 12 + 1;
     SEAD_ASSERT(1 <= mValue && mValue <= 12);
-    return val;
+    return year;
 }
 
 s32 CalendarTime::Month::sub(CalendarTime::Month rhs) const
@@ -142,6 +143,7 @@ CalendarTime::Time::Time(const CalendarTime::Hour& h, const CalendarTime::Minute
 CalendarTime::CalendarTime(const CalendarTime::Date& date, const CalendarTime::Time& time)
     : mDate(date), mTime(time)
 {
+    mDate.calcWeek();
 }
 
 CalendarTime::CalendarTime(const CalendarTime::Year& y, const CalendarTime::Month& m,
diff --git a/modules/src/time/seadDateUtil.cpp b/modules/src/time/seadDateUtil.cpp
index a02fd22f..a8914ce9 100644
--- a/modules/src/time/seadDateUtil.cpp
+++ b/modules/src/time/seadDateUtil.cpp
@@ -6,16 +6,23 @@ namespace sead
 {
 namespace DateUtil
 {
+static inline bool orBool_(bool lhs, bool rhs)
+{
+    return lhs | rhs;
+}
+
 bool isLeapYear(u32 year)
 {
-#ifdef MATCHING_HACK_NX_CLANG
-    bool div100, div4;
-    return (div100 = year % 100 == 0, div4 = year % 4 == 0, !div100 & div4) | (year % 400 == 0);
-#else
-    return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
-#endif
+    const auto remainder_100 = year % 100;
+    const auto remainder_4 = year & 3;
+    const bool divisible_by_4 = remainder_4 == 0;
+    const bool not_divisible_by_100 = remainder_100 != 0;
+    const bool leap_non_century = not_divisible_by_100 & divisible_by_4;
+    const bool divisible_by_400 = year % 400 == 0;
+    return orBool_(divisible_by_400, leap_non_century);
 }
 
+
 CalendarTime::Week calcWeekDay(const CalendarTime::Year& year, const CalendarTime::Month& month,
                                const CalendarTime::Day& day)
 {
@@ -87,8 +94,8 @@ static bool parseW3CDTFStringImpl(u32* year, u32* month, u32* day, u32* hour, u3
                                   const SafeString& string)
 {
     s32 len = string.calcLength();
-    bool ok = true;
     SafeString substr = string;
+    bool ok = true;
     char separator;
 
     if (parseW3CDTFSubString(&ok, year, &substr, &len, &separator, 4, "-", true, 0, 0xFFFFFFFF))
@@ -109,8 +116,13 @@ static bool parseW3CDTFStringImpl(u32* year, u32* month, u32* day, u32* hour, u3
 
         if (separator == '.')
         {
-            if (len == 0)
-                return false;
+            bool has_fraction = len != 0;
+            if (!has_fraction)
+            {
+                *tz_hour = 0;
+                *tz_minute = 0;
+                return has_fraction;
+            }
 
             auto it = substr.tokenBegin("+-Z");
             ++it;

From 71625beff7d9e0b544cb1ac998cb770d9bf0efb4 Mon Sep 17 00:00:00 2001
From: GRAnimated <devin@nhscan.com>
Date: Wed, 15 Jul 2026 17:08:49 -0400
Subject: [PATCH 2/5] human review

---
 include/container/seadTreeMap.h               |  1 -
 include/mc/seadJobQueue.h                     |  5 +--
 modules/src/basis/seadNew.cpp                 | 12 ++++++-
 modules/src/controller/seadControllerMgr.cpp  |  2 +-
 .../nin/seadNinFileDeviceBaseNin.cpp          | 17 +---------
 modules/src/filedevice/seadFileDeviceMgr.cpp  | 16 ++++++++++
 modules/src/filedevice/seadPath.cpp           |  7 ++---
 modules/src/hostio/seadHostIOCurve.cpp        |  4 +--
 modules/src/mc/seadCoreInfo.cpp               | 14 ++++++++-
 modules/src/mc/seadJobQueue.cpp               | 31 +++++++++----------
 modules/src/prim/seadSafeString.cpp           |  2 +-
 modules/src/prim/seadStringBuilder.cpp        |  2 +-
 modules/src/resource/seadSZSDecompressor.cpp  |  2 +-
 13 files changed, 66 insertions(+), 49 deletions(-)

diff --git a/include/container/seadTreeMap.h b/include/container/seadTreeMap.h
index 7db461df..144ac9eb 100644
--- a/include/container/seadTreeMap.h
+++ b/include/container/seadTreeMap.h
@@ -452,7 +452,6 @@ inline TreeMapNode<Key>* TreeMapImpl<Key>::findMin(Node* node)
     return node;
 }
 
-// The compiler barrier preserves the original recursive-result store schedule.
 template <typename Key>
 inline TreeMapNode<Key>* TreeMapImpl<Key>::eraseMin(Node* node)
 {
diff --git a/include/mc/seadJobQueue.h b/include/mc/seadJobQueue.h
index f23e2320..c179fae7 100644
--- a/include/mc/seadJobQueue.h
+++ b/include/mc/seadJobQueue.h
@@ -112,7 +112,7 @@ class JobQueue : public hostio::Node, public INamable
     CoreIdMask mMask;
     Event mFinishEvent{true};
     SafeArray<u32, 3> mGranularity;
-    SafeArray<volatile u32, 3> mCoreEnabled;
+    SafeArray<volatile u32, 3> mCoreEnabled; // volatile required for setCoreMaskAndWaitType
     Atomic<u32> mNumDoneJobs = 0;
 
     Atomic<Status> mStatus = Status::_0;
@@ -153,7 +153,4 @@ class FixedSizeJQ : public JobQueue
     u32 mNumProcessedJobs;
     bool _230;
 };
-static_assert(sizeof(PerfJobQueue) == 0x30);
-static_assert(sizeof(JobQueue) == 0xB0);
-static_assert(sizeof(FixedSizeJQ) == 0xD0);
 }  // namespace sead
diff --git a/modules/src/basis/seadNew.cpp b/modules/src/basis/seadNew.cpp
index a983ed0d..ec40f2ad 100644
--- a/modules/src/basis/seadNew.cpp
+++ b/modules/src/basis/seadNew.cpp
@@ -26,7 +26,17 @@ void* NewImpl(Heap* heap, size_t size, s32 alignment, bool abortOnFailure)
         }
     }
 
-    return heap->tryAlloc(size, alignment);
+    void* result = heap->tryAlloc(size, alignment);
+    #ifdef SEAD_DEBUG
+    if (!result && abortOnFailure)
+    {
+        SEAD_ASSERT_MSG(
+            false, "alloc failed. size: %zu, allocatable size: %zu, alignment: %d, heap: %s", size,
+            heap->getMaxAllocatableSize(alignment), alignment, heap->getName().cstr());
+        return nullptr;
+    }
+    #endif
+    return result;
 }
 
 void DeleteImpl(void* ptr)
diff --git a/modules/src/controller/seadControllerMgr.cpp b/modules/src/controller/seadControllerMgr.cpp
index c7df3150..2affa374 100644
--- a/modules/src/controller/seadControllerMgr.cpp
+++ b/modules/src/controller/seadControllerMgr.cpp
@@ -66,7 +66,7 @@ void ControllerMgr::initializeDefault(Heap* heap)
 void ControllerMgr::finalizeDefault()
 {
 #ifdef NNSDK
-    ControlDevice* device = getControlDevice(ControllerDefine::DeviceId(13));
+    ControlDevice* device = getControlDevice(ControllerDefine::DeviceId::cDevice_NinJoyNpad);
     if (device)
     {
         mDevices.erase(device);
diff --git a/modules/src/filedevice/nin/seadNinFileDeviceBaseNin.cpp b/modules/src/filedevice/nin/seadNinFileDeviceBaseNin.cpp
index eb1c8641..235faa01 100644
--- a/modules/src/filedevice/nin/seadNinFileDeviceBaseNin.cpp
+++ b/modules/src/filedevice/nin/seadNinFileDeviceBaseNin.cpp
@@ -24,9 +24,7 @@ NinFileDeviceBase::NinFileDeviceBase(const SafeString& name, const SafeString& m
 {
 }
 
-// NON_MATCHING: every instruction matches except retail uses CBZ w8 for the is-file test while LLVM
-// selects TBZ w8,#0. Signedness and source-branch inversion emitted identical code and were reverted;
-// next hypothesis is the original integer/range-producing helper that prevents bit-test folding.
+// NON_MATCHING: CBZ vs TBZ
 FileDevice* NinFileDeviceBase::doOpen_(FileHandle* handle, const SafeString& path,
                                        FileDevice::FileOpenFlag flag)
 {
@@ -58,10 +56,6 @@ FileDevice* NinFileDeviceBase::doOpen_(FileHandle* handle, const SafeString& pat
         }
         else if (!nn::fs::ResultPathNotFound().Includes(result))
         {
-            SEAD_WARN("nn::fs::GetEntryType failed. module = %d desc = %d inner_value = 0x%08x "
-                      "path = %s",
-                      result.GetModule(), result.GetDescription(), result.GetInnerValueForDebug(),
-                      fs_path.cstr());
             mLastError = result;
             return nullptr;
         }
@@ -77,10 +71,6 @@ FileDevice* NinFileDeviceBase::doOpen_(FileHandle* handle, const SafeString& pat
             const auto create_result = nn::fs::CreateFile(fs_path.cstr(), 0);
             if (create_result.IsFailure())
             {
-                SEAD_WARN("nn::fs::CreateFile failed. module = %d desc = %d inner_value = 0x%08x "
-                          "path = %s",
-                          create_result.GetModule(), create_result.GetDescription(),
-                          create_result.GetInnerValueForDebug(), fs_path.cstr());
                 mLastError = create_result;
                 return nullptr;
             }
@@ -96,11 +86,6 @@ FileDevice* NinFileDeviceBase::doOpen_(FileHandle* handle, const SafeString& pat
                 const auto create_result = nn::fs::CreateFile(fs_path.cstr(), 0);
                 if (create_result.IsFailure())
                 {
-                    SEAD_WARN(
-                        "nn::fs::CreateFile failed. module = %d desc = %d inner_value = 0x%08x "
-                        "path = %s",
-                        create_result.GetModule(), create_result.GetDescription(),
-                        create_result.GetInnerValueForDebug(), fs_path.cstr());
                     mLastError = create_result;
                     return nullptr;
                 }
diff --git a/modules/src/filedevice/seadFileDeviceMgr.cpp b/modules/src/filedevice/seadFileDeviceMgr.cpp
index 443775d5..7355f8ee 100644
--- a/modules/src/filedevice/seadFileDeviceMgr.cpp
+++ b/modules/src/filedevice/seadFileDeviceMgr.cpp
@@ -339,10 +339,26 @@ bool FileDeviceMgr::trySave(FileDevice::SaveArg& arg)
 }
 
 #ifdef NNSDK
+#ifdef SEAD_DEBUG
+void FileDeviceMgr::mountSaveDataForDebug(Heap*)
+{
+    const auto result = nn::fs::MountSaveDataForDebug("save");
+    SEAD_ASSERT_MSG(
+        result.IsSuccess(),
+        "nn::fs::MountSaveDataForDebug() failed. module = %d desc = %d innervalue = 0x%08x",
+        result.GetModule(), result.GetDescription(), result.GetInnerValueForDebug());
+}
+
+void FileDeviceMgr::unmountSaveDataForDebug()
+{
+    nn::fs::Unmount("save");
+}
+#else
 void FileDeviceMgr::mountSaveDataForDebug(Heap*) {}
 
 void FileDeviceMgr::unmountSaveDataForDebug() {}
 #endif
+#endif
 
 #ifdef cafe
 void FileDeviceMgr::stateChangeCallback_(FSClient* client, FSVolumeState state, void* context)
diff --git a/modules/src/filedevice/seadPath.cpp b/modules/src/filedevice/seadPath.cpp
index d6f92162..b1e5316f 100644
--- a/modules/src/filedevice/seadPath.cpp
+++ b/modules/src/filedevice/seadPath.cpp
@@ -49,16 +49,15 @@ char getLastChar(const SafeString& str)
 }
 }  // namespace
 
-// NON_MATCHING: Exact size and repeated getPart guards are restored with an unsigned index.
-// Search-loop register lifetimes and final slice formation still differ.
+// NON_MATCHING: search-loop register lifetimes and final slice formation differ
 bool Path::getExt(BufferedSafeString* ext, const SafeString& path)
 {
     SEAD_ASSERT_MSG(ext, "destination buffer is null");
 
     ext->trim(0);
 
-    const u32 dot_index = rfindCharIndex(path, '.');
-    if (dot_index == u32(-1))
+    u32 dot_index = rfindCharIndex(path, '.');
+    if (dot_index == 0xFFFFFFFF)
         return false;
 
     if (path.getPart(dot_index).include('/') || path.getPart(dot_index).include('\\'))
diff --git a/modules/src/hostio/seadHostIOCurve.cpp b/modules/src/hostio/seadHostIOCurve.cpp
index 084f41eb..44ff003f 100644
--- a/modules/src/hostio/seadHostIOCurve.cpp
+++ b/modules/src/hostio/seadHostIOCurve.cpp
@@ -127,7 +127,7 @@ T curveSinPow2_(f32 t_, const CurveDataInfo*, const T* f)
     return y * y * f[1];
 }
 
-// NON_MATCHING: Exact target size and endpoint pre-indexed load now match; only the compare-side address differs (SUB+indexed LDR instead of ADD pointer+LDUR). Next hypothesis: recover the original count/index wrapper that keeps the doubled index while materializing the compare pointer.
+// NON_MATCHING: something is causing a difference between signed and unsigned
 template <typename T>
 T curveLinear2D_(f32 t_, const CurveDataInfo* info, const T* f)
 {
@@ -207,7 +207,7 @@ T curveHermit2D_(f32 t_, const CurveDataInfo* info, const T* f)
     return 0;
 }
 
-// NON_MATCHING: Exact-size endpoint form recovered; compare-side address still uses a subtracted index rather than the retail pointer-plus-LDUR shape. Next hypothesis: recover the original count/index wrapper shared with curveLinear2D_.
+// NON_MATCHING: signed vs. unsigned, can probably be solved in the same way as curveLinear2D_
 template <typename T>
 T curveStep2D_(f32 t_, const CurveDataInfo* info, const T* f)
 {
diff --git a/modules/src/mc/seadCoreInfo.cpp b/modules/src/mc/seadCoreInfo.cpp
index 59a7df9f..7f02c8df 100644
--- a/modules/src/mc/seadCoreInfo.cpp
+++ b/modules/src/mc/seadCoreInfo.cpp
@@ -55,7 +55,19 @@ void CoreInfo::configure()
 #endif
 }
 
-void CoreInfo::dump() {}
+void CoreInfo::dump()
+{
+    #ifdef SEAD_DEBUG
+    system::Print("* num cores %d\n", sNumCores);
+    for (u32 i = 0; i < sNumCores; ++i)
+    {
+        system::Print("  [%d] : %s : PlatformCoreId=%d\n", i, i == 0 ? "Main" : "Sub ",
+                      sPlatformCoreId[i]);
+    }
+    system::Print("all mask : %x\n", u32(getMaskAll()));
+    system::Print("all sub mask : %x\n", u32(getMaskSubAll()));
+    #endif
+}
 
 u32 CoreInfo::getPlatformMask(CoreId id)
 {
diff --git a/modules/src/mc/seadJobQueue.cpp b/modules/src/mc/seadJobQueue.cpp
index d8765743..d6c8325d 100644
--- a/modules/src/mc/seadJobQueue.cpp
+++ b/modules/src/mc/seadJobQueue.cpp
@@ -8,7 +8,7 @@
 
 namespace sead
 {
-// NON_MATCHING: Retail keeps the original this base and emits three positive-offset flag stores; Clang rebases this through a writeback store and uses negative offsets. Layout and initialized values match.
+// NON_MATCHING
 JobQueue::JobQueue()
 {
     mCoreEnabled[0] = 0;
@@ -94,7 +94,7 @@ void JobQueue::wait_AT_WORKER()
     }
 }
 
-// NON_MATCHING: Retail preserves separate B.LO and B.NE enum tests sharing one compare; Clang folds the equivalent switch cases into a single range branch.
+// NON_MATCHING: b.hi vs. b.lo and b.ne
 void JobQueue::wait()
 {
     switch (mSyncType)
@@ -113,7 +113,7 @@ void JobQueue::wait()
         mFinishEvent.wait();
 }
 
-// NON_MATCHING: Instruction count and behavior match, but Clang assigns the queue/name live ranges to x19/x20 opposite retail. Next hypothesis is the original SafeString temporary lifetime/order.
+// NON_MATCHING: the original creates a bunch of empty strings somehow
 void PerfJobQueue::initialize(const char* name, Heap* heap)
 {
     mBars.allocBufferAssert(CoreInfo::getNumCores(), heap);
@@ -146,42 +146,42 @@ void PerfJobQueue::reset()
 
 void PerfJobQueue::measureBeginDeque()
 {
+    // placing CoreId in a union prevents the sead enum initialization 
     union UninitializedCoreId
     {
-        CoreId value;
         UninitializedCoreId() {}
-        ~UninitializedCoreId() {}
+        CoreId value;
     } core;
 
-    static_cast<void>(mBars[CoreInfo::getCurrentCoreId()]);
+    mBars[CoreInfo::getCurrentCoreId()];
     core.value = CoreInfo::getCurrentCoreId();
-    static_cast<void>(mInts[core.value]);
+    mInts[core.value];
 }
 
 void PerfJobQueue::measureEndDeque()
 {
-    static_cast<void>(mBars[CoreInfo::getCurrentCoreId()]);
+    mBars[CoreInfo::getCurrentCoreId()];
 }
 
 void PerfJobQueue::measureBeginRun()
 {
+    // placing CoreId in a union prevents the sead enum initialization 
     union UninitializedCoreId
     {
-        CoreId value;
         UninitializedCoreId() {}
-        ~UninitializedCoreId() {}
+        CoreId value;
     } core;
 
-    static_cast<void>(mBars[CoreInfo::getCurrentCoreId()]);
+    mBars[CoreInfo::getCurrentCoreId()];
     core.value = CoreInfo::getCurrentCoreId();
     auto& idx = mInts[core.value];
-    static_cast<void>(getBarColor(idx));
+    getBarColor(idx);
     idx = (idx + 1) % 9;
 }
 
 void PerfJobQueue::measureEndRun()
 {
-    static_cast<void>(mBars[CoreInfo::getCurrentCoreId()]);
+    mBars[CoreInfo::getCurrentCoreId()];
 }
 
 const Color4f& PerfJobQueue::getBarColor(u32 idx) const
@@ -204,7 +204,7 @@ void PerfJobQueue::attachProcessMeter() {}
 
 void PerfJobQueue::detachProcessMeter() {}
 
-// NON_MATCHING: Base JobQueue values and derived fields are correct; the remaining diff inherits the base-constructor this-rebasing/addressing-mode choice.
+// NON_MATCHING:
 FixedSizeJQ::FixedSizeJQ()
 {
     mStatus = Status::_0;
@@ -214,9 +214,8 @@ FixedSizeJQ::FixedSizeJQ()
 
 void FixedSizeJQ::begin() {}
 
-// TODO: Splatoon 2 and BotW sead have a different implementation which checks _230 and the current
+// NON_MATCHING: TODO: Splatoon 2 and BotW sead have a different implementation which checks _230 and the current
 // core number...
-// NON_MATCHING: Retail materializes ret/end/begin before the size tests and assigns different whole-function registers; equivalent nested/source-order rewrites are flattened by Clang. Next hypothesis is the exact original branch nesting around size and mNumJobs.
 bool FixedSizeJQ::run(u32 size, u32* finished_jobs, Worker* worker)
 {
     *finished_jobs = 0;
diff --git a/modules/src/prim/seadSafeString.cpp b/modules/src/prim/seadSafeString.cpp
index 3ed09c31..9c52a50a 100644
--- a/modules/src/prim/seadSafeString.cpp
+++ b/modules/src/prim/seadSafeString.cpp
@@ -169,7 +169,7 @@ s32 BufferedSafeStringBase<char16>::appendWithFormat(const char16* format, ...)
     return ret;
 }
 
-// NON_MATCHING: Retail nested forward/backward overlap scans and byte-scaled memory operations are reconstructed. char16 is exact-size (1312 bytes); char is 16 bytes short. Remaining differences are stack/register lifetimes, especially the backward scan spill set and char-only source-pointer lifetime.
+// NON_MATCHING: stack
 template <typename T>
 s32 replaceStringImpl_(T* dst, s32* length, s32 dst_size, const T* src, s32 src_size,
                        const SafeStringBase<T>& old_str, const SafeStringBase<T>& new_str,
diff --git a/modules/src/prim/seadStringBuilder.cpp b/modules/src/prim/seadStringBuilder.cpp
index c050cb04..ecc88bc8 100644
--- a/modules/src/prim/seadStringBuilder.cpp
+++ b/modules/src/prim/seadStringBuilder.cpp
@@ -547,7 +547,7 @@ s32 StringBuilderBase<T>::rstrip(const T* characters)
 template s32 StringBuilder::rstrip(const char* characters);
 template s32 WStringBuilder::rstrip(const char16* characters);
 
-// NON_MATCHING: Retail schedules the packed-length ADD before the speculative index SUB; Clang emits the same independent recurrence updates in reverse order. Next hypothesis is the original loop form that keeps the packed length as the primary induction variable.
+// NON_MATCHING: equivalent, two instruction reorders
 template <typename T>
 s32 StringBuilderBase<T>::rstripUnprintableAsciiChars()
 {
diff --git a/modules/src/resource/seadSZSDecompressor.cpp b/modules/src/resource/seadSZSDecompressor.cpp
index b495f1ed..18120735 100644
--- a/modules/src/resource/seadSZSDecompressor.cpp
+++ b/modules/src/resource/seadSZSDecompressor.cpp
@@ -333,7 +333,7 @@ u32 SZSDecompressor::getDecompSize(const void* src)
     return Endian::toHostU32(Endian::cBig, BitUtil::bitCastPtr<u32>(src, 4));
 }
 
-// NON_MATCHING: The retail loop carries both the raw decremented header count and a byte-masked copy; current codegen adds two redundant masks.
+// NON_MATCHING
 s32 SZSDecompressor::readHeader_(DecompContext* context, const u8* src, u32 srcSize)
 {
     s32 len = 0;

From b26952ab4c644672f6bb50e16991b843504fbb1d Mon Sep 17 00:00:00 2001
From: GRAnimated <devin@nhscan.com>
Date: Wed, 15 Jul 2026 23:41:44 -0400
Subject: [PATCH 3/5] Fix BOTW regressions

---
 include/filedevice/seadFileDeviceMgr.h      |   5 +
 include/mc/seadJobQueue.h                   |   9 ++
 modules/src/gfx/nvn/seadDebugFontMgrNvn.cpp |   6 +
 modules/src/hostio/seadHostIOCurve.cpp      |  16 +++
 modules/src/mc/seadJobQueue.cpp             | 111 ++++++++++++++++
 modules/src/thread/seadThread.cpp           | 134 ++++++++++++++++++++
 6 files changed, 281 insertions(+)

diff --git a/include/filedevice/seadFileDeviceMgr.h b/include/filedevice/seadFileDeviceMgr.h
index f6ca7b41..06f15a23 100644
--- a/include/filedevice/seadFileDeviceMgr.h
+++ b/include/filedevice/seadFileDeviceMgr.h
@@ -11,6 +11,7 @@
 #include <filedevice/seadMainFileDevice.h>
 #include <heap/seadDisposer.h>
 #include <prim/seadSafeString.h>
+#include <seadVersion.h>
 
 namespace sead
 {
@@ -72,7 +73,11 @@ class FileDeviceMgr
 #elif defined(NNSDK)
     u8* mRomCache = nullptr;
     bool mMountedHost = false;
+#if SEAD_VERSION == SEAD_VERSION_SMO
     bool mMountedSd;
+#else
+    bool mMountedSd = false;
+#endif
 #endif
 };
 
diff --git a/include/mc/seadJobQueue.h b/include/mc/seadJobQueue.h
index c179fae7..a75f3939 100644
--- a/include/mc/seadJobQueue.h
+++ b/include/mc/seadJobQueue.h
@@ -9,6 +9,7 @@
 #include "mc/seadJob.h"
 #include "prim/seadEnum.h"
 #include "prim/seadNamable.h"
+#include "seadVersion.h"
 #include "thread/seadAtomic.h"
 #include "thread/seadEvent.h"
 
@@ -36,9 +37,15 @@ class PerfJobQueue
     void detachProcessMeter();
 
 private:
+#ifdef SEAD_DEBUG
+    Buffer<MultiProcessMeterBar<512>> mBars;
+    Buffer<u32> mInts;
+    MultiProcessMeterBar<1> mProcessMeterBar;
+#else
     Buffer<SafeString> mBars;
     Buffer<u32> mInts;
     SafeString mProcessMeterBar;
+#endif
 };
 
 class JobQueueLock
@@ -118,7 +125,9 @@ class JobQueue : public hostio::Node, public INamable
     Atomic<Status> mStatus = Status::_0;
     const char* mDescription = "NoName";
 
+#if defined(SEAD_DEBUG) || SEAD_VERSION == SEAD_VERSION_SMO
     PerfJobQueue mPerf;
+#endif
 };
 
 class FixedSizeJQ : public JobQueue
diff --git a/modules/src/gfx/nvn/seadDebugFontMgrNvn.cpp b/modules/src/gfx/nvn/seadDebugFontMgrNvn.cpp
index 65333dad..15aa860c 100644
--- a/modules/src/gfx/nvn/seadDebugFontMgrNvn.cpp
+++ b/modules/src/gfx/nvn/seadDebugFontMgrNvn.cpp
@@ -9,11 +9,15 @@
 
 namespace sead
 {
+// BOTW
+// NON_MATCHING
 SEAD_SINGLETON_DISPOSER_IMPL(DebugFontMgrJis1Nvn)
 DebugFontMgrJis1Nvn::~DebugFontMgrJis1Nvn() {}
 
 DebugFontMgrJis1Nvn::DebugFontMgrJis1Nvn() = default;
 
+// BOTW
+// NON_MATCHING
 void DebugFontMgrJis1Nvn::initialize(Heap* heap, const char* shader_path, const char* font_path,
                                      const char* table_path, u32 unk)
 {
@@ -37,6 +41,8 @@ void DebugFontMgrJis1Nvn::initialize(Heap* heap, const char* shader_path, const
                          unk);
 }
 
+// BOTW
+// NON_MATCHING: Stack
 void DebugFontMgrJis1Nvn::initializeFromBinary(Heap* heap, void* shader_binary, u64 shader_size,
                                                void* font_binary, u64 font_size,
                                                const void* table_binary, u32 unk3)
diff --git a/modules/src/hostio/seadHostIOCurve.cpp b/modules/src/hostio/seadHostIOCurve.cpp
index 44ff003f..2a3eea4d 100644
--- a/modules/src/hostio/seadHostIOCurve.cpp
+++ b/modules/src/hostio/seadHostIOCurve.cpp
@@ -2,6 +2,7 @@
 #include <cmath>
 #include "math/seadMathCalcCommon.h"
 #include "math/seadMathNumbers.h"
+#include "seadVersion.h"
 
 namespace sead::hostio
 {
@@ -207,6 +208,7 @@ T curveHermit2D_(f32 t_, const CurveDataInfo* info, const T* f)
     return 0;
 }
 
+// SMO
 // NON_MATCHING: signed vs. unsigned, can probably be solved in the same way as curveLinear2D_
 template <typename T>
 T curveStep2D_(f32 t_, const CurveDataInfo* info, const T* f)
@@ -215,6 +217,7 @@ T curveStep2D_(f32 t_, const CurveDataInfo* info, const T* f)
     if (t <= f[0])
         return f[1];
 
+#if SEAD_VERSION == SEAD_VERSION_SMO
     const s32 n = info->numUse / 2;
     const u32 end = 2 * n;
     if (t >= f[end - 2])
@@ -229,6 +232,17 @@ T curveStep2D_(f32 t_, const CurveDataInfo* info, const T* f)
         if (t < f[j + 2])
             return f[j + 1];
     }
+#else
+    const s8 n = info->numUse / 2;
+    if (t >= f[2 * (n - 1)])
+        return f[2 * (n - 1) + 1];
+
+    for (s32 i = 0; i < n; ++i)
+    {
+        if (t < f[2 * i + 2])
+            return f[2 * i + 1];
+    }
+#endif
     return 0;
 }
 
@@ -287,6 +301,8 @@ Vector2<T> curveHermit2DVec2_(f32 t, const CurveDataInfo* info, const T* f)
     return {t, curveHermit2D_(t, info, f)};
 }
 
+// SMO
+// NON_MATCHING: curveStep2D_ is inlined here
 template <typename T>
 Vector2<T> curveStep2DVec2_(f32 t, const CurveDataInfo* info, const T* f)
 {
diff --git a/modules/src/mc/seadJobQueue.cpp b/modules/src/mc/seadJobQueue.cpp
index d6c8325d..2e48cdec 100644
--- a/modules/src/mc/seadJobQueue.cpp
+++ b/modules/src/mc/seadJobQueue.cpp
@@ -113,6 +113,101 @@ void JobQueue::wait()
         mFinishEvent.wait();
 }
 
+#ifdef SEAD_DEBUG
+// NON_MATCHING: stack
+void PerfJobQueue::initialize(const char* name, Heap* heap)
+{
+    mBars.allocBufferAssert(CoreInfo::getNumCores(), heap);
+    mInts.allocBufferAssert(CoreInfo::getNumCores(), heap);
+
+    for (s32 i = 0; i < mInts.size(); ++i)
+        mInts[CoreId(i)] = 0;
+
+    for (s32 i = 0; i < mBars.size(); ++i)
+        mBars[i].setName(CoreId(i).text());
+
+    mProcessMeterBar.setColor({1, 1, 0, 1});
+    mProcessMeterBar.setName(name);
+}
+
+void PerfJobQueue::finalize()
+{
+    mInts.freeBuffer();
+    mBars.freeBuffer();
+}
+
+void PerfJobQueue::reset()
+{
+    for (s32 i = 0; i < mInts.size(); ++i)
+        mInts[CoreId(i)] = 0;
+}
+
+// NON_MATCHING: stack
+void PerfJobQueue::measureBeginDeque()
+{
+    auto& bar = mBars[CoreInfo::getCurrentCoreId()];
+    static_cast<void>(mInts[CoreInfo::getCurrentCoreId()]);
+    bar.measureBegin(Color4f::cWhite);
+}
+
+void PerfJobQueue::measureEndDeque()
+{
+    mBars[CoreInfo::getCurrentCoreId()].measureEnd();
+}
+
+void PerfJobQueue::measureBeginRun()
+{
+    auto& bar = mBars[CoreInfo::getCurrentCoreId()];
+    auto& idx = mInts[CoreInfo::getCurrentCoreId()];
+    bar.measureBegin(getBarColor(idx));
+    idx = (idx + 1) % 9;
+}
+
+void PerfJobQueue::measureEndRun()
+{
+    mBars[CoreInfo::getCurrentCoreId()].measureEnd();
+}
+
+// NON_MATCHING: loading sColors...
+const Color4f& PerfJobQueue::getBarColor(u32 idx) const
+{
+    static const SafeArray<Color4f, 9> sColors = {{
+        {0.2078431397676468, 0.8313725590705872, 0.6274510025978088, 1.0},
+        {0.0, 0.6666666865348816, 0.4470588266849518, 1.0},
+        {0.125490203499794, 0.49803921580314636, 0.3764705955982208, 1.0},
+        {0.7490196228027344, 0.5254902243614197, 0.1882352977991104, 1.0},
+        {1.0, 0.6000000238418579, 0.0, 1.0},
+        {1.0, 0.6980392336845398, 0.250980406999588, 1.0},
+        {0.6901960968971252, 0.1725490242242813, 0.29411765933036804, 1.0},
+        {0.0, 0.9176470637321472, 0.21568627655506134, 1.0},
+        {0.9607843160629272, 0.239215686917305, 0.40784314274787903, 1.0},
+    }};
+    return sColors.mBuffer[idx];
+}
+
+void PerfJobQueue::attachProcessMeter()
+{
+    if (!ProcessMeter::instance())
+        return;
+
+    for (s32 i = 0; i < mBars.size(); ++i)
+        ProcessMeter::instance()->attachProcessMeterBar(&mBars[i]);
+
+    ProcessMeter::instance()->attachProcessMeterBar(&mProcessMeterBar);
+}
+
+void PerfJobQueue::detachProcessMeter()
+{
+    if (!ProcessMeter::instance())
+        return;
+
+    for (s32 i = 0; i < mBars.size(); ++i)
+        ProcessMeter::instance()->detachProcessMeterBar(&mBars[i]);
+
+    ProcessMeter::instance()->detachProcessMeterBar(&mProcessMeterBar);
+}
+
+#else
 // NON_MATCHING: the original creates a bunch of empty strings somehow
 void PerfJobQueue::initialize(const char* name, Heap* heap)
 {
@@ -204,6 +299,8 @@ void PerfJobQueue::attachProcessMeter() {}
 
 void PerfJobQueue::detachProcessMeter() {}
 
+#endif
+
 // NON_MATCHING:
 FixedSizeJQ::FixedSizeJQ()
 {
@@ -220,7 +317,9 @@ bool FixedSizeJQ::run(u32 size, u32* finished_jobs, Worker* worker)
 {
     *finished_jobs = 0;
 
+#if defined(SEAD_DEBUG) || SEAD_VERSION == SEAD_VERSION_SMO
     mPerf.measureBeginDeque();
+#endif
     u32 num_finished = 0;
     bool ret = true;
     s32 begin = 0;
@@ -244,9 +343,11 @@ bool FixedSizeJQ::run(u32 size, u32* finished_jobs, Worker* worker)
         end = num_finished + begin - 1;
         ret = num_finished + begin >= num_jobs;
     }
+#if defined(SEAD_DEBUG) || SEAD_VERSION == SEAD_VERSION_SMO
     mPerf.measureEndDeque();
 
     mPerf.measureBeginRun();
+#endif
     if (worker)
         worker->setState(Worker::State::cRunning_Run);
 
@@ -255,7 +356,9 @@ bool FixedSizeJQ::run(u32 size, u32* finished_jobs, Worker* worker)
 
     if (worker)
         worker->setState(Worker::State::cRunning_AfterRun);
+#if defined(SEAD_DEBUG) || SEAD_VERSION == SEAD_VERSION_SMO
     mPerf.measureEndRun();
+#endif
 
     if (ret)
     {
@@ -274,7 +377,9 @@ bool FixedSizeJQ::run(u32 size, u32* finished_jobs, Worker* worker)
 
 void FixedSizeJQ::initialize(u32 size, Heap* heap)
 {
+#if defined(SEAD_DEBUG) || SEAD_VERSION == SEAD_VERSION_SMO
     mPerf.initialize(getName().cstr(), heap);
+#endif
 
     ScopedLock<JobQueueLock> lock(&mLock);
     mJobs.allocBufferAssert(size, heap);
@@ -285,7 +390,9 @@ void FixedSizeJQ::initialize(u32 size, Heap* heap)
 
 void FixedSizeJQ::finalize()
 {
+#if defined(SEAD_DEBUG) || SEAD_VERSION == SEAD_VERSION_SMO
     mPerf.finalize();
+#endif
     mJobs.freeBuffer();
 }
 
@@ -337,7 +444,9 @@ u32 FixedSizeJQ::deque(Job** jobs, u32 count)
 
 bool FixedSizeJQ::rewind()
 {
+#if defined(SEAD_DEBUG) || SEAD_VERSION == SEAD_VERSION_SMO
     mPerf.reset();
+#endif
     mNumProcessedJobs = 0;
     return true;
 }
@@ -345,7 +454,9 @@ bool FixedSizeJQ::rewind()
 void FixedSizeJQ::clear()
 {
     mStatus = Status::_5;
+#if defined(SEAD_DEBUG) || SEAD_VERSION == SEAD_VERSION_SMO
     mPerf.reset();
+#endif
     mNumJobs = 0;
     mNumProcessedJobs = 0;
     mSyncType = SyncType::cNoSync;
diff --git a/modules/src/thread/seadThread.cpp b/modules/src/thread/seadThread.cpp
index 85dab3ea..9fdeb703 100644
--- a/modules/src/thread/seadThread.cpp
+++ b/modules/src/thread/seadThread.cpp
@@ -62,12 +62,14 @@ void Thread::quitAndWaitDoneSingleThread(bool is_jam)
     waitDone();
 }
 
+#ifdef SEAD_DEBUG
 constexpr u32 cStackCanaryMagic = 0x5EAD5CEC;
 
 static bool checkStackMagic(uintptr_t addr)
 {
     return BitUtil::bitCastPtr<u32>(reinterpret_cast<const void*>(addr)) == cStackCanaryMagic;
 }
+#endif
 
 s32 Thread::calcStackUsedSizePeak() const
 {
@@ -79,11 +81,65 @@ s32 Thread::calcStackUsedSizePeak() const
 #endif
 }
 
+#ifdef SEAD_DEBUG
+void Thread::checkStackOverFlow(const char* source_file, s32 source_line) const
+{
+    checkStackPointerOverFlow(source_file, source_line);
+    checkStackEndCorruption(source_file, source_line);
+}
+
+void Thread::checkStackEndCorruption(const char* source_file, s32 source_line) const
+{
+    if (ThreadMgr::instance()->getMainThread() == this)
+        return;
+
+    const uintptr_t start = getStackCheckStartAddress_();
+    if (!start)
+        return;
+
+    SEAD_ASSERT_MSG(checkStackMagic(start),
+                    "sead::Thread Stack End Corruption! [%s:%p]\n"
+                    "  Source File: %s\n"
+                    "  Line Number: %d\n"
+                    "  Stack Size: %d",
+                    getName().cstr(), this,
+                    source_file ? source_file : SafeString::cEmptyString.cstr(), source_line,
+                    getStackSize());
+}
+
+void Thread::checkStackPointerOverFlow(const char* source_file, s32 source_line) const
+{
+    if (!ThreadMgr::instance() || ThreadMgr::instance()->getCurrentThread() != this)
+    {
+        SEAD_WARN("sead::Thread::checkStackPointerOverFlow cannot be called from other thread.");
+        return;
+    }
+
+    const uintptr_t ptr = ThreadUtil::GetCurrentStackPointer();
+    const uintptr_t start = getStackCheckStartAddress_();
+    if (start)
+    {
+        SEAD_ASSERT_MSG(start <= ptr,
+                        "sead::Thread Stack Pointer Overflow! [%s:%p]\n"
+                        "  Source File: %s\n"
+                        "  Line Number: %d\n"
+                        "  Stack Size: %d, Over Size: %ld",
+                        getName().cstr(), this,
+                        source_file ? source_file : SafeString::cEmptyString.cstr(), source_line,
+                        getStackSize(), start - ptr);
+    }
+    else
+    {
+        ThreadMgr::instance()->getCurrentThread();
+    }
+}
+#else
 void Thread::checkStackOverFlow(const char*, s32) const {}
 
 void Thread::checkStackEndCorruption(const char*, s32) const {}
 
 void Thread::checkStackPointerOverFlow(const char*, s32) const {}
+#endif
 
 void Thread::setStackOverflowExceptionEnable(bool)
 {
@@ -106,9 +162,61 @@ void Thread::run_()
     }
 }
 
+#ifdef SEAD_DEBUG
+// NON_MATCHING: the first loop gets unrolled and the loop counter is not negated
+void Thread::initStackCheck_()
+{
+    void* const start = reinterpret_cast<void*>(getStackCheckStartAddress_());
+    void* const end = PtrUtil::addOffset(mStackTopForCheck, mStackSize);
+    u32* addr = static_cast<u32*>(start);
+
+    if (start >= end)
+        return;
+
+    const size_t len = uintptr_t(end) + (-uintptr_t(start) - 1);
+
+    for (u32 i = 0; i < ((len / 4 + 1) % 8); ++i)
+        *addr++ = cStackCanaryMagic;
+
+    if (len >= 0x1C)
+    {
+        do
+        {
+            for (s32 i = 0; i < 8; ++i)
+                *addr++ = cStackCanaryMagic;
+        } while (addr < end);
+    }
+}
+
+// NON_MATCHING: see Thread::initStackCheck_
+void Thread::initStackCheckWithCurrentStackPointer_()
+{
+    void* const start = reinterpret_cast<void*>(getStackCheckStartAddress_());
+    void* const end = reinterpret_cast<void*>(ThreadUtil::GetCurrentStackPointer());
+    u32* addr = static_cast<u32*>(start);
+
+    if (start >= end)
+        return;
+
+    const size_t len = uintptr_t(end) + (-uintptr_t(start) - 1);
+
+    for (u32 i = 0; i < ((len / 4 + 1) % 8); ++i)
+        *addr++ = cStackCanaryMagic;
+
+    if (len >= 0x1C)
+    {
+        do
+        {
+            for (s32 i = 0; i < 8; ++i)
+                *addr++ = cStackCanaryMagic;
+        } while (addr < end);
+    }
+}
+#else
 void Thread::initStackCheck_() {}
 
 void Thread::initStackCheckWithCurrentStackPointer_() {}
+#endif
 
 SEAD_SINGLETON_DISPOSER_IMPL(ThreadMgr)
 
@@ -182,9 +290,35 @@ void ThreadMgr::quitAndWaitDoneMultipleThread(Thread** threads, s32 num, bool is
     waitDoneMultipleThread(threads, num);
 }
 
+#ifdef SEAD_DEBUG
+void ThreadMgr::checkCurrentThreadStackOverFlow(const char* source_file, s32 source_line)
+{
+    if (!ThreadMgr::instance())
+        return;
+    if (Thread* thread = ThreadMgr::instance()->getCurrentThread())
+        thread->checkStackOverFlow(source_file, source_line);
+}
+
+void ThreadMgr::checkCurrentThreadStackEndCorruption(const char* source_file, s32 source_line)
+{
+    if (!ThreadMgr::instance())
+        return;
+    if (Thread* thread = ThreadMgr::instance()->getCurrentThread())
+        thread->checkStackEndCorruption(source_file, source_line);
+}
+
+void ThreadMgr::checkCurrentThreadStackPointerOverFlow(const char* source_file, s32 source_line)
+{
+    if (!ThreadMgr::instance())
+        return;
+    if (Thread* thread = ThreadMgr::instance()->getCurrentThread())
+        thread->checkStackPointerOverFlow(source_file, source_line);
+}
+#else
 void ThreadMgr::checkCurrentThreadStackOverFlow(const char*, s32) {}
 
 void ThreadMgr::checkCurrentThreadStackEndCorruption(const char*, s32) {}
 
 void ThreadMgr::checkCurrentThreadStackPointerOverFlow(const char*, s32) {}
+#endif
 }  // namespace sead

From 0a0f38b0f18b145d2437ed3ac935e3d179d3571b Mon Sep 17 00:00:00 2001
From: GRAnimated <devin@nhscan.com>
Date: Wed, 15 Jul 2026 23:45:03 -0400
Subject: [PATCH 4/5] Fix for BOTW buildbot

---
 modules/src/basis/seadNew.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/src/basis/seadNew.cpp b/modules/src/basis/seadNew.cpp
index ec40f2ad..ccc75417 100644
--- a/modules/src/basis/seadNew.cpp
+++ b/modules/src/basis/seadNew.cpp
@@ -8,7 +8,7 @@ namespace sead
 {
 namespace system
 {
-void* NewImpl(Heap* heap, size_t size, s32 alignment, bool abortOnFailure)
+void* NewImpl(Heap* heap, size_t size, s32 alignment, bool abortOnFailure [[maybe_unused]])
 {
     if (!HeapMgr::sInstancePtr)
     {

From 9e7e0c92eefdd531ed7faa8cfc5de4cdf84475f7 Mon Sep 17 00:00:00 2001
From: GRAnimated <devin@nhscan.com>
Date: Thu, 16 Jul 2026 18:36:03 -0400
Subject: [PATCH 5/5] Review fixes

---
 include/framework/seadMethodTree.h             |  4 ++--
 .../nin/seadNinFileDeviceBaseNin.cpp           | 15 +++++++++++----
 modules/src/filedevice/seadFileDeviceMgr.cpp   | 10 ++++------
 modules/src/filedevice/seadPath.cpp            | 18 +++++++++---------
 modules/src/framework/seadMethodTree.cpp       |  4 ++--
 5 files changed, 28 insertions(+), 23 deletions(-)

diff --git a/include/framework/seadMethodTree.h b/include/framework/seadMethodTree.h
index 8e6621f3..aeaf2cbc 100644
--- a/include/framework/seadMethodTree.h
+++ b/include/framework/seadMethodTree.h
@@ -31,7 +31,7 @@ class MethodTreeNode : public TTreeNode<MethodTreeNode*>, public INamable, publi
 
     using PauseEventDelegate = IDelegate2<MethodTreeNode*, PauseFlag>;
 
-    explicit MethodTreeNode(CriticalSection* cs) : TTreeNode(this), INamable("")
+    explicit MethodTreeNode(CriticalSection* cs) : TTreeNode(this)
     {
         mPauseEventDelegate = nullptr;
         mCriticalSection = cs;
@@ -78,7 +78,7 @@ class MethodTreeNode : public TTreeNode<MethodTreeNode*>, public INamable, publi
     StorageFor<sead::AnyDelegate> mDelegateHolder;
     mutable CriticalSection* mCriticalSection;
     [[maybe_unused]] u32 mPriority;
-    u32 mPauseFlag;
+    BitFlag32 mPauseFlag;
     PauseEventDelegate* mPauseEventDelegate;
     void* mUserID;
 };
diff --git a/modules/src/filedevice/nin/seadNinFileDeviceBaseNin.cpp b/modules/src/filedevice/nin/seadNinFileDeviceBaseNin.cpp
index 235faa01..668d2281 100644
--- a/modules/src/filedevice/nin/seadNinFileDeviceBaseNin.cpp
+++ b/modules/src/filedevice/nin/seadNinFileDeviceBaseNin.cpp
@@ -24,7 +24,6 @@ NinFileDeviceBase::NinFileDeviceBase(const SafeString& name, const SafeString& m
 {
 }
 
-// NON_MATCHING: CBZ vs TBZ
 FileDevice* NinFileDeviceBase::doOpen_(FileHandle* handle, const SafeString& path,
                                        FileDevice::FileOpenFlag flag)
 {
@@ -47,7 +46,7 @@ FileDevice* NinFileDeviceBase::doOpen_(FileHandle* handle, const SafeString& pat
     bool should_set_size = true;
     if ((flag | cFileOpenFlag_ReadWrite) == cFileOpenFlag_Create)
     {
-        bool is_file = false;
+        u32 is_file = false;
         nn::fs::DirectoryEntryType type;
         const auto result = nn::fs::GetEntryType(&type, fs_path.cstr());
         if (result.IsSuccess())
@@ -56,13 +55,17 @@ FileDevice* NinFileDeviceBase::doOpen_(FileHandle* handle, const SafeString& pat
         }
         else if (!nn::fs::ResultPathNotFound().Includes(result))
         {
+            SEAD_WARN("nn::fs::GetEntryType failed. module = %d desc = %d inner_value = 0x%08x "
+                      "path = %s",
+                      result.GetModule(), result.GetDescription(), result.GetInnerValueForDebug(),
+                      fs_path.cstr());
             mLastError = result;
             return nullptr;
         }
 
         if (flag == cFileOpenFlag_Create)
         {
-            if (is_file)
+            if (is_file != 0)
             {
                 mLastError = nn::fs::ResultPathAlreadyExists();
                 return nullptr;
@@ -71,13 +74,17 @@ FileDevice* NinFileDeviceBase::doOpen_(FileHandle* handle, const SafeString& pat
             const auto create_result = nn::fs::CreateFile(fs_path.cstr(), 0);
             if (create_result.IsFailure())
             {
+                SEAD_WARN("nn::fs::CreateFile failed. module = %d desc = %d inner_value = 0x%08x "
+                          "path = %s",
+                          create_result.GetModule(), create_result.GetDescription(),
+                          create_result.GetInnerValueForDebug(), fs_path.cstr());
                 mLastError = create_result;
                 return nullptr;
             }
         }
         else
         {
-            if (is_file)
+            if (is_file == 1)
             {
                 should_set_size = false;
             }
diff --git a/modules/src/filedevice/seadFileDeviceMgr.cpp b/modules/src/filedevice/seadFileDeviceMgr.cpp
index 7355f8ee..0af150c3 100644
--- a/modules/src/filedevice/seadFileDeviceMgr.cpp
+++ b/modules/src/filedevice/seadFileDeviceMgr.cpp
@@ -339,25 +339,23 @@ bool FileDeviceMgr::trySave(FileDevice::SaveArg& arg)
 }
 
 #ifdef NNSDK
-#ifdef SEAD_DEBUG
 void FileDeviceMgr::mountSaveDataForDebug(Heap*)
 {
+#ifdef SEAD_DEBUG
     const auto result = nn::fs::MountSaveDataForDebug("save");
     SEAD_ASSERT_MSG(
         result.IsSuccess(),
         "nn::fs::MountSaveDataForDebug() failed. module = %d desc = %d innervalue = 0x%08x",
         result.GetModule(), result.GetDescription(), result.GetInnerValueForDebug());
+#endif
 }
 
 void FileDeviceMgr::unmountSaveDataForDebug()
 {
+#ifdef SEAD_DEBUG
     nn::fs::Unmount("save");
-}
-#else
-void FileDeviceMgr::mountSaveDataForDebug(Heap*) {}
-
-void FileDeviceMgr::unmountSaveDataForDebug() {}
 #endif
+}
 #endif
 
 #ifdef cafe
diff --git a/modules/src/filedevice/seadPath.cpp b/modules/src/filedevice/seadPath.cpp
index b1e5316f..f2fd59da 100644
--- a/modules/src/filedevice/seadPath.cpp
+++ b/modules/src/filedevice/seadPath.cpp
@@ -49,22 +49,22 @@ char getLastChar(const SafeString& str)
 }
 }  // namespace
 
-// NON_MATCHING: search-loop register lifetimes and final slice formation differ
 bool Path::getExt(BufferedSafeString* ext, const SafeString& path)
 {
     SEAD_ASSERT_MSG(ext, "destination buffer is null");
 
     ext->trim(0);
 
-    u32 dot_index = rfindCharIndex(path, '.');
-    if (dot_index == 0xFFFFFFFF)
-        return false;
-
-    if (path.getPart(dot_index).include('/') || path.getPart(dot_index).include('\\'))
-        return false;
+    const s32 dot_index = rfindCharIndex(path, '.');
+    if (dot_index >= 0)
+    {
+        if (path.getPart(dot_index).include('/') || path.getPart(dot_index).include('\\'))
+            return false;
 
-    ext->copy(path.getPart(dot_index + 1));
-    return true;
+        ext->copy(path.getPart(dot_index + 1));
+        return true;
+    }
+    return false;
 }
 
 bool Path::getFileName(BufferedSafeString* name, const SafeString& path)
diff --git a/modules/src/framework/seadMethodTree.cpp b/modules/src/framework/seadMethodTree.cpp
index e361fc2b..f87ad3be 100644
--- a/modules/src/framework/seadMethodTree.cpp
+++ b/modules/src/framework/seadMethodTree.cpp
@@ -84,11 +84,11 @@ void MethodTreeNode::call()
 
 void MethodTreeNode::callRec_()
 {
-    if (!(mPauseFlag & cPause_Self))
+    if (mPauseFlag.isOff(cPause_Self))
         (*mDelegateHolder.data())();
 
     auto* node = child();
-    if (node && !(mPauseFlag & cPause_Child))
+    if (node && mPauseFlag.isOff(cPause_Child))
     {
         while (node)
         {