diff --git a/include/container/seadTreeMap.h b/include/container/seadTreeMap.h
index 0ee17a7f..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;
 }
 
-// NON_MATCHING: this version matches the LLRB tree implementation and is better optimized
 template <typename Key>
 inline TreeMapNode<Key>* TreeMapImpl<Key>::eraseMin(Node* node)
 {
@@ -462,10 +461,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..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,8 +73,12 @@ 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
 };
 
 }  // namespace sead
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..aeaf2cbc 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)
     {
-        mCriticalSection = cs;
         mPauseEventDelegate = nullptr;
-        mUserID = nullptr;
+        mCriticalSection = cs;
         mDelegateHolder.construct(sead::Delegate<MethodTreeNode>());
+        mUserID = nullptr;
+        mPauseFlag = cPause_None;
         setPauseFlag(cPause_Both);
     }
 
diff --git a/include/mc/seadJobQueue.h b/include/mc/seadJobQueue.h
index b3b10143..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
@@ -112,13 +119,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; // volatile required for setCoreMaskAndWaitType
     Atomic<u32> mNumDoneJobs = 0;
 
     Atomic<Status> mStatus = Status::_0;
     const char* mDescription = "NoName";
 
-#ifdef SEAD_DEBUG
+#if defined(SEAD_DEBUG) || SEAD_VERSION == SEAD_VERSION_SMO
     PerfJobQueue mPerf;
 #endif
 };
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..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)
     {
@@ -27,6 +27,7 @@ void* NewImpl(Heap* heap, size_t size, s32 alignment, bool abortOnFailure)
     }
 
     void* result = heap->tryAlloc(size, alignment);
+    #ifdef SEAD_DEBUG
     if (!result && abortOnFailure)
     {
         SEAD_ASSERT_MSG(
@@ -34,6 +35,7 @@ void* NewImpl(Heap* heap, size_t size, s32 alignment, bool abortOnFailure)
             heap->getMaxAllocatableSize(alignment), alignment, heap->getName().cstr());
         return nullptr;
     }
+    #endif
     return result;
 }
 
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..2affa374 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::cDevice_NinJoyNpad);
+    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..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: inverted branching for should_set_size
 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())
@@ -64,14 +63,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)
+            if (is_file != 0)
             {
                 mLastError = nn::fs::ResultPathAlreadyExists();
                 return nullptr;
             }
+
             const auto create_result = nn::fs::CreateFile(fs_path.cstr(), 0);
             if (create_result.IsFailure())
             {
@@ -83,6 +82,22 @@ FileDevice* NinFileDeviceBase::doOpen_(FileHandle* handle, const SafeString& pat
                 return nullptr;
             }
         }
+        else
+        {
+            if (is_file == 1)
+            {
+                should_set_size = false;
+            }
+            else
+            {
+                const auto create_result = nn::fs::CreateFile(fs_path.cstr(), 0);
+                if (create_result.IsFailure())
+                {
+                    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..0af150c3 100644
--- a/modules/src/filedevice/seadFileDeviceMgr.cpp
+++ b/modules/src/filedevice/seadFileDeviceMgr.cpp
@@ -341,16 +341,20 @@ bool FileDeviceMgr::trySave(FileDevice::SaveArg& arg)
 #ifdef NNSDK
 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");
+#endif
 }
 #endif
 
diff --git a/modules/src/filedevice/seadPath.cpp b/modules/src/filedevice/seadPath.cpp
index 7dcac9e8..f2fd59da 100644
--- a/modules/src/filedevice/seadPath.cpp
+++ b/modules/src/filedevice/seadPath.cpp
@@ -49,7 +49,6 @@ char getLastChar(const SafeString& str)
 }
 }  // namespace
 
-// NON_MATCHING: redundant checks for dot_index < 0 in SafeString::getPart() are optimized out
 bool Path::getExt(BufferedSafeString* ext, const SafeString& path)
 {
     SEAD_ASSERT_MSG(ext, "destination buffer is null");
@@ -57,14 +56,15 @@ bool Path::getExt(BufferedSafeString* ext, const SafeString& path)
     ext->trim(0);
 
     const s32 dot_index = rfindCharIndex(path, '.');
-    if (dot_index < 0)
-        return false;
-
-    if (path.getPart(dot_index).include('/') || path.getPart(dot_index).include('\\'))
-        return false;
+    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/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..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.isOn(cPause_Self))
+    if (mPauseFlag.isOff(cPause_Self))
         (*mDelegateHolder.data())();
 
     auto* node = child();
-    if (node && !mPauseFlag.isOn(cPause_Child))
+    if (node && mPauseFlag.isOff(cPause_Child))
     {
         while (node)
         {
diff --git a/modules/src/gfx/nvn/seadDebugFontMgrNvn.cpp b/modules/src/gfx/nvn/seadDebugFontMgrNvn.cpp
index 35f2729a..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() = default;
+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,7 +41,7 @@ void DebugFontMgrJis1Nvn::initialize(Heap* heap, const char* shader_path, const
                          unk);
 }
 
-// SMO
+// BOTW
 // NON_MATCHING: Stack
 void DebugFontMgrJis1Nvn::initializeFromBinary(Heap* heap, void* shader_binary, u64 shader_size,
                                                void* font_binary, u64 font_size,
@@ -58,47 +62,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 +122,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 +183,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..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
 {
@@ -63,10 +64,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 +87,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,64 +128,112 @@ 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: something is causing a difference between signed and unsigned
 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;
 }
 
+// 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)
 {
     const T t = t_;
-    const s8 n = info->numUse / 2;
     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])
+    {
+        const T* end_ptr = f + end;
+        return *--end_ptr;
+    }
+
+    for (s32 i = 0; i < n; ++i)
+    {
+        const s32 j = 2 * i;
+        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];
 
@@ -186,6 +242,7 @@ T curveStep2D_(f32 t_, const CurveDataInfo* info, const T* f)
         if (t < f[2 * i + 2])
             return f[2 * i + 1];
     }
+#endif
     return 0;
 }
 
@@ -244,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/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..7f02c8df 100644
--- a/modules/src/mc/seadCoreInfo.cpp
+++ b/modules/src/mc/seadCoreInfo.cpp
@@ -57,6 +57,7 @@ void CoreInfo::configure()
 
 void CoreInfo::dump()
 {
+    #ifdef SEAD_DEBUG
     system::Print("* num cores %d\n", sNumCores);
     for (u32 i = 0; i < sNumCores; ++i)
     {
@@ -65,6 +66,7 @@ void CoreInfo::dump()
     }
     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 33f40c4c..2e48cdec 100644
--- a/modules/src/mc/seadJobQueue.cpp
+++ b/modules/src/mc/seadJobQueue.cpp
@@ -11,7 +11,9 @@ namespace sead
 // NON_MATCHING
 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,18 +94,26 @@ void JobQueue::wait_AT_WORKER()
     }
 }
 
+// NON_MATCHING: b.hi vs. b.lo and b.ne
 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();
 }
 
+#ifdef SEAD_DEBUG
 // NON_MATCHING: stack
 void PerfJobQueue::initialize(const char* name, Heap* heap)
 {
@@ -195,9 +207,103 @@ void PerfJobQueue::detachProcessMeter()
     ProcessMeter::instance()->detachProcessMeterBar(&mProcessMeterBar);
 }
 
+#else
+// NON_MATCHING: the original creates a bunch of empty strings somehow
+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)
+    {
+        CoreId core(i);
+        mInts[core] = 0;
+    }
+
+    for (s32 i = 0; i < mBars.size(); ++i)
+        mBars[i].SafeStringBase<char>::operator=(SafeString("?"));
+
+    SafeString queue_name(name);
+    mProcessMeterBar.SafeStringBase<char>::operator=(queue_name);
+}
+
+void PerfJobQueue::finalize()
+{
+    mInts.freeBuffer();
+    mBars.freeBuffer();
+}
+
+void PerfJobQueue::reset()
+{
+    for (s32 i = 0; i < mInts.size(); ++i)
+        mInts[CoreId(i)] = 0;
+}
+
+void PerfJobQueue::measureBeginDeque()
+{
+    // placing CoreId in a union prevents the sead enum initialization 
+    union UninitializedCoreId
+    {
+        UninitializedCoreId() {}
+        CoreId value;
+    } core;
+
+    mBars[CoreInfo::getCurrentCoreId()];
+    core.value = CoreInfo::getCurrentCoreId();
+    mInts[core.value];
+}
+
+void PerfJobQueue::measureEndDeque()
+{
+    mBars[CoreInfo::getCurrentCoreId()];
+}
+
+void PerfJobQueue::measureBeginRun()
+{
+    // placing CoreId in a union prevents the sead enum initialization 
+    union UninitializedCoreId
+    {
+        UninitializedCoreId() {}
+        CoreId value;
+    } core;
+
+    mBars[CoreInfo::getCurrentCoreId()];
+    core.value = CoreInfo::getCurrentCoreId();
+    auto& idx = mInts[core.value];
+    getBarColor(idx);
+    idx = (idx + 1) % 9;
+}
+
+void PerfJobQueue::measureEndRun()
+{
+    mBars[CoreInfo::getCurrentCoreId()];
+}
+
+const Color4f& PerfJobQueue::getBarColor(u32 idx) const
+{
+    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},
+        {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.9176470637321472, 0.0, 0.21568627655506134, 1.0},
+        {0.9607843160629272, 0.239215686917305, 0.40784314274787903, 1.0},
+    };
+    return sColors[idx];
+}
+
+void PerfJobQueue::attachProcessMeter() {}
+
+void PerfJobQueue::detachProcessMeter() {}
+
+#endif
+
+// NON_MATCHING:
 FixedSizeJQ::FixedSizeJQ()
 {
-    _230 = true;
     mStatus = Status::_0;
     mNumJobs = 0;
     mNumProcessedJobs = 0;
@@ -205,17 +311,16 @@ 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...
 bool FixedSizeJQ::run(u32 size, u32* finished_jobs, Worker* worker)
 {
     *finished_jobs = 0;
 
-#ifdef SEAD_DEBUG
+#if defined(SEAD_DEBUG) || SEAD_VERSION == SEAD_VERSION_SMO
     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,11 +343,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
+#if defined(SEAD_DEBUG) || SEAD_VERSION == SEAD_VERSION_SMO
     mPerf.measureEndDeque();
-#endif
 
-#ifdef SEAD_DEBUG
     mPerf.measureBeginRun();
 #endif
     if (worker)
@@ -253,7 +356,7 @@ bool FixedSizeJQ::run(u32 size, u32* finished_jobs, Worker* worker)
 
     if (worker)
         worker->setState(Worker::State::cRunning_AfterRun);
-#ifdef SEAD_DEBUG
+#if defined(SEAD_DEBUG) || SEAD_VERSION == SEAD_VERSION_SMO
     mPerf.measureEndRun();
 #endif
 
@@ -274,7 +377,7 @@ bool FixedSizeJQ::run(u32 size, u32* finished_jobs, Worker* worker)
 
 void FixedSizeJQ::initialize(u32 size, Heap* heap)
 {
-#ifdef SEAD_DEBUG
+#if defined(SEAD_DEBUG) || SEAD_VERSION == SEAD_VERSION_SMO
     mPerf.initialize(getName().cstr(), heap);
 #endif
 
@@ -287,7 +390,7 @@ void FixedSizeJQ::initialize(u32 size, Heap* heap)
 
 void FixedSizeJQ::finalize()
 {
-#ifdef SEAD_DEBUG
+#if defined(SEAD_DEBUG) || SEAD_VERSION == SEAD_VERSION_SMO
     mPerf.finalize();
 #endif
     mJobs.freeBuffer();
@@ -341,7 +444,7 @@ u32 FixedSizeJQ::deque(Job** jobs, u32 count)
 
 bool FixedSizeJQ::rewind()
 {
-#ifdef SEAD_DEBUG
+#if defined(SEAD_DEBUG) || SEAD_VERSION == SEAD_VERSION_SMO
     mPerf.reset();
 #endif
     mNumProcessedJobs = 0;
@@ -351,7 +454,7 @@ bool FixedSizeJQ::rewind()
 void FixedSizeJQ::clear()
 {
     mStatus = Status::_5;
-#ifdef SEAD_DEBUG
+#if defined(SEAD_DEBUG) || SEAD_VERSION == SEAD_VERSION_SMO
     mPerf.reset();
 #endif
     mNumJobs = 0;
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..9c52a50a 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: 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,
@@ -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..ecc88bc8 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;
@@ -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..18120735 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
 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..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,6 +81,7 @@ s32 Thread::calcStackUsedSizePeak() const
 #endif
 }
 
+#ifdef SEAD_DEBUG
 void Thread::checkStackOverFlow(const char* source_file, s32 source_line) const
 {
     checkStackPointerOverFlow(source_file, source_line);
@@ -130,6 +133,13 @@ void Thread::checkStackPointerOverFlow(const char* source_file, s32 source_line)
         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)
 {
@@ -152,6 +162,7 @@ void Thread::run_()
     }
 }
 
+#ifdef SEAD_DEBUG
 // NON_MATCHING: the first loop gets unrolled and the loop counter is not negated
 void Thread::initStackCheck_()
 {
@@ -201,6 +212,11 @@ void Thread::initStackCheckWithCurrentStackPointer_()
         } while (addr < end);
     }
 }
+#else
+void Thread::initStackCheck_() {}
+
+void Thread::initStackCheckWithCurrentStackPointer_() {}
+#endif
 
 SEAD_SINGLETON_DISPOSER_IMPL(ThreadMgr)
 
@@ -274,6 +290,7 @@ 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())
@@ -297,4 +314,11 @@ void ThreadMgr::checkCurrentThreadStackPointerOverFlow(const char* source_file,
     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
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;