From 090dcee01206bf7ba6b2231747f0b083521019f1 Mon Sep 17 00:00:00 2001
From: TakaRikka <takarikka@outlook.com>
Date: Sun, 26 Feb 2023 17:50:56 -0800
Subject: [PATCH] clean JKernel

---
 include/JSystem/JKernel/JKRCompArchive.h  |   8 +-
 include/JSystem/JSupport/JSupport.h       |  10 +
 include/JSystem/JUtility/JUTConsole.h     |   1 +
 include/dolphin/os/OSAlloc.h              |   3 +-
 libs/JSystem/JKernel/JKRAram.cpp          |  17 +-
 libs/JSystem/JKernel/JKRAramArchive.cpp   |  74 ++--
 libs/JSystem/JKernel/JKRAramBlock.cpp     |   7 +-
 libs/JSystem/JKernel/JKRAramHeap.cpp      |  35 +-
 libs/JSystem/JKernel/JKRAramPiece.cpp     |  12 +-
 libs/JSystem/JKernel/JKRAramStream.cpp    | 121 +-----
 libs/JSystem/JKernel/JKRArchivePri.cpp    |  10 +-
 libs/JSystem/JKernel/JKRArchivePub.cpp    |  10 +-
 libs/JSystem/JKernel/JKRAssertHeap.cpp    |  80 +---
 libs/JSystem/JKernel/JKRCompArchive.cpp   | 257 ++++-------
 libs/JSystem/JKernel/JKRDecomp.cpp        |  95 ++---
 libs/JSystem/JKernel/JKRDisposer.cpp      |   6 -
 libs/JSystem/JKernel/JKRDvdAramRipper.cpp |  45 +-
 libs/JSystem/JKernel/JKRDvdArchive.cpp    |  19 +-
 libs/JSystem/JKernel/JKRDvdFile.cpp       |  10 +-
 libs/JSystem/JKernel/JKRDvdRipper.cpp     |  54 ++-
 libs/JSystem/JKernel/JKRExpHeap.cpp       | 491 +++++++++-------------
 libs/JSystem/JKernel/JKRFile.cpp          |   6 -
 libs/JSystem/JKernel/JKRFileCache.cpp     | 117 +-----
 libs/JSystem/JKernel/JKRFileFinder.cpp    |   1 -
 libs/JSystem/JKernel/JKRFileLoader.cpp    |   9 +-
 libs/JSystem/JKernel/JKRHeap.cpp          | 244 ++++-------
 libs/JSystem/JKernel/JKRMemArchive.cpp    | 102 +----
 libs/JSystem/JKernel/JKRSolidHeap.cpp     |  12 +-
 libs/JSystem/JKernel/JKRThread.cpp        |  36 +-
 libs/JSystem/JUtility/JUTConsole.cpp      |   2 -
 30 files changed, 609 insertions(+), 1285 deletions(-)

diff --git a/include/JSystem/JKernel/JKRCompArchive.h b/include/JSystem/JKernel/JKRCompArchive.h
index 3becd55f1fd..f5fcb319999 100644
--- a/include/JSystem/JKernel/JKRCompArchive.h
+++ b/include/JSystem/JKernel/JKRCompArchive.h
@@ -9,12 +9,12 @@ public:
     JKRCompArchive(long, JKRArchive::EMountDirection);
     virtual ~JKRCompArchive();
 
-    void open(long);
+    bool open(long);
 
     /* vt[09] */ void removeResourceAll(void); /* override */
     /* vt[10] */ bool removeResource(void*);   /* override */
 
-    /* vt[15] */ u32 getExpandedResSize(const void*);                  /* override */
+    /* vt[15] */ u32 getExpandedResSize(const void*) const;                  /* override */
     /* vt[16] */ void* fetchResource(SDIFileEntry*, u32*);             /* override */
     /* vt[17] */ void* fetchResource(void*, u32, SDIFileEntry*, u32*); /* override */
 
@@ -23,9 +23,9 @@ private:
     /* 0x00 */  // vtable
     /* 0x04 */  // JKRArchive
     /* 0x5C */ int field_0x5c;
-    /* 0x60 */ int field_0x60;
+    /* 0x60 */ EMountDirection mMountDirection;
     /* 0x64 */ int field_0x64;
-    /* 0x68 */ int field_0x68;
+    /* 0x68 */ JKRAramBlock* field_0x68;
     /* 0x6C */ int field_0x6c;
     /* 0x70 */ JKRDvdFile* field_0x70;
     /* 0x74 */ u32 mSizeOfMemPart;
diff --git a/include/JSystem/JSupport/JSupport.h b/include/JSystem/JSupport/JSupport.h
index e98dee1f987..cec15081637 100644
--- a/include/JSystem/JSupport/JSupport.h
+++ b/include/JSystem/JSupport/JSupport.h
@@ -1,6 +1,8 @@
 #ifndef JSUPPORT_H
 #define JSUPPORT_H
 
+#include "dolphin/types.h"
+
 template <typename T>
 T* JSUConvertOffsetToPtr(const void* ptr, const void* offset) {
     if (offset == NULL) {
@@ -10,4 +12,12 @@ T* JSUConvertOffsetToPtr(const void* ptr, const void* offset) {
     }
 }
 
+inline u8 JSULoByte(u16 in) {
+    return in & 0xff;
+}
+
+inline u8 JSUHiByte(u16 in) {
+    return in >> 8;
+}
+
 #endif
diff --git a/include/JSystem/JUtility/JUTConsole.h b/include/JSystem/JUtility/JUTConsole.h
index c1c2a5adfac..6714e1922d3 100644
--- a/include/JSystem/JUtility/JUTConsole.h
+++ b/include/JSystem/JUtility/JUTConsole.h
@@ -147,5 +147,6 @@ extern "C" void JUTSetWarningConsole(JUTConsole*);
 extern "C" JUTConsole* JUTGetWarningConsole();
 extern "C" void JUTReportConsole_f_va(const char*, va_list);
 extern "C" void JUTReportConsole_f(const char*, ...);
+extern "C" void JUTWarningConsole(const char* message);
 
 #endif /* JUTCONSOLE_H */
diff --git a/include/dolphin/os/OSAlloc.h b/include/dolphin/os/OSAlloc.h
index 7a74b1e4bcf..ffb5e0c9c05 100644
--- a/include/dolphin/os/OSAlloc.h
+++ b/include/dolphin/os/OSAlloc.h
@@ -26,7 +26,8 @@ typedef u32 OSHeapHandle;
 
 extern volatile s32 __OSCurrHeap;
 
-#define OSRoundUp32B(v) (((u32)(v + 31) & ~31))
+#define OSRoundUp32B(x) (((u32)(x) + 0x1F) & ~(0x1F))
+#define OSRoundDown32B(x) (((u32)(x)) & ~(0x1F))
 
 #define OSRoundUp(x, align) (((x) + (align)-1) & (-(align)))
 #define OSRoundUpPtr(x, align) ((void*)((((u32)(x)) + (align)-1) & (~((align)-1))))
diff --git a/libs/JSystem/JKernel/JKRAram.cpp b/libs/JSystem/JKernel/JKRAram.cpp
index 87601d4035d..6a2c20f0ad4 100644
--- a/libs/JSystem/JKernel/JKRAram.cpp
+++ b/libs/JSystem/JKernel/JKRAram.cpp
@@ -124,7 +124,7 @@ JKRAram::JKRAram(u32 audio_buffer_size, u32 audio_graph_size, long priority)
     u32 aramSize = ARGetSize();
 
     mAudioMemorySize = audio_buffer_size;
-    if (audio_graph_size == 0xffffffff) {
+    if (audio_graph_size == 0xFFFFFFFF) {
         mGraphMemorySize = (aramSize - audio_buffer_size) - aramBase;
         mAramMemorySize = 0;
     } else {
@@ -171,24 +171,15 @@ void* JKRAram::run(void) {
     } while (true);
 }
 
-/* ############################################################################################## */
-/* 8039D078-8039D078 0296D8 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
-// #pragma push
-// #pragma force_active on
-// SECTION_DEAD static char const* const stringBase_8039D078 = "JKRAram.cpp";
-// SECTION_DEAD static char const* const stringBase_8039D084 = "%s";
-// SECTION_DEAD static char const* const stringBase_8039D087 = ":::address not 32Byte aligned.";
-// #pragma pop
-
 /* 802D2248-802D22DC 2CCB88 0094+00 2/2 0/0 0/0 .text
  * checkOkAddress__7JKRAramFPUcUlP12JKRAramBlockUl              */
 void JKRAram::checkOkAddress(u8* addr, u32 size, JKRAramBlock* block, u32 param_4) {
     if (!IS_ALIGNED((u32)addr, 0x20) && !IS_ALIGNED(size, 0x20)) {
-        JUTException::panic_f("JKRAram.cpp", 0xdb, "%s", ":::address not 32Byte aligned.");
+        JUTException::panic_f(__FILE__, 219, "%s", ":::address not 32Byte aligned.");
     }
 
     if (block && !IS_ALIGNED((u32)block->getAddress() + param_4, 0x20)) {
-        JUTException::panic_f("JKRAram.cpp", 0xe3, "%s", ":::address not 32Byte aligned.");
+        JUTException::panic_f(__FILE__, 227, "%s", ":::address not 32Byte aligned.");
     }
 }
 
@@ -445,5 +436,3 @@ SECTION_DEAD static char const* const stringBase_8039D0A6 = "bad aramSync\n";
 /* @stringBase0 padding */
 SECTION_DEAD static char const* const pad_8039D0B4 = "\0\0\0";
 #pragma pop
-
-/* 8039D078-8039D078 0296D8 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
diff --git a/libs/JSystem/JKernel/JKRAramArchive.cpp b/libs/JSystem/JKernel/JKRAramArchive.cpp
index ec8ca228cce..b6482fc77cf 100644
--- a/libs/JSystem/JKernel/JKRAramArchive.cpp
+++ b/libs/JSystem/JKernel/JKRAramArchive.cpp
@@ -8,19 +8,11 @@
 #include "JSystem/JKernel/JKRDvdAramRipper.h"
 #include "JSystem/JKernel/JKRDvdRipper.h"
 #include "JSystem/JKernel/JKRFile.h"
+#include "JSystem/JUtility/JUTException.h"
 #include "MSL_C/MSL_Common/Src/string.h"
 #include "MSL_C/math.h"
 #include "dol2asm.h"
 #include "dolphin/os/OSCache.h"
-#include "dolphin/types.h"
-
-//
-// Types:
-//
-
-struct JUTException {
-    /* 802E21FC */ static void panic_f(char const*, int, char const*, ...);
-};
 
 //
 // Forward References:
@@ -112,9 +104,11 @@ SECTION_DATA extern void* __vt__7JKRFile[8] = {
 JKRAramArchive::JKRAramArchive(s32 param_0, JKRArchive::EMountDirection mountDirection)
     : JKRArchive(param_0, MOUNT_ARAM) {
     mMountDirection = mountDirection;
+
     if (!this->open(param_0)) {
         return;
     }
+
     mVolumeType = 'RARC';
     mVolumeName = mStringTable + mNodes->name_offset;
     JKRFileLoader::sVolumeList.prepend(&mFileLoaderLink);
@@ -131,19 +125,24 @@ JKRAramArchive::~JKRAramArchive() {
                     JKRHeap::free(entry->data, mHeap);
                 }
             }
+
             JKRHeap::free(mArcInfoBlock, mHeap);
             mArcInfoBlock = NULL;
         }
+
         if (mExpandedSize != NULL) {
             JKRHeap::free(mExpandedSize, NULL);
             mExpandedSize = NULL;
         }
+
         if (mDvdFile != NULL) {
             delete mDvdFile;
         }
+
         if (mBlock != NULL) {
             delete mBlock;
         }
+
         JKRFileLoader::sVolumeList.remove(&mFileLoaderLink);
         mIsMounted = false;
     }
@@ -174,6 +173,7 @@ bool JKRAramArchive::open(s32 entryNum) {
         mMountMode = UNKNOWN_MOUNT_MODE;
         return false;
     }
+
     SArcHeader* header = static_cast<SArcHeader*>(JKRAllocFromSysHeap(0x20, -0x20));
     if (header == NULL) {
         mMountMode = UNKNOWN_MOUNT_MODE;
@@ -263,15 +263,18 @@ void* JKRAramArchive::fetchResource(JKRArchive::SDIFileEntry* pEntry, u32* pOutS
     if (pOutSize == NULL) {
         pOutSize = &outSize;
     }
+
     JKRCompression compression = JKRConvertAttrToCompressionType(pEntry->getFlags());
     if (pEntry->data == NULL) {
         u32 size = JKRAramArchive::fetchResource_subroutine(
             pEntry->data_offset + mBlock->getAddress(), pEntry->data_size, mHeap, compression,
             &outBuf);
+
         *pOutSize = size;
         if (size == NULL) {
             return NULL;
         }
+
         pEntry->data = outBuf;
         if (compression == COMPRESSION_YAZ0) {
             this->setExpandSize(pEntry, *pOutSize);
@@ -283,6 +286,7 @@ void* JKRAramArchive::fetchResource(JKRArchive::SDIFileEntry* pEntry, u32* pOutS
             *pOutSize = pEntry->data_size;
         }
     }
+
     return pEntry->data;
 }
 
@@ -352,6 +356,7 @@ u32 JKRAramArchive::fetchResource_subroutine(u32 src, u32 srcLength, u8* dst, u3
     u32 outLen;
     u32 srcSize = ALIGN_NEXT(srcLength, 0x20);
     u32 dstSize = ALIGN_PREV(dstLength, 0x20);
+
     switch (compression) {
     case COMPRESSION_NONE:
         if (srcSize > dstSize) {
@@ -366,7 +371,7 @@ u32 JKRAramArchive::fetchResource_subroutine(u32 src, u32 srcLength, u8* dst, u3
                                &outLen);
         return outLen;
     default:
-        JUTException::panic_f("JKRAramArchive.cpp", 0x28F, "%s", "??? bad sequence\n");
+        JUTException::panic_f(__FILE__, 655, "%s", "??? bad sequence\n");
         return 0;
     }
 }
@@ -400,7 +405,7 @@ u32 JKRAramArchive::fetchResource_subroutine(u32 entryNum, u32 length, JKRHeap*
         *out = tmpBufAligned;
         return readLen;
     default:
-        JUTException::panic_f("JKRAramArchive.cpp", 0x2c9, "%s", "??? bad sequence\n");
+        JUTException::panic_f(__FILE__, 0x2c9, "%s", "??? bad sequence\n");
         return 0;
     }
 }
@@ -420,29 +425,30 @@ asm u32 JKRAramArchive::fetchResource_subroutine(u32 param_0, u32 param_1, JKRHe
 u32 JKRAramArchive::getExpandedResSize(void const* ptr) const {
     if (mExpandedSize == NULL) {
         return this->getResSize(ptr);
-    } else {
-        JKRArchive::SDIFileEntry* entry = this->findPtrResource(ptr);
-        if (entry == NULL) {
-            return 0xFFFFFFFF;
-        } else {
-            if (entry->getCompressFlag() == 0) {
-                return this->getResSize(ptr);
-            } else {
-                u32 expandSize = this->getExpandSize(entry);
-                if (expandSize != 0) {
-                    return expandSize;
-                }
-                u8 tmpBuf[0x40];
-                SArcHeader* buf = (SArcHeader*)ALIGN_PREV((s32)&tmpBuf[0x1F], 0x20);
-                JKRAramToMainRam(entry->data_offset + mBlock->getAddress(), (u8*)buf, 0x20,
-                                 EXPAND_SWITCH_UNKNOWN0, 0, NULL, -1, NULL);
-                expandSize = JKRDecompExpandSize(buf);
-                // ??? casting away const?
-                ((JKRArchive*)this)->setExpandSize(entry, expandSize);
-                return expandSize;
-            }
-        }
     }
+
+    JKRArchive::SDIFileEntry* entry = this->findPtrResource(ptr);
+    if (entry == NULL) {
+        return 0xFFFFFFFF;
+    }
+
+    if (entry->getCompressFlag() == 0) {
+        return this->getResSize(ptr);
+    }
+
+    u32 expandSize = this->getExpandSize(entry);
+    if (expandSize != 0) {
+        return expandSize;
+    }
+
+    u8 tmpBuf[0x40];
+    SArcHeader* buf = (SArcHeader*)ALIGN_PREV((s32)&tmpBuf[0x1F], 0x20);
+    JKRAramToMainRam(entry->data_offset + mBlock->getAddress(), (u8*)buf, 0x20,
+                     EXPAND_SWITCH_UNKNOWN0, 0, NULL, -1, NULL);
+    expandSize = JKRDecompExpandSize(buf);
+    // ??? casting away const?
+    ((JKRArchive*)this)->setExpandSize(entry, expandSize);
+    return expandSize;
 }
 
 /* 802D7B90-802D7BF0 2D24D0 0060+00 1/0 0/0 0/0 .text            __dt__7JKRFileFv */
@@ -455,5 +461,3 @@ extern "C" asm void __dt__7JKRFileFv() {
 #include "asm/JSystem/JKernel/JKRAramArchive/__dt__7JKRFileFv.s"
 }
 #pragma pop
-
-/* 8039D188-8039D188 0297E8 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
diff --git a/libs/JSystem/JKernel/JKRAramBlock.cpp b/libs/JSystem/JKernel/JKRAramBlock.cpp
index 45c6176e0a3..58a3919ee3a 100644
--- a/libs/JSystem/JKernel/JKRAramBlock.cpp
+++ b/libs/JSystem/JKernel/JKRAramBlock.cpp
@@ -6,12 +6,6 @@
 #include "JSystem/JKernel/JKRAramBlock.h"
 #include "JSystem/JKernel/JKRAramHeap.h"
 #include "JSystem/JKernel/JKRHeap.h"
-#include "dol2asm.h"
-#include "dolphin/types.h"
-
-//
-// Declarations:
-//
 
 /* 802D3304-802D3378 2CDC44 0074+00 2/2 1/1 0/0 .text            __ct__12JKRAramBlockFUlUlUlUcb */
 JKRAramBlock::JKRAramBlock(u32 address, u32 size, u32 freeSize, u8 groupId, bool isTempMemory)
@@ -27,6 +21,7 @@ JKRAramBlock::JKRAramBlock(u32 address, u32 size, u32 freeSize, u8 groupId, bool
 JKRAramBlock::~JKRAramBlock() {
     JSUList<JKRAramBlock>* list = mBlockLink.getSupervisor();
     JSULink<JKRAramBlock>* prev = mBlockLink.getPrev();
+
     if (prev) {
         JKRAramBlock* block = prev->getObject();
         block->mFreeSize = mSize + mFreeSize + block->mFreeSize;
diff --git a/libs/JSystem/JKernel/JKRAramHeap.cpp b/libs/JSystem/JKernel/JKRAramHeap.cpp
index 0e04176dc3d..8adf0080c24 100644
--- a/libs/JSystem/JKernel/JKRAramHeap.cpp
+++ b/libs/JSystem/JKernel/JKRAramHeap.cpp
@@ -5,48 +5,20 @@
 
 #include "JSystem/JKernel/JKRAramHeap.h"
 #include "JSystem/JKernel/JKRHeap.h"
-#include "dol2asm.h"
-#include "global.h"
 
 //
 // Forward References:
 //
 
-extern "C" void __ct__11JKRAramHeapFUlUl();
-extern "C" void __dt__11JKRAramHeapFv();
-extern "C" void alloc__11JKRAramHeapFUlQ211JKRAramHeap10EAllocMode();
-extern "C" void allocFromHead__11JKRAramHeapFUl();
-extern "C" void allocFromTail__11JKRAramHeapFUl();
-extern "C" void getFreeSize__11JKRAramHeapFv();
-extern "C" void getTotalFreeSize__11JKRAramHeapFv();
-extern "C" void dump__11JKRAramHeapFv();
-extern "C" void __sinit_JKRAramHeap_cpp();
-extern "C" void func_802D32B0(void* _this);
 extern "C" u8 sAramList__11JKRAramHeap[12];
-
 extern "C" void* __vt__11JKRAramHeap;
 
 //
 // External References:
 //
 
-// TODO: move to JKRHeap
-void* operator new(u32 size);
-void* operator new(u32 size, int alignment);
-void* operator new(u32 size, JKRHeap* heap, int alignment);
-
-extern "C" void findFromRoot__7JKRHeapFPv();
-extern "C" void* __nw__FUlP7JKRHeapi();
 extern "C" void __dl__FPv();
-extern "C" void __ct__11JKRDisposerFv();
 extern "C" void __dt__11JKRDisposerFv();
-extern "C" void __ct__12JKRAramBlockFUlUlUlUcb();
-extern "C" void allocHead__12JKRAramBlockFUlUcP11JKRAramHeap();
-extern "C" void allocTail__12JKRAramBlockFUlUcP11JKRAramHeap();
-extern "C" void __dt__10JSUPtrListFv();
-extern "C" void initiate__10JSUPtrListFv();
-extern "C" void append__10JSUPtrListFP10JSUPtrLink();
-extern "C" void __register_global_object();
 extern "C" void _savegpr_29();
 extern "C" void _restgpr_29();
 
@@ -54,9 +26,6 @@ extern "C" void _restgpr_29();
 // Declarations:
 //
 
-/* 80434300-8043430C 061020 000C+00 1/1 0/0 0/0 .bss             @297 */
-static u8 lit_297[12];
-
 /* 8043430C-80434318 06102C 000C+00 8/8 0/0 0/0 .bss             sAramList__11JKRAramHeap */
 JSUList<JKRAramBlock> JKRAramHeap::sAramList;
 
@@ -206,9 +175,7 @@ void JKRAramHeap::dump(void) {
 
     JSUList<JKRAramBlock>* list = &sAramList;
     JSUListIterator<JKRAramBlock> iterator = list;
-    for (; iterator != list->getEnd(); ++iterator) {
-        // The debug version calls OSReport
-    }
+    for (; iterator != list->getEnd(); ++iterator) {}
 
     unlock();
 }
diff --git a/libs/JSystem/JKernel/JKRAramPiece.cpp b/libs/JSystem/JKernel/JKRAramPiece.cpp
index 0fceb9662aa..fb837ae66c8 100644
--- a/libs/JSystem/JKernel/JKRAramPiece.cpp
+++ b/libs/JSystem/JKernel/JKRAramPiece.cpp
@@ -8,13 +8,7 @@
 #include "JSystem/JKernel/JKRDecomp.h"
 #include "JSystem/JKernel/JKRHeap.h"
 #include "JSystem/JUtility/JUTException.h"
-#include "dol2asm.h"
 #include "dolphin/os/OSCache.h"
-#include "dolphin/types.h"
-
-//
-// Declarations:
-//
 
 /* 802D3574-802D35F4 2CDEB4 0080+00 1/1 0/0 0/0 .text
  * prepareCommand__12JKRAramPieceFiUlUlUlP12JKRAramBlockPFUl_v  */
@@ -49,12 +43,12 @@ OSMutex JKRAramPiece::mMutex;
 JKRAMCommand* JKRAramPiece::orderAsync(int direction, u32 source, u32 destination, u32 length,
                                        JKRAramBlock* block, JKRAMCommand::AsyncCallback callback) {
     lock();
-    if (((source & 0x1f) != 0) || ((destination & 0x1f) != 0)) {
+    if ((source & 0x1f) != 0 || (destination & 0x1f) != 0) {
         OSReport("direction = %x\n", direction);
         OSReport("source = %x\n", source);
         OSReport("destination = %x\n", destination);
         OSReport("length = %x\n", length);
-        JUTException::panic_f("JKRAramPiece.cpp", 0x6c, "%s", "illegal address. abort.");
+        JUTException::panic_f(__FILE__, 108, "%s", "illegal address. abort.");
     }
 
     Message* message = new (JKRHeap::getSystemHeap(), -4) Message();
@@ -167,5 +161,3 @@ JKRAMCommand::~JKRAMCommand() {
     if (field_0x94)
         JKRHeap::free(field_0x94, NULL);
 }
-
-/* 8039D0B8-8039D0B8 029718 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
diff --git a/libs/JSystem/JKernel/JKRAramStream.cpp b/libs/JSystem/JKernel/JKRAramStream.cpp
index 90b754a50ff..d9a243a97c7 100644
--- a/libs/JSystem/JKernel/JKRAramStream.cpp
+++ b/libs/JSystem/JKernel/JKRAramStream.cpp
@@ -9,57 +9,6 @@
 #include "JSystem/JSupport/JSUFileStream.h"
 #include "JSystem/JSupport/JSURandomInputStream.h"
 #include "JSystem/JUtility/JUTException.h"
-#include "dol2asm.h"
-#include "global.h"
-
-//
-// Forward References:
-//
-
-extern "C" void create__13JKRAramStreamFl();
-extern "C" void __ct__13JKRAramStreamFl();
-extern "C" void __dt__13JKRAramStreamFv();
-extern "C" void run__13JKRAramStreamFv();
-extern "C" bool readFromAram__13JKRAramStreamFv();
-extern "C" void writeToAram__13JKRAramStreamFP20JKRAramStreamCommand();
-extern "C" void write_StreamToAram_Async__13JKRAramStreamFP18JSUFileInputStreamUlUlUlPUl();
-extern "C" void sync__13JKRAramStreamFP20JKRAramStreamCommandi();
-extern "C" void setTransBuffer__13JKRAramStreamFPUcUlP7JKRHeap();
-extern "C" void __ct__20JKRAramStreamCommandFv();
-extern "C" s32 getAvailable__20JSURandomInputStreamCFv(JSURandomInputStream*);
-extern "C" extern char const* const JKRAramStream__stringBase0;
-extern "C" u8 sMessageBuffer__13JKRAramStream[16];
-extern "C" u8 sMessageQueue__13JKRAramStream[32];
-extern "C" u8 sAramStreamObject__13JKRAramStream[4];
-extern "C" u8 transBuffer__13JKRAramStream[4];
-extern "C" u8 transSize__13JKRAramStream[4];
-extern "C" u8 transHeap__13JKRAramStream[4];
-
-//
-// External References:
-//
-
-extern "C" void alloc__7JKRHeapFUliP7JKRHeap();
-extern "C" void alloc__7JKRHeapFUli();
-extern "C" void free__7JKRHeapFPvP7JKRHeap();
-extern "C" void* __nw__FUlP7JKRHeapi();
-extern "C" void __dl__FPv();
-extern "C" void __ct__9JKRThreadFUlii();
-extern "C" void __dt__9JKRThreadFv();
-extern "C" void orderSync__12JKRAramPieceFiUlUlUlP12JKRAramBlock();
-extern "C" void read__14JSUInputStreamFPvl();
-extern "C" void seek__20JSURandomInputStreamFl17JSUStreamSeekFrom();
-extern "C" void panic_f__12JUTExceptionFPCciPCce();
-extern "C" void _savegpr_24();
-extern "C" void _savegpr_26();
-extern "C" void _restgpr_24();
-extern "C" void _restgpr_26();
-extern "C" u8 sSystemHeap__7JKRHeap[4];
-extern "C" u8 sCurrentHeap__7JKRHeap[4];
-
-//
-// Declarations:
-//
 
 /* ############################################################################################## */
 /* 80451408-8045140C 000908 0004+00 1/1 0/0 0/0 .sbss            sAramStreamObject__13JKRAramStream
@@ -97,7 +46,7 @@ JKRAramStream::JKRAramStream(long priority) : JKRThread(0xc00, 0x10, priority) {
 JKRAramStream::~JKRAramStream() {}
 
 /* 802D3C68-802D3CD8 2CE5A8 0070+00 1/0 0/0 0/0 .text            run__13JKRAramStreamFv */
-void* JKRAramStream::run(void) {
+void* JKRAramStream::run() {
     OSInitMessageQueue(&sMessageQueue, sMessageBuffer, ARRAY_SIZE(sMessageBuffer));
 
     for (;;) {
@@ -117,16 +66,13 @@ void* JKRAramStream::run(void) {
 }
 
 /* 802D3CD8-802D3CE0 2CE618 0008+00 1/1 0/0 0/0 .text            readFromAram__13JKRAramStreamFv */
-s32 JKRAramStream::readFromAram(void) {
+s32 JKRAramStream::readFromAram() {
     return 1;
 }
 
 /* ############################################################################################## */
 /* 8039D120-8039D120 029780 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
-// regalloc problems
-#ifdef NONMATCHING
 s32 JKRAramStream::writeToAram(JKRAramStreamCommand* command) {
-    u32 size;
     u32 dstSize = command->mSize;
     u32 offset = command->mOffset;
     u32 writtenLength = 0;
@@ -134,31 +80,24 @@ s32 JKRAramStream::writeToAram(JKRAramStreamCommand* command) {
     u8* buffer = command->mTransferBuffer;
     u32 bufferSize = command->mTransferBufferSize;
     JKRHeap* heap = command->mHeap;
-    if (buffer) {
-        if (bufferSize) {
-            size = bufferSize;
-        } else {
-            size = 0x8000;
-        }
 
-        command->mTransferBufferSize = size;
+    if (buffer) {
+        bufferSize = (bufferSize) ? bufferSize : 0x8000;
+
+        command->mTransferBufferSize = bufferSize;
         command->mAllocatedTransferBuffer = false;
     } else {
-        if (bufferSize) {
-            size = bufferSize;
-        } else {
-            size = 0x8000;
-        }
+        bufferSize = (bufferSize) ? bufferSize : 0x8000;
 
         if (heap) {
-            buffer = (u8*)JKRAllocFromHeap(heap, size, -0x20);
+            buffer = (u8*)JKRAllocFromHeap(heap, bufferSize, -0x20);
             command->mTransferBuffer = buffer;
         } else {
-            buffer = (u8*)JKRAllocFromSysHeap(size, -0x20);
+            buffer = (u8*)JKRAllocFromSysHeap(bufferSize, -0x20);
             command->mTransferBuffer = buffer;
         }
 
-        command->mTransferBufferSize = size;
+        command->mTransferBufferSize = bufferSize;
         command->mAllocatedTransferBuffer = true;
     }
 
@@ -169,20 +108,15 @@ s32 JKRAramStream::writeToAram(JKRAramStreamCommand* command) {
             heap->dump();
         }
 
-        JUTException::panic_f("JKRAramStream.cpp", 0xac, "%s", ":::Cannot alloc memory\n");
+        JUTException::panic_f(__FILE__, 172, "%s", ":::Cannot alloc memory\n");
     }
 
     if (buffer) {
-        ((JSURandomInputStream*)command->mStream)->seek(offset, JSUStreamSeekFrom_SET);
+        command->mStream->seek(offset, JSUStreamSeekFrom_SET);
         while (dstSize != 0) {
-            u32 length;
-            if (dstSize > size) {
-                length = size;
-            } else {
-                length = dstSize;
-            }
+            u32 length = (dstSize > bufferSize) ? bufferSize : dstSize;
 
-            s32 readLength = ((JSURandomInputStream*)command->mStream)->read(buffer, length);
+            s32 readLength = command->mStream->read(buffer, length);
             if (readLength == 0) {
                 writtenLength = 0;
                 break;
@@ -190,7 +124,7 @@ s32 JKRAramStream::writeToAram(JKRAramStreamCommand* command) {
 
             JKRAramPcs(0, (u32)buffer, destination, length, NULL);
             dstSize -= length;
-            writtenLength += writtenLength;
+            writtenLength += length;
             destination += length;
 
             if (command->mReturnSize) {
@@ -204,30 +138,9 @@ s32 JKRAramStream::writeToAram(JKRAramStreamCommand* command) {
         }
     }
 
-    OSSendMessage(&command->mMessageQueue, (OSMessage)writtenLength, OS_MESSAGE_NON_BLOCKING);
+    OSSendMessage(&command->mMessageQueue, (OSMessage)writtenLength, OS_MESSAGE_NOBLOCK);
     return writtenLength;
 }
-#else
-#pragma push
-#pragma force_active on
-SECTION_DEAD static char const* const stringBase_8039D120 = "JKRAramStream.cpp";
-SECTION_DEAD static char const* const stringBase_8039D132 = "%s";
-SECTION_DEAD static char const* const stringBase_8039D135 = ":::Cannot alloc memory\n";
-/* @stringBase0 padding */
-SECTION_DEAD static char const* const pad_8039D14D = "\0\0";
-#pragma pop
-
-/* 802D3CE0-802D3ED0 2CE620 01F0+00 1/1 0/0 0/0 .text
- * writeToAram__13JKRAramStreamFP20JKRAramStreamCommand         */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm s32 JKRAramStream::writeToAram(JKRAramStreamCommand* param_0) {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRAramStream/writeToAram__13JKRAramStreamFP20JKRAramStreamCommand.s"
-}
-#pragma pop
-#endif
 
 /* ############################################################################################## */
 /* 8045140C-80451410 00090C 0004+00 2/2 0/0 0/0 .sbss            transBuffer__13JKRAramStream */
@@ -322,5 +235,3 @@ JKRAramStreamCommand::JKRAramStreamCommand() {
 extern "C" s32 getAvailable__20JSURandomInputStreamCFv(JSURandomInputStream* self) {
     return self->getLength() - self->getPosition();
 }
-
-/* 8039D120-8039D120 029780 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
diff --git a/libs/JSystem/JKernel/JKRArchivePri.cpp b/libs/JSystem/JKernel/JKRArchivePri.cpp
index 238268884db..988c461361b 100644
--- a/libs/JSystem/JKernel/JKRArchivePri.cpp
+++ b/libs/JSystem/JKernel/JKRArchivePri.cpp
@@ -7,12 +7,6 @@
 #include "JSystem/JKernel/JKRHeap.h"
 #include "MSL_C/MSL_Common/Src/ctype.h"
 #include "MSL_C/MSL_Common/Src/string.h"
-#include "dol2asm.h"
-#include "dolphin/types.h"
-
-//
-// Declarations:
-//
 
 /* ############################################################################################## */
 /* 80451420-80451428 000920 0004+04 1/1 5/5 0/0 .sbss            sCurrentDirID__10JKRArchive */
@@ -78,7 +72,6 @@ JKRArchive::SDIDirEntry* JKRArchive::findDirectory(const char* name, u32 directo
     SDIFileEntry* fileEntry = mFiles + dirEntry->first_file_index;
 
     for (int i = 0; i < dirEntry->num_entries; fileEntry++, i++) {
-        // regalloc doesn't like fileEntry->getNameHash()
         if (isSameName(arcName, fileEntry->getNameOffset(), fileEntry->name_hash)) {
             if (fileEntry->isDirectory()) {
                 return findDirectory(name, fileEntry->data_offset);
@@ -95,6 +88,7 @@ JKRArchive::SDIFileEntry* JKRArchive::findTypeResource(u32 type, const char* nam
     if (type) {
         CArcName arcName(name);
         SDIDirEntry* dirEntry = findResType(type);
+
         if (dirEntry) {
             SDIFileEntry* fileEntry = mFiles + dirEntry->first_file_index;
             for (int i = 0; i < dirEntry->num_entries; fileEntry++, i++) {
@@ -115,8 +109,8 @@ JKRArchive::SDIFileEntry* JKRArchive::findFsResource(const char* name, u32 direc
         CArcName arcName(&name, '/');
         SDIDirEntry* dirEntry = mNodes + directoryId;
         SDIFileEntry* fileEntry = mFiles + dirEntry->first_file_index;
+
         for (int i = 0; i < dirEntry->num_entries; fileEntry++, i++) {
-            // regalloc doesn't like fileEntry->getNameHash()
             if (isSameName(arcName, fileEntry->getNameOffset(), fileEntry->name_hash)) {
                 if (fileEntry->isDirectory()) {
                     return findFsResource(name, fileEntry->data_offset);
diff --git a/libs/JSystem/JKernel/JKRArchivePub.cpp b/libs/JSystem/JKernel/JKRArchivePub.cpp
index cae7cb8d584..73a69ddc99b 100644
--- a/libs/JSystem/JKernel/JKRArchivePub.cpp
+++ b/libs/JSystem/JKernel/JKRArchivePub.cpp
@@ -12,12 +12,6 @@
 #include "JSystem/JKernel/JKRFileLoader.h"
 #include "JSystem/JKernel/JKRHeap.h"
 #include "JSystem/JKernel/JKRMemArchive.h"
-#include "dol2asm.h"
-#include "dolphin/types.h"
-
-//
-// Declarations:
-//
 
 /* 802D5778-802D57E4 2D00B8 006C+00 2/2 0/0 0/0 .text check_mount_already__10JKRArchiveFlP7JKRHeap
  */
@@ -283,7 +277,7 @@ u32 JKRArchive::readResource(void* buffer, u32 bufferSize, u16 id) {
 
 /* 802D5FB4-802D603C 2D08F4 0088+00 1/0 2/0 0/0 .text            removeResourceAll__10JKRArchiveFv
  */
-void JKRArchive::removeResourceAll(void) {
+void JKRArchive::removeResourceAll() {
     if (mArcInfoBlock && mMountMode != MOUNT_MEM) {
         SDIFileEntry* fileEntry = mFiles;
         for (int i = 0; i < mArcInfoBlock->num_file_entries; fileEntry++, i++) {
@@ -326,7 +320,7 @@ u32 JKRArchive::getResSize(const void* resource) const {
 }
 
 /* 802D610C-802D6150 2D0A4C 0044+00 0/0 1/1 0/0 .text            countResource__10JKRArchiveCFv */
-u32 JKRArchive::countResource(void) const {
+u32 JKRArchive::countResource() const {
     u32 count = 0;
     for (int i = 0; i < mArcInfoBlock->num_file_entries; i++) {
         if (mFiles[i].isUnknownFlag1()) {
diff --git a/libs/JSystem/JKernel/JKRAssertHeap.cpp b/libs/JSystem/JKernel/JKRAssertHeap.cpp
index 0054cd87a41..21ebb2226bd 100644
--- a/libs/JSystem/JKernel/JKRAssertHeap.cpp
+++ b/libs/JSystem/JKernel/JKRAssertHeap.cpp
@@ -4,56 +4,6 @@
 //
 
 #include "JSystem/JKernel/JKRAssertHeap.h"
-#include "dol2asm.h"
-#include "dolphin/types.h"
-
-//
-// Types:
-//
-
-//
-// Forward References:
-//
-
-extern "C" void __ct__13JKRAssertHeapFPvUlP7JKRHeapb();
-extern "C" void __dt__13JKRAssertHeapFv();
-extern "C" void create__13JKRAssertHeapFP7JKRHeap();
-extern "C" void do_destroy__13JKRAssertHeapFv();
-extern "C" void getHeapType__13JKRAssertHeapFv();
-extern "C" bool check__13JKRAssertHeapFv();
-extern "C" bool dump__13JKRAssertHeapFv();
-extern "C" bool dump_sort__13JKRAssertHeapFv();
-extern "C" bool do_changeGroupID__13JKRAssertHeapFUc();
-extern "C" bool do_getCurrentGroupId__13JKRAssertHeapFv();
-extern "C" bool do_alloc__13JKRAssertHeapFUli();
-extern "C" void do_free__13JKRAssertHeapFPv();
-extern "C" void do_freeAll__13JKRAssertHeapFv();
-extern "C" void do_freeTail__13JKRAssertHeapFv();
-extern "C" void do_fillFreeArea__13JKRAssertHeapFv();
-extern "C" bool do_resize__13JKRAssertHeapFPvUl();
-extern "C" bool do_getSize__13JKRAssertHeapFPv();
-extern "C" bool do_getFreeSize__13JKRAssertHeapFv();
-extern "C" bool do_getMaxFreeBlock__13JKRAssertHeapFv();
-extern "C" bool do_getTotalFreeSize__13JKRAssertHeapFv();
-
-//
-// External References:
-//
-
-extern "C" void __ct__7JKRHeapFPvUlP7JKRHeapb();
-extern "C" void __dt__7JKRHeapFv();
-extern "C" void alloc__7JKRHeapFUliP7JKRHeap();
-extern "C" void callAllDisposer__7JKRHeapFv();
-extern "C" void dispose__7JKRHeapFv();
-extern "C" void __dl__FPv();
-extern "C" void state_register__7JKRHeapCFPQ27JKRHeap6TStateUl();
-extern "C" void state_compare__7JKRHeapCFRCQ27JKRHeap6TStateRCQ27JKRHeap6TState();
-extern "C" void state_dump__7JKRHeapCFRCQ27JKRHeap6TState();
-extern "C" u8 sRootHeap__7JKRHeap[4];
-
-//
-// Declarations:
-//
 
 /* 802D12C4-802D1300 2CBC04 003C+00 1/1 0/0 0/0 .text __ct__13JKRAssertHeapFPvUlP7JKRHeapb */
 JKRAssertHeap::JKRAssertHeap(void* data, unsigned long size, JKRHeap* parent, bool errorFlag)
@@ -83,17 +33,17 @@ JKRAssertHeap* JKRAssertHeap::create(JKRHeap* parent) {
 }
 
 /* 802D13D8-802D1408 2CBD18 0030+00 1/0 0/0 0/0 .text            do_destroy__13JKRAssertHeapFv */
-void JKRAssertHeap::do_destroy(void) {
+void JKRAssertHeap::do_destroy() {
     this->~JKRAssertHeap();
 }
 
 /* 802D1408-802D1414 2CBD48 000C+00 1/0 0/0 0/0 .text            getHeapType__13JKRAssertHeapFv */
-u32 JKRAssertHeap::getHeapType(void) {
+u32 JKRAssertHeap::getHeapType() {
     return 'ASTH';
 }
 
 /* 802D1414-802D141C 2CBD54 0008+00 1/0 0/0 0/0 .text            check__13JKRAssertHeapFv */
-bool JKRAssertHeap::check(void) {
+bool JKRAssertHeap::check() {
     return true;
 }
 
@@ -114,7 +64,7 @@ s32 JKRAssertHeap::do_changeGroupID(u8) {
 }
 
 /* 802D1434-802D143C 2CBD74 0008+00 1/0 0/0 0/0 .text do_getCurrentGroupId__13JKRAssertHeapFv */
-u8 JKRAssertHeap::do_getCurrentGroupId(void) {
+u8 JKRAssertHeap::do_getCurrentGroupId() {
     return 0;
 }
 
@@ -124,25 +74,17 @@ void* JKRAssertHeap::do_alloc(u32, int) {
 }
 
 /* 802D1444-802D1448 2CBD84 0004+00 1/0 0/0 0/0 .text            do_free__13JKRAssertHeapFPv */
-void JKRAssertHeap::do_free(void* param_0) {
-    /* empty function */
-}
+void JKRAssertHeap::do_free(void* param_0) {}
 
 /* 802D1448-802D144C 2CBD88 0004+00 1/0 0/0 0/0 .text            do_freeAll__13JKRAssertHeapFv */
-void JKRAssertHeap::do_freeAll() {
-    /* empty function */
-}
+void JKRAssertHeap::do_freeAll() {}
 
 /* 802D144C-802D1450 2CBD8C 0004+00 1/0 0/0 0/0 .text            do_freeTail__13JKRAssertHeapFv */
-void JKRAssertHeap::do_freeTail() {
-    /* empty function */
-}
+void JKRAssertHeap::do_freeTail() {}
 
 /* 802D1450-802D1454 2CBD90 0004+00 1/0 0/0 0/0 .text            do_fillFreeArea__13JKRAssertHeapFv
  */
-void JKRAssertHeap::do_fillFreeArea() {
-    /* empty function */
-}
+void JKRAssertHeap::do_fillFreeArea() {}
 
 /* 802D1454-802D145C 2CBD94 0008+00 1/0 0/0 0/0 .text            do_resize__13JKRAssertHeapFPvUl */
 s32 JKRAssertHeap::do_resize(void*, u32) {
@@ -156,16 +98,16 @@ s32 JKRAssertHeap::do_getSize(void*) {
 
 /* 802D1464-802D146C 2CBDA4 0008+00 1/0 0/0 0/0 .text            do_getFreeSize__13JKRAssertHeapFv
  */
-s32 JKRAssertHeap::do_getFreeSize(void) {
+s32 JKRAssertHeap::do_getFreeSize() {
     return 0;
 }
 
 /* 802D146C-802D1474 2CBDAC 0008+00 1/0 0/0 0/0 .text do_getMaxFreeBlock__13JKRAssertHeapFv */
-void* JKRAssertHeap::do_getMaxFreeBlock(void) {
+void* JKRAssertHeap::do_getMaxFreeBlock() {
     return NULL;
 }
 
 /* 802D1474-802D147C 2CBDB4 0008+00 1/0 0/0 0/0 .text do_getTotalFreeSize__13JKRAssertHeapFv */
-s32 JKRAssertHeap::do_getTotalFreeSize(void) {
+s32 JKRAssertHeap::do_getTotalFreeSize() {
     return 0;
 }
diff --git a/libs/JSystem/JKernel/JKRCompArchive.cpp b/libs/JSystem/JKernel/JKRCompArchive.cpp
index 6cbdb99a3e9..8597e6727e0 100644
--- a/libs/JSystem/JKernel/JKRCompArchive.cpp
+++ b/libs/JSystem/JKernel/JKRCompArchive.cpp
@@ -3,122 +3,15 @@
 // Translation Unit: JKRCompArchive
 //
 
-// #include "JSystem/JKernel/JKRCompArchive.h"
+#include "JSystem/JKernel/JKRCompArchive.h"
+#include "JSystem/JKernel/JKRAram.h"
+#include "JSystem/JKernel/JKRDvdAramRipper.h"
+#include "JSystem/JKernel/JKRDvdArchive.h"
+#include "JSystem/JKernel/JKRMemArchive.h"
+#include "JSystem/JUtility/JUTException.h"
+#include "MSL_C/MSL_Common/Src/string.h"
+#include "MSL_C/math.h"
 #include "dol2asm.h"
-#include "dolphin/types.h"
-
-//
-// Types:
-//
-
-struct JUTException {
-    /* 802E21FC */ void panic_f(char const*, int, char const*, ...);
-};
-
-struct JSUPtrLink {};
-
-struct JSUPtrList {
-    /* 802DBFF0 */ void prepend(JSUPtrLink*);
-    /* 802DC15C */ void remove(JSUPtrLink*);
-};
-
-struct JKRMemArchive {
-    /* 802D6F5C */ void fetchResource_subroutine(u8*, u32, u8*, u32, int);
-};
-
-struct JKRHeap {
-    /* 802CE4D4 */ void alloc(u32, int);
-    /* 802CE474 */ void alloc(u32, int, JKRHeap*);
-    /* 802CE500 */ void free(void*, JKRHeap*);
-    /* 802CE548 */ void free(void*);
-    /* 802CEB18 */ void copyMemory(void*, void*, u32);
-
-    static u8 sSystemHeap[4];
-};
-
-struct JKRFileLoader {
-    /* 802D41D4 */ void unmount();
-
-    static u8 sVolumeList[12];
-};
-
-struct JKRExpandSwitch {};
-
-struct JKRDvdRipper {
-    struct EAllocDirection {};
-
-    /* 802D9C54 */ void loadToMainRAM(s32, u8*, JKRExpandSwitch, u32, JKRHeap*,
-                                      JKRDvdRipper::EAllocDirection, u32, int*, u32*);
-};
-
-struct JKRDvdFile {
-    /* 802D96A0 */ JKRDvdFile(s32);
-};
-
-struct JKRDvdArchive {
-    /* 802D8474 */ void fetchResource_subroutine(s32, u32, u32, JKRHeap*, int, int, u8**);
-    /* 802D826C */ void fetchResource_subroutine(s32, u32, u32, u8*, u32, int, int);
-};
-
-struct JKRDvdAramRipper {
-    /* 802DA874 */ void loadToAram(s32, u32, JKRExpandSwitch, u32, u32, u32*);
-};
-
-struct JKRDecomp {
-    /* 802DB988 */ void orderSync(u8*, u8*, u32, u32);
-};
-
-struct JKRArchive {
-    struct EMountDirection {};
-
-    struct SDIFileEntry {};
-
-    struct EMountMode {};
-
-    /* 802D5A38 */ void becomeCurrent(char const*);
-    /* 802D5C64 */ void getResource(u32, char const*);
-    /* 802D5BE8 */ void getResource(char const*);
-    /* 802D5D8C */ void readResource(void*, u32, u32, char const*);
-    /* 802D5E30 */ void readResource(void*, u32, char const*);
-    /* 802D609C */ void detachResource(void*);
-    /* 802D60D8 */ void getResSize(void const*) const;
-    /* 802D6150 */ void countFile(char const*) const;
-    /* 802D61B0 */ void getFirstFile(char const*) const;
-    /* 802D6294 */ JKRArchive(s32, JKRArchive::EMountMode);
-    /* 802D6334 */ ~JKRArchive();
-    /* 802D6734 */ void findPtrResource(void const*) const;
-    /* 802D693C */ void setExpandSize(JKRArchive::SDIFileEntry*, u32);
-    /* 802D6978 */ void getExpandSize(JKRArchive::SDIFileEntry*) const;
-};
-
-struct JKRCompArchive {
-    /* 802D87D4 */ JKRCompArchive(s32, JKRArchive::EMountDirection);
-    /* 802D887C */ ~JKRCompArchive();
-    /* 802D89BC */ void open(s32);
-    /* 802D8F40 */ void fetchResource(JKRArchive::SDIFileEntry*, u32*);
-    /* 802D90C0 */ void fetchResource(void*, u32, JKRArchive::SDIFileEntry*, u32*);
-    /* 802D9260 */ void removeResourceAll();
-    /* 802D92F4 */ void removeResource(void*);
-    /* 802D9360 */ void getExpandedResSize(void const*) const;
-};
-
-struct JKRAramHeap {
-    struct EAllocMode {};
-
-    /* 802D2FBC */ void alloc(u32, JKRAramHeap::EAllocMode);
-};
-
-struct JKRAramArchive {
-    /* 802D7858 */ void fetchResource_subroutine(u32, u32, u8*, u32, int);
-    /* 802D7914 */ void fetchResource_subroutine(u32, u32, JKRHeap*, int, u8**);
-};
-
-struct JKRAram {
-    /* 802D233C */ void mainRamToAram(u8*, u32, u32, JKRExpandSwitch, u32, JKRHeap*, int, u32*);
-    /* 802D25B4 */ void aramToMainRam(u32, u8*, u32, JKRExpandSwitch, u32, JKRHeap*, int, u32*);
-
-    static u8 sAramObject[4];
-};
 
 //
 // Forward References:
@@ -138,7 +31,6 @@ extern "C" extern char const* const JKRCompArchive__stringBase0;
 // External References:
 //
 
-SECTION_INIT void memset();
 extern "C" void alloc__7JKRHeapFUliP7JKRHeap();
 extern "C" void alloc__7JKRHeapFUli();
 extern "C" void free__7JKRHeapFPvP7JKRHeap();
@@ -177,7 +69,6 @@ extern "C" void orderSync__9JKRDecompFPUcPUcUlUl();
 extern "C" void prepend__10JSUPtrListFP10JSUPtrLink();
 extern "C" void remove__10JSUPtrListFP10JSUPtrLink();
 extern "C" void panic_f__12JUTExceptionFPCciPCce();
-extern "C" void DCInvalidateRange();
 extern "C" void _savegpr_25();
 extern "C" void _savegpr_26();
 extern "C" void _savegpr_28();
@@ -186,7 +77,6 @@ extern "C" void _restgpr_25();
 extern "C" void _restgpr_26();
 extern "C" void _restgpr_28();
 extern "C" void _restgpr_29();
-extern "C" void abs();
 extern "C" u8 sVolumeList__13JKRFileLoader[12];
 extern "C" u8 sSystemHeap__7JKRHeap[4];
 extern "C" u8 sAramObject__7JKRAram[4];
@@ -195,57 +85,60 @@ extern "C" u8 sAramObject__7JKRAram[4];
 // Declarations:
 //
 
-/* ############################################################################################## */
-/* 803CC3E8-803CC438 029508 0050+00 2/2 0/0 0/0 .data            __vt__14JKRCompArchive */
-SECTION_DATA extern void* __vt__14JKRCompArchive[20] = {
-    (void*)NULL /* RTTI */,
-    (void*)NULL,
-    (void*)__dt__14JKRCompArchiveFv,
-    (void*)unmount__13JKRFileLoaderFv,
-    (void*)becomeCurrent__10JKRArchiveFPCc,
-    (void*)getResource__10JKRArchiveFPCc,
-    (void*)getResource__10JKRArchiveFUlPCc,
-    (void*)readResource__10JKRArchiveFPvUlPCc,
-    (void*)readResource__10JKRArchiveFPvUlUlPCc,
-    (void*)removeResourceAll__14JKRCompArchiveFv,
-    (void*)removeResource__14JKRCompArchiveFPv,
-    (void*)detachResource__10JKRArchiveFPv,
-    (void*)getResSize__10JKRArchiveCFPCv,
-    (void*)countFile__10JKRArchiveCFPCc,
-    (void*)getFirstFile__10JKRArchiveCFPCc,
-    (void*)getExpandedResSize__14JKRCompArchiveCFPCv,
-    (void*)fetchResource__14JKRCompArchiveFPQ210JKRArchive12SDIFileEntryPUl,
-    (void*)fetchResource__14JKRCompArchiveFPvUlPQ210JKRArchive12SDIFileEntryPUl,
-    (void*)setExpandSize__10JKRArchiveFPQ210JKRArchive12SDIFileEntryUl,
-    (void*)getExpandSize__10JKRArchiveCFPQ210JKRArchive12SDIFileEntry,
-};
-
 /* 802D87D4-802D887C 2D3114 00A8+00 0/0 1/1 0/0 .text
  * __ct__14JKRCompArchiveFlQ210JKRArchive15EMountDirection      */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm JKRCompArchive::JKRCompArchive(s32 param_0, JKRArchive::EMountDirection param_1) {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRCompArchive/__ct__14JKRCompArchiveFlQ210JKRArchive15EMountDirection.s"
+JKRCompArchive::JKRCompArchive(s32 entryNum, JKRArchive::EMountDirection eMountDirection)
+    : JKRArchive(entryNum, MOUNT_COMP) {
+    mMountDirection = eMountDirection;
+
+    if (!open(entryNum)) {
+        return;
+    }
+
+    mVolumeType = 'RARC';
+    mVolumeName = &mStringTable[mNodes->name_offset];
+    sVolumeList.prepend(&mFileLoaderLink);
+    mIsMounted = true;
 }
-#pragma pop
 
 /* 802D887C-802D89BC 2D31BC 0140+00 1/0 0/0 0/0 .text            __dt__14JKRCompArchiveFv */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm JKRCompArchive::~JKRCompArchive() {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRCompArchive/__dt__14JKRCompArchiveFv.s"
+JKRCompArchive::~JKRCompArchive() {
+    if (mArcInfoBlock != NULL) {
+        SDIFileEntry* file = mFiles;
+        for (int i = 0; i < mArcInfoBlock->num_file_entries; i++) {
+            if (!((file->type_flags_and_name_offset >> 0x18) & 0x10) && file->data != NULL) {
+                JKRFreeToHeap(mHeap, file->data);
+            }
+
+            file++;
+        }
+
+        JKRFreeToHeap(mHeap, mArcInfoBlock);
+        mArcInfoBlock = NULL;
+    }
+
+    if (field_0x68 != NULL) {
+        delete field_0x68;
+    }
+
+    if (mExpandedSize != NULL) {
+        i_JKRFree(mExpandedSize);
+        mExpandedSize = NULL;
+    }
+
+    if (field_0x70 != NULL) {
+        delete field_0x70;
+    }
+
+    sVolumeList.remove(&mFileLoaderLink);
+    mIsMounted = false;
 }
-#pragma pop
 
 /* 802D89BC-802D8F40 2D32FC 0584+00 1/1 0/0 0/0 .text            open__14JKRCompArchiveFl */
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void JKRCompArchive::open(s32 param_0) {
+asm bool JKRCompArchive::open(s32 param_0) {
     nofralloc
 #include "asm/JSystem/JKernel/JKRCompArchive/open__14JKRCompArchiveFl.s"
 }
@@ -256,7 +149,7 @@ asm void JKRCompArchive::open(s32 param_0) {
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void JKRCompArchive::fetchResource(JKRArchive::SDIFileEntry* param_0, u32* param_1) {
+asm void* JKRCompArchive::fetchResource(JKRArchive::SDIFileEntry* param_0, u32* param_1) {
     nofralloc
 #include "asm/JSystem/JKernel/JKRCompArchive/fetchResource__14JKRCompArchiveFPQ210JKRArchive12SDIFileEntryPUl.s"
 }
@@ -276,33 +169,45 @@ SECTION_DEAD static char const* const stringBase_8039D236 = "illegal archive.";
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void JKRCompArchive::fetchResource(void* param_0, u32 param_1,
-                                       JKRArchive::SDIFileEntry* param_2, u32* param_3) {
+asm void* JKRCompArchive::fetchResource(void* param_0, u32 param_1,
+                                        JKRArchive::SDIFileEntry* param_2, u32* param_3) {
     nofralloc
 #include "asm/JSystem/JKernel/JKRCompArchive/fetchResource__14JKRCompArchiveFPvUlPQ210JKRArchive12SDIFileEntryPUl.s"
 }
 #pragma pop
 
 /* 802D9260-802D92F4 2D3BA0 0094+00 1/0 0/0 0/0 .text removeResourceAll__14JKRCompArchiveFv */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void JKRCompArchive::removeResourceAll() {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRCompArchive/removeResourceAll__14JKRCompArchiveFv.s"
+void JKRCompArchive::removeResourceAll() {
+    if (mArcInfoBlock != NULL && mMountMode != MOUNT_MEM) {
+        SDIFileEntry* fileEntry = mFiles;
+        for (int i = 0; i < mArcInfoBlock->num_file_entries; i++) {
+            int tmp = fileEntry->type_flags_and_name_offset >> 0x18;
+
+            if (fileEntry->data != NULL) {
+                if (!(tmp & 0x10)) {
+                    JKRFreeToHeap(mHeap, fileEntry->data);
+                }
+
+                fileEntry->data = NULL;
+            }
+        }
+    }
 }
-#pragma pop
 
 /* 802D92F4-802D9360 2D3C34 006C+00 1/0 0/0 0/0 .text            removeResource__14JKRCompArchiveFPv
  */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void JKRCompArchive::removeResource(void* param_0) {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRCompArchive/removeResource__14JKRCompArchiveFPv.s"
+bool JKRCompArchive::removeResource(void* resource) {
+    SDIFileEntry* fileEntry = findPtrResource(resource);
+    if (!fileEntry)
+        return false;
+
+    if (!((fileEntry->type_flags_and_name_offset >> 0x18) & 0x10)) {
+        JKRFreeToHeap(mHeap, resource);
+    }
+
+    fileEntry->data = NULL;
+    return true;
 }
-#pragma pop
 
 /* ############################################################################################## */
 /* 8039D220-8039D220 029880 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
@@ -317,7 +222,7 @@ SECTION_DEAD static char const* const pad_8039D259 = "\0\0\0\0\0\0";
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void JKRCompArchive::getExpandedResSize(void const* param_0) const {
+asm u32 JKRCompArchive::getExpandedResSize(void const* param_0) const {
     nofralloc
 #include "asm/JSystem/JKernel/JKRCompArchive/getExpandedResSize__14JKRCompArchiveCFPCv.s"
 }
diff --git a/libs/JSystem/JKernel/JKRDecomp.cpp b/libs/JSystem/JKernel/JKRDecomp.cpp
index f1f2a1799be..12994b94a76 100644
--- a/libs/JSystem/JKernel/JKRDecomp.cpp
+++ b/libs/JSystem/JKernel/JKRDecomp.cpp
@@ -5,10 +5,9 @@
 
 #include "JSystem/JKernel/JKRDecomp.h"
 #include "JSystem/JKernel/JKRAramPiece.h"
-#include "JSystem/JKernel/JKRHeap.h"
 #include "JSystem/JKernel/JKRArchive.h"
+#include "JSystem/JKernel/JKRHeap.h"
 #include "dol2asm.h"
-#include "dolphin/types.h"
 
 //
 // Forward References:
@@ -80,7 +79,7 @@ JKRDecomp::JKRDecomp(long priority) : JKRThread(0x800, 0x10, priority) {
 JKRDecomp::~JKRDecomp() {}
 
 /* 802DB790-802DB858 2D60D0 00C8+00 1/0 0/0 0/0 .text            run__9JKRDecompFv */
-void* JKRDecomp::run(void) {
+void* JKRDecomp::run() {
     OSInitMessageQueue(&sMessageQueue, sMessageBuffer, 8);
     for (;;) {
         OSMessage message;
@@ -172,26 +171,23 @@ void JKRDecomp::decode(u8* srcBuffer, u8* dstBuffer, u32 srcLength, u32 dstLengt
 }
 
 /* 802DBA58-802DBC14 2D6398 01BC+00 1/1 0/0 0/0 .text            decodeSZP__9JKRDecompFPUcPUcUlUl */
-// All instructions match. Wrong registers are used.
+// 2 extra mr instructions
 #ifdef NONMATCHING
 void JKRDecomp::decodeSZP(u8* src, u8* dst, u32 srcLength, u32 dstLength) {
-    u32 decodedSize;
+    // s32 decodedSize;
     s32 srcChunkOffset;
-    s32 count;
+    u32 count;
     s32 dstOffset;
     u32 length;
-    u32 counter;
-    u32 srcDataOffset;
-    u32 linkTableOffset;
+    s32 linkInfo;
     s32 offset;
     s32 i;
-
-    decodedSize = read_big_endian_u32(src + 4);
-    linkTableOffset = read_big_endian_u32(src + 8);
-    srcDataOffset = read_big_endian_u32(src + 12);
+    s32 decodedSize = read_big_endian_u32(src + 4);
+    s32 linkTableOffset = read_big_endian_u32(src + 8);
+    s32 srcDataOffset = read_big_endian_u32(src + 12);
 
     dstOffset = 0;
-    counter = 0;
+    u32 counter = 0;
     srcChunkOffset = 16;
 
     u32 chunkBits;
@@ -204,55 +200,50 @@ void JKRDecomp::decodeSZP(u8* src, u8* dst, u32 srcLength, u32 dstLength) {
     do {
         if (counter == 0) {
             chunkBits = read_big_endian_u32(src + srcChunkOffset);
-            srcChunkOffset += 4;
-            counter = 32;
+            srcChunkOffset += sizeof(u32);
+            counter = sizeof(u32) * 8;
         }
 
         if (chunkBits & 0x80000000) {
             if (dstLength == 0) {
                 dst[dstOffset] = src[srcDataOffset];
                 length--;
-                if (length == 0) {
+                if (length == 0)
                     return;
-                }
             } else {
                 dstLength--;
             }
             dstOffset++;
             srcDataOffset++;
         } else {
-            u32 linkInfo = read_big_endian_u16(src + linkTableOffset);
-            linkTableOffset += 2;
+            linkInfo = src[linkTableOffset] << 8 | src[linkTableOffset + 1];
+            linkTableOffset += sizeof(u16);
 
             offset = dstOffset - (linkInfo & 0xFFF);
-            count = ((s32)linkInfo) >> 12;
+            count = (linkInfo >> 12);
             if (count == 0) {
                 count = (u32)src[srcDataOffset] + 0x12;
                 srcDataOffset++;
-            } else {
+            } else
                 count += 2;
-            }
 
-            if (count > decodedSize - dstOffset) {
+            if ((s32)count > decodedSize - dstOffset)
                 count = decodedSize - dstOffset;
-            }
 
-            for (i = 0; i < count; i++, dstOffset++, offset++) {
+            for (i = 0; i < (s32)count; i++, dstOffset++, offset++) {
                 if (dstLength == 0) {
                     dst[dstOffset] = dst[offset - 1];
                     length--;
-                    if (length == 0) {
+                    if (length == 0)
                         return;
-                    }
-                } else {
+                } else
                     dstLength--;
-                }
             }
         }
 
         chunkBits <<= 1;
         counter--;
-    } while ((s32)dstLength < decodedSize);
+    } while (dstOffset < decodedSize);
 }
 #else
 #pragma push
@@ -267,19 +258,20 @@ asm void JKRDecomp::decodeSZP(u8* param_0, u8* param_1, u32 param_2, u32 param_3
 
 /* 802DBC14-802DBCF8 2D6554 00E4+00 1/1 0/0 0/0 .text            decodeSZS__9JKRDecompFPUcPUcUlUl */
 #ifdef NONMATCHING
-void JKRDecomp::decodeSZS(u8* src_buffer, u8* dst_buffer, u32 param_3, u32 param_4) {
-    int copyByteCount;
+void JKRDecomp::decodeSZS(u8* src_buffer, u8* dst_buffer, u32 srcSize, u32 dstSize) {
     u8* decompEnd;
     u8* copyStart;
-    int chunkBitsLeft = 0;
-    int chunkBits;
-    decompEnd = dst_buffer + *(int*)(src_buffer + 4) - param_4;
-    if (param_3 == 0) {
+    s32 copyByteCount;
+    s32 chunkBitsLeft = 0;
+    s32 chunkBits;
+
+    decompEnd = dst_buffer + *(int*)(src_buffer + 4) - dstSize;
+
+    if (srcSize == 0)
         return;
-    }
-    if (param_4 > *(u32*)src_buffer) {
+    if (dstSize > *(u32*)src_buffer)
         return;
-    }
+
     u8* curSrcPos = src_buffer + 0x10;
     do {
         if (chunkBitsLeft == 0) {
@@ -288,19 +280,18 @@ void JKRDecomp::decodeSZS(u8* src_buffer, u8* dst_buffer, u32 param_3, u32 param
             curSrcPos++;
         }
         if ((chunkBits & 0x80) != 0) {
-            if (param_4 == 0) {
+            if (dstSize == 0) {
                 *dst_buffer = *curSrcPos;
-                param_3--;
+                srcSize--;
                 dst_buffer++;
-                if (param_3 == 0) {
+                if (srcSize == 0)
                     return;
-                }
             } else {
-                param_4--;
+                dstSize--;
             }
             curSrcPos++;
         } else {
-            int curVal = *curSrcPos;
+            u8 curVal = *curSrcPos;
             // load is inversed
             copyStart = dst_buffer - ((curVal & 0xF) << 8 | curSrcPos[1]);
             // copyByteCount = ;
@@ -313,15 +304,14 @@ void JKRDecomp::decodeSZS(u8* src_buffer, u8* dst_buffer, u32 param_3, u32 param
                 copyByteCount = (curVal >> 4) + 2;
             }
             do {
-                if (param_4 == 0) {
+                if (dstSize == 0) {
                     *dst_buffer = *(copyStart - 1);
-                    param_3--;
+                    srcSize--;
                     dst_buffer++;
-                    if (param_3 == 0) {
+                    if (srcSize == 0)
                         return;
-                    }
                 } else {
-                    param_4--;
+                    dstSize--;
                 }
                 copyByteCount--;
                 copyStart++;
@@ -348,13 +338,16 @@ JKRCompression JKRDecomp::checkCompressed(u8* src) {
         if (src[2] == 'y') {
             return COMPRESSION_YAY0;
         }
+
         if (src[2] == 'z') {
             return COMPRESSION_YAZ0;
         }
     }
+
     if ((src[0] == 'A') && (src[1] == 'S') && (src[2] == 'R')) {
         return COMPRESSION_ASR;
     }
+
     return COMPRESSION_NONE;
 }
 
diff --git a/libs/JSystem/JKernel/JKRDisposer.cpp b/libs/JSystem/JKernel/JKRDisposer.cpp
index bdcfcddebe9..ddacb954438 100644
--- a/libs/JSystem/JKernel/JKRDisposer.cpp
+++ b/libs/JSystem/JKernel/JKRDisposer.cpp
@@ -5,12 +5,6 @@
 
 #include "JSystem/JKernel/JKRDisposer.h"
 #include "JSystem/JKernel/JKRHeap.h"
-#include "dol2asm.h"
-#include "dolphin/types.h"
-
-//
-// Declarations:
-//
 
 /* 802D147C-802D14E4 2CBDBC 0068+00 0/0 12/12 0/0 .text            __ct__11JKRDisposerFv */
 JKRDisposer::JKRDisposer() : mLink(this) {
diff --git a/libs/JSystem/JKernel/JKRDvdAramRipper.cpp b/libs/JSystem/JKernel/JKRDvdAramRipper.cpp
index 03b107e8f05..aa0375b7aa4 100644
--- a/libs/JSystem/JKernel/JKRDvdAramRipper.cpp
+++ b/libs/JSystem/JKernel/JKRDvdAramRipper.cpp
@@ -7,10 +7,10 @@
 #include "JSystem/JKernel/JKRAram.h"
 #include "JSystem/JKernel/JKRAramStream.h"
 #include "JSystem/JKernel/JKRDvdFile.h"
-// #include "JSystem/JSupport/JSUFileStream.h"
+#include "JSystem/JSupport/JSUFileStream.h"
+#include "JSystem/JSupport/JSUList.h"
 #include "dol2asm.h"
 #include "dolphin/os/OSCache.h"
-#include "dolphin/types.h"
 #include "dolphin/vi/vi.h"
 #include "global.h"
 
@@ -23,16 +23,6 @@ struct JSUList__template10 {
     /* 802DB62C */ void func_802DB62C(void* _this);
 };
 
-struct JSUInputStream {
-    /* 802DC23C */ ~JSUInputStream();
-};
-
-struct JSUFileInputStream {
-    /* 802DADD8 */ ~JSUFileInputStream();
-    /* 802DC638 */ JSUFileInputStream(JKRFile*);
-    int padding[4];
-};
-
 struct JKRAramPiece {
     /* 802D3838 */ void orderSync(int, u32, u32, u32, JKRAramBlock*);
 };
@@ -120,14 +110,17 @@ JKRAramBlock* JKRDvdAramRipper::loadToAram(JKRDvdFile* dvdFile, u32 param_1,
     JKRADCommand* command =
         loadToAram_Async(dvdFile, param_1, param_2, NULL, param_3, param_4, param_5);
     syncAram(command, 0);
+
     if (command->field_0x48 < 0) {
         delete command;
         return NULL;
     }
+
     if (param_1) {
         delete command;
         return (JKRAramBlock*)-1;
     }
+
     JKRAramBlock* result = command->mBlock;
     delete command;
     return result;
@@ -147,10 +140,12 @@ JKRADCommand* JKRDvdAramRipper::loadToAram_Async(JKRDvdFile* dvdFile, u32 param_
     command->field_0x3c = param_4;
     command->field_0x40 = param_5;
     command->field_0x44 = param_6;
+
     if (!callCommand_Async(command)) {
         delete command;
         return NULL;
     }
+
     return command;
 }
 
@@ -176,6 +171,7 @@ JKRADCommand* JKRDvdAramRipper::callCommand_Async(JKRADCommand* command) {
     if (command->field_0x44) {
         *command->field_0x44 = 0;
     }
+
     if (dvdFile->field_0x50) {
         bVar1 = false;
     } else {
@@ -194,17 +190,21 @@ JKRADCommand* JKRDvdAramRipper::callCommand_Async(JKRADCommand* command) {
                 if (DVDReadPrio(&dvdFile->mFileInfo, bufPtr, 0x20, 0, 2) >= 0) {
                     break;
                 }
+
                 if (data_804508D0 == 0) {
                     delete stream;
                     return NULL;
                 }
+
                 VIWaitForRetrace();
             }
             DCInvalidateRange(bufPtr, 0x20);
             JKRCompression tmpCompression = JKRDecomp::checkCompressed(bufPtr);
+
             if (tmpCompression == 3) {
                 tmpCompression = 0;
             }
+
             compression = tmpCompression;
             uncompressedSize =
                 bufPtr[4] << 0x18 | bufPtr[5] << 0x10 | bufPtr[6] << 0x08 | bufPtr[7];
@@ -212,9 +212,11 @@ JKRADCommand* JKRDvdAramRipper::callCommand_Async(JKRADCommand* command) {
                 uncompressedSize = command->field_0x40;
             }
         }
+
         if (compression == 0) {
             command->field_0x34 = 0;
         }
+
         if (command->field_0x34 == 1) {
             if (command->field_0x2c == 0 && command->mBlock == NULL) {
                 command->mBlock =
@@ -224,9 +226,11 @@ JKRADCommand* JKRDvdAramRipper::callCommand_Async(JKRADCommand* command) {
                 }
                 dvdFile->mBlock = command->mBlock;
             }
+
             if (command->mBlock) {
                 command->field_0x2c = command->mBlock->mAddress;
             }
+
             if (command->field_0x2c == 0) {
                 dvdFile->field_0x50 = NULL;
                 return NULL;
@@ -235,14 +239,17 @@ JKRADCommand* JKRDvdAramRipper::callCommand_Async(JKRADCommand* command) {
             if (command->field_0x2c == 0 && !command->mBlock) {
                 command->mBlock = JKRAram::getAramHeap()->alloc(fileSize, JKRAramHeap::HEAD);
             }
+
             if (command->mBlock) {
                 command->field_0x2c = command->mBlock->mAddress;
             }
+
             if (command->field_0x2c == 0) {
                 dvdFile->field_0x50 = NULL;
                 return NULL;
             }
         }
+
         if (compression == 0) {
             command->mStreamCommand = JKRAramStream::write_StreamToAram_Async(
                 stream, command->field_0x2c, fileSize - command->field_0x3c, command->field_0x3c,
@@ -257,12 +264,14 @@ JKRADCommand* JKRDvdAramRipper::callCommand_Async(JKRADCommand* command) {
                                        uncompressedSize, command->field_0x3c, 0,
                                        command->field_0x44);
         }
+
         if (!command->field_0x38) {
             (*((JSUList<JKRADCommand>*)&sDvdAramAsyncList)).append(&command->mLink);
         } else {
             command->field_0x38((u32)command);
         }
     }
+
     OSUnlockMutex(&dvdFile->mMutex2);
     return bVar1 == true ? command : NULL;
 }
@@ -281,7 +290,8 @@ asm JKRADCommand* JKRDvdAramRipper::callCommand_Async(JKRADCommand* command) {
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm JSUFileInputStream::~JSUFileInputStream() {
+// asm JSUFileInputStream::~JSUFileInputStream() {
+extern "C" asm void __dt__18JSUFileInputStreamFv() {
     nofralloc
 #include "asm/JSystem/JKernel/JKRDvdAramRipper/__dt__18JSUFileInputStreamFv.s"
 }
@@ -289,22 +299,27 @@ asm JSUFileInputStream::~JSUFileInputStream() {
 
 /* 802DAE48-802DAF1C 2D5788 00D4+00 1/1 0/0 0/0 .text
  * syncAram__16JKRDvdAramRipperFP12JKRADCommandi                */
+// should match when other functions using sDvdAramAsyncList are decompiled
 #ifdef NONMATCHING
 bool JKRDvdAramRipper::syncAram(JKRADCommand* command, int param_1) {
     JKRDvdFile* dvdFile = command->mDvdFile;
     OSLockMutex(&dvdFile->mMutex2);
+
     if (command->mStreamCommand) {
         JKRAramStreamCommand* var1 = JKRAramStream::sync(command->mStreamCommand, param_1);
         command->field_0x48 = -(var1 == NULL);
+
         if (param_1 != 0 && var1 == NULL) {
             OSUnlockMutex(&dvdFile->mMutex2);
             return false;
         }
     }
+
     (*((JSUList<JKRADCommand>*)&sDvdAramAsyncList)).remove(&command->mLink);
     if (command->mStreamCommand) {
         delete command->mStreamCommand;
     }
+
     delete dvdFile->mFileStream;
     dvdFile->field_0x50 = NULL;
     OSUnlockMutex(&dvdFile->mMutex2);
@@ -405,6 +420,7 @@ int JKRDecompressFromDVDToAram(JKRDvdFile* dvdFile, u32 param_1, u32 fileSize, u
         OSInitMutex(&decompMutex);
         data_804514A4 = true;
     }
+
     OSRestoreInterrupts(level);
     OSLockMutex(&decompMutex);
     u32 bufferSize = JKRDvdAramRipper::sSZSBufferSize;
@@ -478,8 +494,7 @@ static asm int dmaBufferFlush(u32 param_0) {
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void __sinit_JKRDvdAramRipper_cpp() {
-    nofralloc
+asm void __sinit_JKRDvdAramRipper_cpp(){nofralloc
 #include "asm/JSystem/JKernel/JKRDvdAramRipper/__sinit_JKRDvdAramRipper_cpp.s"
 }
 #pragma pop
diff --git a/libs/JSystem/JKernel/JKRDvdArchive.cpp b/libs/JSystem/JKernel/JKRDvdArchive.cpp
index c2d094fac38..b29451d035a 100644
--- a/libs/JSystem/JKernel/JKRDvdArchive.cpp
+++ b/libs/JSystem/JKernel/JKRDvdArchive.cpp
@@ -11,6 +11,7 @@
 #include "MSL_C/math.h"
 #include "MSL_C/string.h"
 #include "dol2asm.h"
+#include "dolphin/os/OS.h"
 #include "global.h"
 
 //
@@ -74,11 +75,6 @@ extern "C" void _restgpr_29();
 extern "C" u8 sVolumeList__13JKRFileLoader[12];
 extern "C" u8 sSystemHeap__7JKRHeap[4];
 
-extern "C" {
-void DCInvalidateRange(void*, u32);
-void DCStoreRange(void*, u32);
-}
-
 //
 // Declarations:
 //
@@ -226,6 +222,7 @@ void* JKRDvdArchive::fetchResource(SDIFileEntry* fileEntry, u32* returnSize) {
         if (resourceSize == 0) {
             return NULL;
         }
+
         fileEntry->data = resourcePtr;
         if (fileCompression == COMPRESSION_YAZ0) {
             setExpandSize(fileEntry, *returnSize);
@@ -346,12 +343,11 @@ u32 JKRDvdArchive::fetchResource_subroutine(s32 entryNum, u32 offset, u32 size,
     }
 
     case COMPRESSION_YAY0: {
-        JUTException::panic_f("JKRDvdArchive.cpp", 0x289, "%s",
-                              "Sorry, not applied for SZP archive.\n");
+        JUTException::panic_f(__FILE__, 649, "%s", "Sorry, not applied for SZP archive.\n");
     }
 
     default: {
-        JUTException::panic_f("JKRDvdArchive.cpp", 0x28d, "%s", "??? bad sequence\n");
+        JUTException::panic_f(__FILE__, 653, "%s", "??? bad sequence\n");
         return 0;
     }
     }
@@ -414,12 +410,11 @@ u32 JKRDvdArchive::fetchResource_subroutine(s32 entryNum, u32 offset, u32 size,
     }
 
     case COMPRESSION_YAY0: {
-        JUTException::panic_f("JKRDvdArchive.cpp", 0x2f2, "%s",
-                              "Sorry, not applied SZP archive.\n");
+        JUTException::panic_f(__FILE__, 754, "%s", "Sorry, not applied SZP archive.\n");
     }
 
     default: {
-        JUTException::panic_f("JKRDvdArchive.cpp", 0x2f6, "%s", "??? bad sequence\n");
+        JUTException::panic_f(__FILE__, 758, "%s", "??? bad sequence\n");
         return 0;
     }
     }
@@ -461,5 +456,3 @@ u32 JKRDvdArchive::getExpandedResSize(const void* resource) const {
 
     return resourceSize;
 }
-
-/* 8039D1B0-8039D1B0 029810 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
diff --git a/libs/JSystem/JKernel/JKRDvdFile.cpp b/libs/JSystem/JKernel/JKRDvdFile.cpp
index 211259d7a5a..83356b1ee28 100644
--- a/libs/JSystem/JKernel/JKRDvdFile.cpp
+++ b/libs/JSystem/JKernel/JKRDvdFile.cpp
@@ -9,10 +9,6 @@
 #include "dol2asm.h"
 #include "global.h"
 
-//
-// Declarations:
-//
-
 /* 8043436C-80434378 06108C 000C+00 4/4 0/0 0/0 .bss             sDvdList__10JKRDvdFile */
 JSUList<JKRDvdFile> JKRDvdFile::sDvdList;
 
@@ -94,7 +90,7 @@ void JKRDvdFile::close() {
             mIsAvailable = false;
             getDvdList().remove(&mDvdLink);
         } else {
-            JUTException::panic_f("JKRDvdFile.cpp", 0xd5, "%s", "cannot close DVD file\n");
+            JUTException::panic_f(__FILE__, 213, "%s", "cannot close DVD file\n");
         }
     }
 }
@@ -105,7 +101,7 @@ s32 JKRDvdFile::readData(void* param_1, long length, long param_3) {
     // The assert condition gets stringified as "( length & 0x1f ) == 0", 
     // with out disabling clang-format the spaces in the condition will  
     // get removed and the string will be incorrect.
-    JUT_ASSERT("JKRDvdFile.cpp", 0xee, ( length & 0x1f ) == 0);
+    JUT_ASSERT(__FILE__, 238, ( length & 0x1f ) == 0);
     /* clang-format on */
 
     OSLockMutex(&mMutex1);
@@ -155,5 +151,3 @@ void JKRDvdFile::doneProcess(long id, DVDFileInfo* fileInfo) {
 s32 JKRDvdFile::getFileSize(void) const {
     return mFileInfo.length;
 }
-
-/* 8039D260-8039D260 0298C0 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
diff --git a/libs/JSystem/JKernel/JKRDvdRipper.cpp b/libs/JSystem/JKernel/JKRDvdRipper.cpp
index ac61b87dec6..405214c3847 100644
--- a/libs/JSystem/JKernel/JKRDvdRipper.cpp
+++ b/libs/JSystem/JKernel/JKRDvdRipper.cpp
@@ -9,7 +9,6 @@
 #include "MSL_C/MSL_Common/Src/string.h"
 #include "dol2asm.h"
 #include "dolphin/os/OSCache.h"
-#include "dolphin/types.h"
 #include "global.h"
 
 //
@@ -107,7 +106,7 @@ void* JKRDvdRipper::loadToMainRAM(s32 entryNumber, u8* dst, JKRExpandSwitch expa
 /* 8039D290-8039D290 0298F0 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
 #pragma push
 #pragma force_active on
-SECTION_DEAD static char const* const stringBase_8039D290 = "JKRDvdRipper.cpp";
+SECTION_DEAD static char const* const stringBase_8039D290 = __FILE__;
 SECTION_DEAD static char const* const stringBase_8039D2A1 = "%s";
 SECTION_DEAD static char const* const stringBase_8039D2A4 = "Sorry, not applied for SZP archive.";
 SECTION_DEAD static char const* const stringBase_8039D2C8 = "Not support SZP with offset read";
@@ -151,21 +150,26 @@ void* JKRDvdRipper::loadToMainRAM(JKRDvdFile* dvdFile, u8* dst, JKRExpandSwitch
         }
         r26 = (bufPtr[4] << 0x18) | (bufPtr[5] << 0x10) | (bufPtr[6] << 0x08) | (bufPtr[7]);
     }
+
     if (pCompression) {
         *pCompression = compression;
     }
+
     if (expandSwitch == EXPAND_SWITCH_UNKNOWN1 && compression) {
         if (dstLength != 0 && r26 > dstLength) {
             r26 = dstLength;
         }
+
         if (!dst) {
             dst = (u8*)JKRHeap::alloc(r26, allocDirection == ALLOC_DIRECTION_FORWARD ? 0x20 : -0x20,
                                       heap);
             did_alloc = true;
         }
+
         if (!dst) {
             return NULL;
         }
+
         if (compression == 1) {
             mem = (u8*)JKRHeap::alloc(fileSizeAligned, 0x20, heap);
             if (mem == NULL && did_alloc == true) {
@@ -183,10 +187,12 @@ void* JKRDvdRipper::loadToMainRAM(JKRDvdFile* dvdFile, u8* dst, JKRExpandSwitch
                 var2, allocDirection == ALLOC_DIRECTION_FORWARD ? 0x20 : -0x20, heap);
             did_alloc = true;
         }
+
         if (!dst) {
             return NULL;
         }
     }
+
     if (compression == 0) {
         int count = 0;
         if (offset != 0) {
@@ -197,31 +203,38 @@ void* JKRDvdRipper::loadToMainRAM(JKRDvdFile* dvdFile, u8* dst, JKRExpandSwitch
                 if (count >= 0) {
                     break;
                 }
+
                 if (count == -3 || !data_804508C8) {
                     if (did_alloc == true) {
                         JKRHeap::free(dst, NULL);
                     }
                     return NULL;
                 }
+
                 VIWaitForRetrace();
             }
+
             DCInvalidateRange(bufPtr, 0x20);
             count = JKRDecomp::checkCompressed(bufPtr);
             if (count == 3) {
                 count = 0;
             }
         }
+
         if (count == 0 || expandSwitch == EXPAND_SWITCH_UNKNOWN2 ||
-            expandSwitch == EXPAND_SWITCH_UNKNOWN0) {
+            expandSwitch == EXPAND_SWITCH_UNKNOWN0)
+        {
             fileSizeAligned -= offset;
             if (dstLength != 0 && dstLength < fileSizeAligned) {
                 fileSizeAligned = dstLength;
             }
+
             while (true) {
                 count = DVDReadPrio(dvdFile->getFileInfo(), dst, fileSizeAligned, offset, 2);
                 if (count >= 0) {
                     break;
                 }
+
                 if (count == -3 || !data_804508C8) {
                     if (did_alloc == true) {
                         JKRHeap::free(dst, NULL);
@@ -230,6 +243,7 @@ void* JKRDvdRipper::loadToMainRAM(JKRDvdFile* dvdFile, u8* dst, JKRExpandSwitch
                 }
                 VIWaitForRetrace();
             }
+
             if (param_8) {
                 *param_8 = fileSizeAligned;
             }
@@ -237,24 +251,25 @@ void* JKRDvdRipper::loadToMainRAM(JKRDvdFile* dvdFile, u8* dst, JKRExpandSwitch
         } else if (count == 2) {
             JKRDecompressFromDVD(dvdFile, dst, fileSizeAligned, dstLength, 0, offset, param_8);
         } else {
-            JUTException::panic_f("JKRDvdRipper.cpp", 0x143, "%s",
-                                  "Sorry, not applied for SZP archive.");
+            JUTException::panic_f(__FILE__, 0x143, "%s", "Sorry, not applied for SZP archive.");
         }
         return dst;
     } else if (compression == 1) {
         if (offset) {
-            JUTException::panic_f("JKRDvdRipper.cpp", 0x14d, "%s",
-                                  "Not support SZP with offset read");
+            JUTException::panic_f(__FILE__, 0x14d, "%s", "Not support SZP with offset read");
         }
+
         while (true) {
             int count = DVDReadPrio(dvdFile->getFileInfo(), mem, fileSizeAligned, 0, 2);
             if (count >= 0) {
                 break;
             }
+
             if (count == -3 || !data_804508C8) {
                 if (did_alloc == true) {
                     JKRHeap::free(dst, NULL);
                 }
+
                 JKRHeap::free(mem, NULL);
                 return NULL;
             }
@@ -356,6 +371,7 @@ static u32 tsArea;
 
 /* 802DA1E4-802DA35C 2D4B24 0178+00 1/1 0/0 0/0 .text
  * JKRDecompressFromDVD__FP10JKRDvdFilePvUlUlUlUlPUl            */
+// wrong reg at the end
 #ifdef NONMATCHING
 static int JKRDecompressFromDVD(JKRDvdFile* dvdFile, void* dst, u32 fileSize, u32 param_3,
                                 u32 param_4, u32 param_5, u32* param_6) {
@@ -364,11 +380,13 @@ static int JKRDecompressFromDVD(JKRDvdFile* dvdFile, void* dst, u32 fileSize, u3
         OSInitMutex(&decompMutex);
         data_80451458 = true;
     }
+
     OSRestoreInterrupts(level);
     OSLockMutex(&decompMutex);
     u32 bufferSize = JKRDvdRipper::sSZSBufferSize;
     szpBuf = (u8*)JKRHeap::sSystemHeap->alloc(bufferSize, -0x20);
     szpEnd = szpBuf + bufferSize;
+
     if (param_4) {
         refBuf = (u8*)JKRHeap::sSystemHeap->alloc(0x1120, -4);
         refEnd = refBuf + 0x1120;
@@ -376,24 +394,29 @@ static int JKRDecompressFromDVD(JKRDvdFile* dvdFile, void* dst, u32 fileSize, u3
     } else {
         refBuf = NULL;
     }
+
     srcFile = dvdFile;
     srcOffset = param_5;
     transLeft = fileSize - param_5;
     fileOffset = param_4;
     readCount = 0;
     maxDest = param_3;
+
     if (!param_6) {
         tsPtr = &tsArea;
     } else {
         tsPtr = param_6;
     }
+
     *tsPtr = 0;
     u8* first = firstSrcData();
     int result = first ? decompSZS_subroutine(first, (u8*)dst) : -1;
-    JKRHeap::free(szpBuf, 0);
+    i_JKRFree(szpBuf);
+
     if (refBuf) {
-        JKRHeap::free(refBuf, 0);
+        i_JKRFree(refBuf);
     }
+
     DCStoreRangeNoSync(dst, *tsPtr);
     OSUnlockMutex(&decompMutex);
     return result;
@@ -542,16 +565,19 @@ static u8* firstSrcData() {
     u8* buffer = szpBuf;
     u32 bufSize = szpEnd - buffer;
     u32 length = transLeft < bufSize ? transLeft : bufSize;
+
     while (true) {
         int result = DVDReadPrio(srcFile->getFileInfo(), buffer, length, srcOffset, 2);
         if (result >= 0) {
             break;
         }
+
         if (result == -3 || !data_804508C8) {
             return NULL;
         }
         VIWaitForRetrace();
     }
+
     DCInvalidateRange(buffer, length);
     srcOffset += length;
     transLeft -= length;
@@ -566,9 +592,11 @@ static u8* nextSrcData(u8* param_0) {
     memcpy(dest, param_0, size);
     u8* end = dest + size;
     u32 transSize = szpEnd - end;
+
     if (transSize > transLeft) {
         transSize = transLeft;
     }
+
     while (true) {
         s32 result = DVDReadPrio(srcFile->getFileInfo(), end, transSize, srcOffset, 2);
         if (result >= 0) {
@@ -580,12 +608,15 @@ static u8* nextSrcData(u8* param_0) {
         }
         VIWaitForRetrace();
     }
+
     DCInvalidateRange(end, transSize);
     srcOffset += transSize;
     transLeft -= transSize;
+
     if (transLeft == 0) {
         srcLimit = end + transSize;
     }
+
     return dest;
 }
 #else
@@ -608,8 +639,7 @@ u8 JKRDvdRipper::isErrorRetry() {
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void __sinit_JKRDvdRipper_cpp() {
-    nofralloc
+asm void __sinit_JKRDvdRipper_cpp(){nofralloc
 #include "asm/JSystem/JKernel/JKRDvdRipper/__sinit_JKRDvdRipper_cpp.s"
 }
 #pragma pop
@@ -629,5 +659,3 @@ extern "C" asm void func_802DA820(void* _this) {
 #include "asm/JSystem/JKernel/JKRDvdRipper/func_802DA820.s"
 }
 #pragma pop
-
-/* 8039D290-8039D290 0298F0 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
diff --git a/libs/JSystem/JKernel/JKRExpHeap.cpp b/libs/JSystem/JKernel/JKRExpHeap.cpp
index 5c656d0f38c..91b1e32a9b1 100644
--- a/libs/JSystem/JKernel/JKRExpHeap.cpp
+++ b/libs/JSystem/JKernel/JKRExpHeap.cpp
@@ -4,9 +4,9 @@
 //
 
 #include "JSystem/JKernel/JKRExpHeap.h"
+#include "JSystem/JSupport/JSupport.h"
 #include "JSystem/JUtility/JUTException.h"
 #include "dol2asm.h"
-#include "dolphin/types.h"
 #include "global.h"
 
 //
@@ -114,7 +114,6 @@ JKRExpHeap* JKRExpHeap::createRoot(int maxHeaps, bool errorFlag) {
 
 /* 802CEE2C-802CEF00 2C976C 00D4+00 0/0 19/19 1/1 .text            create__10JKRExpHeapFUlP7JKRHeapb
  */
-#ifdef NONMATCHING
 JKRExpHeap* JKRExpHeap::create(u32 size, JKRHeap* parent, bool errorFlag) {
     if (!parent) {
         parent = sRootHeap;
@@ -129,30 +128,23 @@ JKRExpHeap* JKRExpHeap::create(u32 size, JKRHeap* parent, bool errorFlag) {
     if (alignedSize < 0xa0)
         return NULL;
 
-    void* memory = alloc(alignedSize, 0x10, parent);
-    void* dataPtr = (u8*)memory + expHeapSize;
+    u8* memory = (u8*)JKRAllocFromHeap(parent, alignedSize, 0x10);
+    u8* dataPtr = (memory + expHeapSize);
     if (!memory) {
         return NULL;
     }
+
     JKRExpHeap* newHeap =
         new (memory) JKRExpHeap(dataPtr, alignedSize - expHeapSize, parent, errorFlag);
+
     if (newHeap == NULL) {
-        free(memory, NULL);
+        i_JKRFree(memory);
         return NULL;
-    };
+    }
+
     newHeap->field_0x6e = false;
     return newHeap;
 }
-#else
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm JKRExpHeap* JKRExpHeap::create(u32 param_0, JKRHeap* param_1, bool param_2) {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRExpHeap/create__10JKRExpHeapFUlP7JKRHeapb.s"
-}
-#pragma pop
-#endif
 
 /* 802CEF00-802CEFAC 2C9840 00AC+00 0/0 1/1 0/0 .text            create__10JKRExpHeapFPvUlP7JKRHeapb
  */
@@ -165,15 +157,18 @@ JKRExpHeap* JKRExpHeap::create(void* ptr, u32 size, JKRHeap* parent, bool errorF
     } else {
         parent2 = parent;
     }
+
     JKRExpHeap* newHeap = NULL;
     u32 expHeapSize = ALIGN_NEXT(sizeof(JKRExpHeap), 0x10);
     if (size < expHeapSize)
         return NULL;
+
     void* dataPtr = (u8*)ptr + expHeapSize;
     u32 alignedSize = ALIGN_PREV((u32)ptr + size - (u32)dataPtr, 0x10);
     if (ptr) {
         newHeap = new (ptr) JKRExpHeap(dataPtr, alignedSize, parent2, errorFlag);
     }
+
     newHeap->field_0x6e = true;
     newHeap->field_0x70 = ptr;
     newHeap->field_0x74 = size;
@@ -193,35 +188,6 @@ void JKRExpHeap::do_destroy() {
     }
 }
 
-/* ############################################################################################## */
-/* 803CBFD0-803CC030 0290F0 0060+00 2/2 0/0 0/0 .data            __vt__10JKRExpHeap */
-SECTION_DATA extern void* __vt__10JKRExpHeap[24] = {
-    (void*)NULL /* RTTI */,
-    (void*)NULL,
-    (void*)__dt__10JKRExpHeapFv,
-    (void*)callAllDisposer__7JKRHeapFv,
-    (void*)getHeapType__10JKRExpHeapFv,
-    (void*)check__10JKRExpHeapFv,
-    (void*)dump_sort__10JKRExpHeapFv,
-    (void*)dump__10JKRExpHeapFv,
-    (void*)do_destroy__10JKRExpHeapFv,
-    (void*)do_alloc__10JKRExpHeapFUli,
-    (void*)do_free__10JKRExpHeapFPv,
-    (void*)do_freeAll__10JKRExpHeapFv,
-    (void*)do_freeTail__10JKRExpHeapFv,
-    (void*)do_fillFreeArea__10JKRExpHeapFv,
-    (void*)do_resize__10JKRExpHeapFPvUl,
-    (void*)do_getSize__10JKRExpHeapFPv,
-    (void*)do_getFreeSize__10JKRExpHeapFv,
-    (void*)do_getMaxFreeBlock__10JKRExpHeapFv,
-    (void*)do_getTotalFreeSize__10JKRExpHeapFv,
-    (void*)do_changeGroupID__10JKRExpHeapFUc,
-    (void*)do_getCurrentGroupId__10JKRExpHeapFv,
-    (void*)state_register__10JKRExpHeapCFPQ27JKRHeap6TStateUl,
-    (void*)state_compare__10JKRExpHeapCFRCQ27JKRHeap6TStateRCQ27JKRHeap6TState,
-    (void*)state_dump__7JKRHeapCFRCQ27JKRHeap6TState,
-};
-
 /* 802CF030-802CF0C0 2C9970 0090+00 3/3 0/0 0/0 .text            __ct__10JKRExpHeapFPvUlP7JKRHeapb
  */
 JKRExpHeap::JKRExpHeap(void* data, u32 size, JKRHeap* parent, bool errorFlag)
@@ -248,6 +214,7 @@ void* JKRExpHeap::do_alloc(u32 size, int alignment) {
     if (size < 4) {
         size = 4;
     }
+
     if (alignment >= 0) {
         if (alignment <= 4) {
             ptr = allocFromHead(size);
@@ -261,6 +228,7 @@ void* JKRExpHeap::do_alloc(u32 size, int alignment) {
             ptr = allocFromTail(size, -alignment);
         }
     }
+
     if (ptr == NULL) {
         JUTWarningConsole_f(":::cannot alloc memory (0x%x byte).\n", size);
         if (mErrorFlag == true) {
@@ -289,68 +257,82 @@ static JKRExpHeap::CMemBlock* DBnewFreeBlock;
 static JKRExpHeap::CMemBlock* DBnewUsedBlock;
 
 /* 802CF234-802CF490 2C9B74 025C+00 1/1 0/0 0/0 .text            allocFromHead__10JKRExpHeapFUli */
+// wrong register at end
 #ifdef NONMATCHING
 void* JKRExpHeap::allocFromHead(u32 size, int align) {
-    size = ALIGN_NEXT(size, 4);
-    s32 foundSize = -1;
-    u32 foundOffset = 0;
-    CMemBlock* foundBlock = NULL;
+    u32 foundOffset;
+    int foundSize;
+    CMemBlock* newFreeBlock;
+    CMemBlock* newUsedBlock;
+    CMemBlock* foundBlock;
 
-    for (CMemBlock* block = mHeadFreeList; block; block = block->getNextBlock()) {
-        u32 start = (u32)(block->getContent());
-        u32 offset = ALIGN_PREV(align - 1 + start, align) - start;
-        if (block->getSize() < size + offset) {
+    size = ALIGN_NEXT(size, 4);
+    foundSize = -1;
+    foundOffset = 0;
+    foundBlock = NULL;
+
+    for (CMemBlock* block = mHeadFreeList; block; block = block->mNext) {
+        u32 offset =
+            ALIGN_PREV(align - 1 + (u32)block->getContent(), align) - (u32)block->getContent();
+        if (block->size < size + offset) {
             continue;
         }
-        if (foundSize <= block->getSize()) {
+
+        if (foundSize <= (u32)block->size) {
             continue;
         }
-        foundSize = block->getSize();
+
+        foundSize = block->size;
         foundBlock = block;
         foundOffset = offset;
         if (mAllocMode != 0) {
             break;
         }
-        u32 blockSize = block->getSize();
+
+        u32 blockSize = block->size;
         if (blockSize == size) {
             break;
         }
     }
+
     DBfoundSize = foundSize;
     DBfoundOffset = foundOffset;
     DBfoundBlock = foundBlock;
+
     if (foundBlock) {
         if (foundOffset >= sizeof(CMemBlock)) {
-            CMemBlock* prev = foundBlock->getPrevBlock();
-            CMemBlock* next = foundBlock->getNextBlock();
-            CMemBlock* newUsedBlock =
-                foundBlock->allocFore(foundOffset - sizeof(CMemBlock), 0, 0, 0, 0);
-            CMemBlock* newFreeBlock;
+            CMemBlock* prev = foundBlock->mPrev;
+            CMemBlock* next = foundBlock->mNext;
+            newUsedBlock = foundBlock->allocFore(foundOffset - sizeof(CMemBlock), 0, 0, 0, 0);
+
             if (newUsedBlock) {
                 newFreeBlock = newUsedBlock->allocFore(size, mCurrentGroupId, 0, 0, 0);
             } else {
                 newFreeBlock = NULL;
             }
+
             if (newFreeBlock) {
                 setFreeBlock(foundBlock, prev, newFreeBlock);
             } else {
                 setFreeBlock(foundBlock, prev, next);
             }
+
             if (newFreeBlock) {
                 setFreeBlock(newFreeBlock, foundBlock, next);
             }
+
             appendUsedList(newUsedBlock);
             DBnewFreeBlock = newFreeBlock;
             DBnewUsedBlock = newUsedBlock;
             return newUsedBlock->getContent();
         } else {
             if (foundOffset != 0) {
-                CMemBlock* prev = foundBlock->getPrevBlock();
-                CMemBlock* next = foundBlock->getNextBlock();
+                CMemBlock* prev = foundBlock->mPrev;
+                CMemBlock* next = foundBlock->mNext;
                 removeFreeBlock(foundBlock);
-                CMemBlock* newUsedBlock = (CMemBlock*)((u32)foundBlock + foundOffset);
-                newUsedBlock->size = foundBlock->getSize() - foundOffset;
-                CMemBlock* newFreeBlock =
+                newUsedBlock = (CMemBlock*)((u32)foundBlock + foundOffset);
+                newUsedBlock->size = foundBlock->size - foundOffset;
+                newFreeBlock =
                     newUsedBlock->allocFore(size, mCurrentGroupId, (u8)foundOffset, 0, 0);
                 if (newFreeBlock) {
                     setFreeBlock(newFreeBlock, prev, next);
@@ -358,9 +340,9 @@ void* JKRExpHeap::allocFromHead(u32 size, int align) {
                 appendUsedList(newUsedBlock);
                 return newUsedBlock->getContent();
             } else {
-                CMemBlock* prev = foundBlock->getPrevBlock();
-                CMemBlock* next = foundBlock->getNextBlock();
-                CMemBlock* newFreeBlock = foundBlock->allocFore(size, mCurrentGroupId, 0, 0, 0);
+                CMemBlock* prev = foundBlock->mPrev;
+                CMemBlock* next = foundBlock->mNext;
+                newFreeBlock = foundBlock->allocFore(size, mCurrentGroupId, 0, 0, 0);
                 removeFreeBlock(foundBlock);
                 if (newFreeBlock) {
                     setFreeBlock(newFreeBlock, prev, next);
@@ -370,6 +352,7 @@ void* JKRExpHeap::allocFromHead(u32 size, int align) {
             }
         }
     }
+
     return NULL;
 }
 #else
@@ -392,18 +375,22 @@ void* JKRExpHeap::allocFromHead(u32 size) {
         if (block->getSize() < size) {
             continue;
         }
+
         if (foundSize <= block->getSize()) {
             continue;
         }
+
         foundSize = block->getSize();
         foundBlock = block;
         if (mAllocMode != 0) {
             break;
         }
+
         if (foundSize == size) {
             break;
         }
     }
+
     if (foundBlock) {
         CMemBlock* newblock = foundBlock->allocFore(size, mCurrentGroupId, 0, 0, 0);
         if (newblock) {
@@ -418,25 +405,24 @@ void* JKRExpHeap::allocFromHead(u32 size) {
 }
 
 /* 802CF574-802CF6D4 2C9EB4 0160+00 1/1 0/0 0/0 .text            allocFromTail__10JKRExpHeapFUli */
-#ifdef NONMATCHING
 void* JKRExpHeap::allocFromTail(u32 size, int align) {
     u32 offset = 0;
     CMemBlock* foundBlock = NULL;
     CMemBlock* newBlock = NULL;
-    u32 end;
-    u32 start;
     u32 usedSize;
-    for (CMemBlock* block = mTailFreeList; block; block = block->getPrevBlock()) {
-        end = (u32)block->getContent() + block->getSize();
-        start = ALIGN_PREV(end - size, align);
-        usedSize = end - start;
-        if (block->getSize() >= usedSize) {
+    u32 start;
+
+    for (CMemBlock* block = mTailFreeList; block; block = block->mPrev) {
+        start = ALIGN_PREV((u32)block->getContent() + block->size - size, align);
+        usedSize = (u32)block->getContent() + block->size - start;
+        if (block->size >= usedSize) {
             foundBlock = block;
-            offset = block->getSize() - usedSize;
+            offset = block->size - usedSize;
             newBlock = (CMemBlock*)start - 1;
             break;
         }
     }
+
     if (foundBlock != NULL) {
         if (offset >= sizeof(CMemBlock)) {
             newBlock->initiate(NULL, NULL, usedSize, mCurrentGroupId, -0x80);
@@ -457,18 +443,9 @@ void* JKRExpHeap::allocFromTail(u32 size, int align) {
             }
         }
     }
+
     return NULL;
 }
-#else
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void* JKRExpHeap::allocFromTail(u32 param_0, int param_1) {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRExpHeap/allocFromTail__10JKRExpHeapFUli.s"
-}
-#pragma pop
-#endif
 
 /* 802CF6D4-802CF7AC 2CA014 00D8+00 1/1 0/0 0/0 .text            allocFromTail__10JKRExpHeapFUl */
 void* JKRExpHeap::allocFromTail(u32 size) {
@@ -480,6 +457,7 @@ void* JKRExpHeap::allocFromTail(u32 size) {
             break;
         }
     }
+
     if (foundBlock != NULL) {
         CMemBlock* usedBlock = foundBlock->allocBack(size2, 0, 0, mCurrentGroupId, 0);
         CMemBlock* freeBlock;
@@ -490,6 +468,7 @@ void* JKRExpHeap::allocFromTail(u32 size) {
             usedBlock = foundBlock;
             freeBlock = NULL;
         }
+
         if (freeBlock) {
             setFreeBlock(freeBlock, foundBlock->getPrevBlock(), foundBlock->getNextBlock());
         }
@@ -524,37 +503,23 @@ void JKRExpHeap::do_freeAll() {
 }
 
 /* 802CF89C-802CF924 2CA1DC 0088+00 1/0 0/0 0/0 .text            do_freeTail__10JKRExpHeapFv */
-#ifdef NONMATCHING
 void JKRExpHeap::do_freeTail() {
     lock();
-    CMemBlock* block = mHeadUsedList;
-    while (block) {
-        if (block->_isTempMemBlock()) {
-            dispose(block->getContent(), block->getSize());
-            CMemBlock* next = block->getNextBlock();
+    for (CMemBlock* block = mHeadUsedList; block != NULL;) {
+        if ((block->mFlags & 0x80) != 0) {
+            dispose(block + 1, block->size);
+            CMemBlock* temp = block->mNext;
             block->free(this);
-            block = next;
+            block = temp;
         } else {
-            block = block->getNextBlock();
+            block = block->mNext;
         }
     }
     unlock();
 }
-#else
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void JKRExpHeap::do_freeTail() {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRExpHeap/do_freeTail__10JKRExpHeapFv.s"
-}
-#pragma pop
-#endif
 
 /* 802CF924-802CF928 2CA264 0004+00 1/0 0/0 0/0 .text            do_fillFreeArea__10JKRExpHeapFv */
-void JKRExpHeap::do_fillFreeArea() {
-    /* empty function */
-}
+void JKRExpHeap::do_fillFreeArea() {}
 
 /* 802CF928-802CF978 2CA268 0050+00 1/0 0/0 0/0 .text            do_changeGroupID__10JKRExpHeapFUc
  */
@@ -567,67 +532,59 @@ s32 JKRExpHeap::do_changeGroupID(u8 param_0) {
 }
 
 /* 802CF978-802CFB24 2CA2B8 01AC+00 1/0 0/0 0/0 .text            do_resize__10JKRExpHeapFPvUl */
-#ifdef NONMATCHING
 s32 JKRExpHeap::do_resize(void* ptr, u32 size) {
     lock();
     CMemBlock* block = CMemBlock::getHeapBlock(ptr);
-    if (block == NULL || ptr < getStartAddr() || getEndAddr() < ptr) {
+    if (block == NULL || ptr < mStart || mEnd < ptr) {
         unlock();
         return -1;
     }
-    u32 newSize = ALIGN_NEXT(size, 4);
-    if (newSize == block->getSize()) {
+
+    size = ALIGN_NEXT(size, 4);
+    if (size == block->size) {
         unlock();
-        return newSize;
+        return size;
     }
-    if (newSize > block->getSize()) {
+
+    if (size > block->size) {
         CMemBlock* foundBlock = NULL;
-        for (CMemBlock* freeBlock = mHeadFreeList; freeBlock;
-             freeBlock = freeBlock->getNextBlock()) {
-            if (freeBlock == (CMemBlock*)((u32)block->getContent() + block->getSize())) {
+        for (CMemBlock* freeBlock = mHeadFreeList; freeBlock; freeBlock = freeBlock->mNext) {
+            if (freeBlock == (CMemBlock*)((u32)(block + 1) + block->size)) {
                 foundBlock = freeBlock;
                 break;
             }
         }
+
         if (foundBlock == NULL) {
             unlock();
             return -1;
         }
-        if (newSize > block->getSize() + sizeof(CMemBlock) + foundBlock->getSize()) {
+
+        if (size > block->size + sizeof(CMemBlock) + foundBlock->size) {
             unlock();
             return -1;
         }
+
         removeFreeBlock(foundBlock);
-        block->size += foundBlock->getSize() + sizeof(CMemBlock);
-        if (block->getSize() - newSize > sizeof(CMemBlock)) {
-            CMemBlock* newBlock =
-                block->allocFore(newSize, block->getGroupId(), block->mFlags, 0, 0);
+        block->size += foundBlock->size + sizeof(CMemBlock);
+        if (block->size - size > sizeof(CMemBlock)) {
+            CMemBlock* newBlock = block->allocFore(size, block->mGroupId, block->mFlags, 0, 0);
             if (newBlock) {
                 recycleFreeBlock(newBlock);
             }
         }
     } else {
-        if (block->getSize() - newSize > 0x10) {
-            CMemBlock* freeBlock =
-                block->allocFore(newSize, block->getGroupId(), block->mFlags, 0, 0);
+        if (block->size - size > sizeof(CMemBlock)) {
+            CMemBlock* freeBlock = block->allocFore(size, block->mGroupId, block->mFlags, 0, 0);
             if (freeBlock) {
                 recycleFreeBlock(freeBlock);
             }
         }
     }
+
     unlock();
-    return block->getSize();
+    return block->size;
 }
-#else
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm s32 JKRExpHeap::do_resize(void* param_0, u32 param_1) {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRExpHeap/do_resize__10JKRExpHeapFPvUl.s"
-}
-#pragma pop
-#endif
 
 /* 802CFB24-802CFBA4 2CA464 0080+00 1/0 0/0 0/0 .text            do_getSize__10JKRExpHeapFPv */
 s32 JKRExpHeap::do_getSize(void* ptr) {
@@ -687,12 +644,14 @@ s32 JKRExpHeap::getUsedSize(u8 groupId) const {
     JKRExpHeap* this2 = const_cast<JKRExpHeap*>(this);
     this2->lock();
     u32 size = 0;
+
     for (CMemBlock* block = mHeadUsedList; block; block = block->getNextBlock()) {
         u8 blockGroupId = block->getGroupId();
         if (blockGroupId == groupId) {
             size += block->getSize() + sizeof(CMemBlock);
         }
     }
+
     this2->unlock();
     return size;
 }
@@ -703,9 +662,11 @@ s32 JKRExpHeap::getTotalUsedSize() const {
     JKRExpHeap* this2 = const_cast<JKRExpHeap*>(this);
     this2->lock();
     u32 size = 0;
+
     for (CMemBlock* block = mHeadUsedList; block; block = block->getNextBlock()) {
         size += block->getSize() + sizeof(CMemBlock);
     }
+
     this2->unlock();
     return size;
 }
@@ -714,16 +675,19 @@ s32 JKRExpHeap::getTotalUsedSize() const {
  * appendUsedList__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock       */
 void JKRExpHeap::appendUsedList(JKRExpHeap::CMemBlock* newblock) {
     if (!newblock) {
-        JUTException::panic_f("JKRExpHeap.cpp", 0x620, "%s", "bad appendUsedList\n");
+        JUTException::panic_f(__FILE__, 1568, "%s", "bad appendUsedList\n");
     }
+
     CMemBlock* block = mTailUsedList;
     newblock->mMagic = 'HM';
+
     if (block) {
         block->mNext = newblock;
         newblock->mPrev = block;
     } else {
         newblock->mPrev = NULL;
     }
+
     mTailUsedList = newblock;
     if (!mHeadUsedList) {
         mHeadUsedList = newblock;
@@ -742,6 +706,7 @@ void JKRExpHeap::setFreeBlock(CMemBlock* block, CMemBlock* prev, CMemBlock* next
         prev->mNext = block;
         block->mPrev = prev;
     }
+
     if (next == NULL) {
         mTailFreeList = block;
         block->mNext = NULL;
@@ -749,6 +714,7 @@ void JKRExpHeap::setFreeBlock(CMemBlock* block, CMemBlock* prev, CMemBlock* next
         next->mPrev = block;
         block->mNext = next;
     }
+
     block->mMagic = 0;
 }
 
@@ -757,11 +723,13 @@ void JKRExpHeap::setFreeBlock(CMemBlock* block, CMemBlock* prev, CMemBlock* next
 void JKRExpHeap::removeFreeBlock(CMemBlock* block) {
     CMemBlock* prev = block->mPrev;
     CMemBlock* next = block->mNext;
+
     if (prev == NULL) {
         mHeadFreeList = next;
     } else {
         prev->mNext = next;
     }
+
     if (next == NULL) {
         mTailFreeList = prev;
     } else {
@@ -774,11 +742,13 @@ void JKRExpHeap::removeFreeBlock(CMemBlock* block) {
 void JKRExpHeap::removeUsedBlock(JKRExpHeap::CMemBlock* block) {
     CMemBlock* prev = block->mPrev;
     CMemBlock* next = block->mNext;
+
     if (prev == NULL) {
         mHeadUsedList = next;
     } else {
         prev->mNext = next;
     }
+
     if (next == NULL) {
         mTailUsedList = prev;
     } else {
@@ -788,143 +758,99 @@ void JKRExpHeap::removeUsedBlock(JKRExpHeap::CMemBlock* block) {
 
 /* 802CFF1C-802D00B4 2CA85C 0198+00 2/2 0/0 0/0 .text
  * recycleFreeBlock__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock     */
-#ifdef NONMATCHING
 void JKRExpHeap::recycleFreeBlock(JKRExpHeap::CMemBlock* block) {
-    u32 size = block->size;
+    JKRExpHeap::CMemBlock* newBlock = block;
+    int size = block->size;
     void* blockEnd = (u8*)block + size;
     block->mMagic = 0;
-    u32 offset = block->getAlignment();
-    if (offset) {
-        block = (CMemBlock*)((u8*)block - offset);
-        size += offset;
-        blockEnd = (u8*)block + size;
-        block->mGroupId = 0;
-        block->mFlags = 0;
-        block->size = size;
+
+    if ((block->mFlags & 0x7f) != 0) {
+        newBlock = (CMemBlock*)((u8*)block - (block->mFlags & 0x7f));
+        size += (block->mFlags & 0x7f);
+        blockEnd = (u8*)newBlock + size;
+        newBlock->mGroupId = 0;
+        newBlock->mFlags = 0;
+        newBlock->size = size;
     }
 
     if (!mHeadFreeList) {
-        block->initiate(NULL, NULL, size, 0, 0);
-        mHeadFreeList = block;
-        mTailFreeList = block;
-        setFreeBlock(block, NULL, NULL);
+        newBlock->initiate(NULL, NULL, size, 0, 0);
+        mHeadFreeList = newBlock;
+        mTailFreeList = newBlock;
+        setFreeBlock(newBlock, NULL, NULL);
         return;
     }
+
     if (mHeadFreeList >= blockEnd) {
-        block->initiate(NULL, NULL, size, 0, 0);
-        setFreeBlock(block, NULL, mHeadFreeList);
-        joinTwoBlocks(block);
+        newBlock->initiate(NULL, NULL, size, 0, 0);
+        setFreeBlock(newBlock, NULL, mHeadFreeList);
+        joinTwoBlocks(newBlock);
         return;
     }
-    if (mTailFreeList <= block) {
-        block->initiate(NULL, NULL, size, 0, 0);
-        setFreeBlock(block, mTailFreeList, NULL);
-        joinTwoBlocks(block->getPrevBlock());
+
+    if (mTailFreeList <= newBlock) {
+        newBlock->initiate(NULL, NULL, size, 0, 0);
+        setFreeBlock(newBlock, mTailFreeList, NULL);
+        joinTwoBlocks(newBlock->mPrev);
         return;
     }
-    for (CMemBlock* freeBlock = mHeadFreeList; freeBlock; freeBlock = freeBlock->getNextBlock()) {
-        if (freeBlock >= block || block >= freeBlock->getNextBlock()) {
+
+    for (CMemBlock* freeBlock = mHeadFreeList; freeBlock; freeBlock = freeBlock->mNext) {
+        if (freeBlock >= newBlock || newBlock >= freeBlock->mNext) {
             continue;
         }
-        block->mNext = freeBlock->getNextBlock();
-        block->mPrev = freeBlock;
-        freeBlock->mNext = block;
-        block->mNext->mPrev = block;
-        block->mGroupId = 0;
-        joinTwoBlocks(block);
+        newBlock->mNext = freeBlock->mNext;
+        newBlock->mPrev = freeBlock;
+        freeBlock->mNext = newBlock;
+        newBlock->mNext->mPrev = newBlock;
+        newBlock->mGroupId = 0;
+        joinTwoBlocks(newBlock);
         joinTwoBlocks(freeBlock);
         return;
     }
 }
-#else
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void JKRExpHeap::recycleFreeBlock(JKRExpHeap::CMemBlock* param_0) {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRExpHeap/recycleFreeBlock__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock.s"
-}
-#pragma pop
-#endif
-
-/* ############################################################################################## */
-/* 8039CAF0-8039CAF0 029150 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
-#pragma push
-#pragma force_active on
-SECTION_DEAD static char const* const stringBase_8039CB3B = ":::Heap may be broken. (block = %x)";
-SECTION_DEAD static char const* const stringBase_8039CB5F = "Bad Block\n";
-#pragma pop
 
 /* 802D00B4-802D0190 2CA9F4 00DC+00 1/1 0/0 0/0 .text
  * joinTwoBlocks__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock        */
-#ifdef NONMATCHING
 void JKRExpHeap::joinTwoBlocks(CMemBlock* block) {
-    u32 endAddr = (u32)block->getContent() + block->getSize();
-    CMemBlock* next = block->getNextBlock();
-    u32 nextAddr = (u32)next - next->getAlignment();
+    u32 endAddr = (u32)(block + 1) + block->size;
+    CMemBlock* next = block->mNext;
+    u32 nextAddr = (u32)next - (next->mFlags & 0x7f);
     if (endAddr > nextAddr) {
         JUTWarningConsole_f(":::Heap may be broken. (block = %x)", block);
-        getCurrentHeap()->dump();
-        JUTException::panic_f("JKRExpHeap.cpp", 0x71c, "%s", "Bad Block\n");
+        JKRGetCurrentHeap()->dump();
+        JUTException::panic_f(__FILE__, 1820, "%s", "Bad Block\n");
     }
-    if (endAddr == nextAddr) {
-        block->size = next->getSize() + sizeof(CMemBlock) + next->getAlignment() + block->getSize();
-        setFreeBlock(block, block->getPrevBlock(), next->getNextBlock());
-    }
-}
-#else
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void JKRExpHeap::joinTwoBlocks(JKRExpHeap::CMemBlock* param_0) {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRExpHeap/joinTwoBlocks__10JKRExpHeapFPQ210JKRExpHeap9CMemBlock.s"
-}
-#pragma pop
-#endif
 
-/* ############################################################################################## */
-/* 8039CAF0-8039CAF0 029150 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
-#pragma push
-#pragma force_active on
-SECTION_DEAD static char const* const stringBase_8039CB6A =
-    ":::addr %08x: bad heap signature. (%c%c)\n";
-SECTION_DEAD static char const* const stringBase_8039CB94 =
-    ":::addr %08x: bad next pointer (%08x)\nabort\n";
-SECTION_DEAD static char const* const stringBase_8039CBC1 =
-    ":::addr %08x: bad previous pointer (%08x)\n";
-SECTION_DEAD static char const* const stringBase_8039CBEC =
-    ":::addr %08x: bad used list(REV) (%08x)\n";
-SECTION_DEAD static char const* const stringBase_8039CC15 = ":::addr %08x: bad block size (%08x)\n";
-SECTION_DEAD static char const* const stringBase_8039CC3A =
-    ":::bad total memory block size (%08X, %08X)\n";
-SECTION_DEAD static char const* const stringBase_8039CC67 =
-    ":::there is some error in this heap!\n";
-#pragma pop
+    if (endAddr == nextAddr) {
+        block->size = next->size + sizeof(CMemBlock) + next->getAlignment() + block->size;
+        setFreeBlock(block, block->mPrev, next->mNext);
+    }
+}
 
 /* 802D0190-802D03B8 2CAAD0 0228+00 1/0 0/0 0/0 .text            check__10JKRExpHeapFv */
-#ifdef NONMATCHING
 bool JKRExpHeap::check() {
     lock();
     int totalBytes = 0;
     bool ok = true;
-    for (CMemBlock* block = mHeadUsedList; block; block = block->getNextBlock()) {
+    for (CMemBlock* block = mHeadUsedList; block; block = block->mNext) {
         if (!block->isValid()) {
             ok = false;
             JUTWarningConsole_f(":::addr %08x: bad heap signature. (%c%c)\n", block,
-                                block->mMagic >> 8, block->mMagic & 0xff);
+                                JSUHiByte(block->mMagic), JSULoByte(block->mMagic));
         }
-        if (block->getNextBlock()) {
-            if (!block->getNextBlock()->isValid()) {
+
+        if (block->mNext) {
+            if (!block->mNext->isValid()) {
                 ok = false;
                 JUTWarningConsole_f(":::addr %08x: bad next pointer (%08x)\nabort\n", block,
-                                    block->getNextBlock());
+                                    block->mNext);
                 break;
             }
-            if (block->getNextBlock()->getPrevBlock() != block) {
+            if (block->mNext->mPrev != block) {
                 ok = false;
-                JUTWarningConsole_f(":::addr %08x: bad previous pointer (%08x)\n",
-                                    block->getNextBlock(), block->getNextBlock()->getPrevBlock());
+                JUTWarningConsole_f(":::addr %08x: bad previous pointer (%08x)\n", block->mNext,
+                                    block->mNext->mPrev);
             }
         } else {
             if (mTailUsedList != block) {
@@ -933,20 +859,21 @@ bool JKRExpHeap::check() {
                                     mTailUsedList);
             }
         }
-        totalBytes += sizeof(CMemBlock) + block->getSize() + block->getAlignment();
+        totalBytes += sizeof(CMemBlock) + block->size + block->getAlignment();
     }
-    for (CMemBlock* block = mHeadFreeList; block; block = block->getNextBlock()) {
-        totalBytes += block->getSize() + sizeof(CMemBlock);
-        if (block->getNextBlock()) {
-            if (block->getNextBlock()->getPrevBlock() != block) {
+
+    for (CMemBlock* block = mHeadFreeList; block; block = block->mNext) {
+        totalBytes += block->size + sizeof(CMemBlock);
+        if (block->mNext) {
+            if (block->mNext->mPrev != block) {
                 ok = false;
-                JUTWarningConsole_f(":::addr %08x: bad previous pointer (%08x)\n",
-                                    block->getNextBlock(), block->getNextBlock()->getPrevBlock());
+                JUTWarningConsole_f(":::addr %08x: bad previous pointer (%08x)\n", block->mNext,
+                                    block->mNext->mPrev);
             }
-            if ((u32)block + block->getSize() + sizeof(CMemBlock) > (u32)block->getNextBlock()) {
+
+            if ((u32)block + block->size + sizeof(CMemBlock) > (u32)block->mNext) {
                 ok = false;
-                JUTWarningConsole_f(":::addr %08x: bad block size (%08x)\n", block,
-                                    block->getSize());
+                JUTWarningConsole_f(":::addr %08x: bad block size (%08x)\n", block, block->size);
             }
         } else {
             if (mTailFreeList != block) {
@@ -956,9 +883,10 @@ bool JKRExpHeap::check() {
             }
         }
     }
-    if (totalBytes != getSize()) {
+
+    if (totalBytes != mSize) {
         ok = false;
-        JUTWarningConsole_f(":::bad total memory block size (%08X, %08X)\n", getSize(), totalBytes);
+        JUTWarningConsole_f(":::bad total memory block size (%08X, %08X)\n", mSize, totalBytes);
     }
 
     if (!ok) {
@@ -968,16 +896,6 @@ bool JKRExpHeap::check() {
     unlock();
     return ok;
 }
-#else
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm bool JKRExpHeap::check() {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRExpHeap/check__10JKRExpHeapFv.s"
-}
-#pragma pop
-#endif
 
 /* ############################################################################################## */
 /* 8039CAF0-8039CAF0 029150 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
@@ -1011,6 +929,7 @@ SECTION_SDATA2 static f32 lit_1121[1 + 1 /* padding */] = {
 SECTION_SDATA2 static f64 lit_1123 = 4503599627370496.0 /* cast u32 to float */;
 
 /* 802D03B8-802D05CC 2CACF8 0214+00 1/0 0/0 0/0 .text            dump__10JKRExpHeapFv */
+// matches with literals
 #ifdef NONMATCHING
 bool JKRExpHeap::dump() {
     lock();
@@ -1018,39 +937,42 @@ bool JKRExpHeap::dump() {
     u32 usedBytes = 0;
     u32 usedCount = 0;
     u32 freeCount = 0;
+
     JUTReportConsole(" attr  address:   size    gid aln   prev_ptr next_ptr\n");
     JUTReportConsole("(Used Blocks)\n");
     if (!mHeadUsedList) {
         JUTReportConsole(" NONE\n");
     }
-    for (CMemBlock* block = mHeadUsedList; block; block = block->getNextBlock()) {
+
+    for (CMemBlock* block = mHeadUsedList; block; block = block->mNext) {
         if (!block->isValid()) {
             JUTReportConsole_f("xxxxx %08x: --------  --- ---  (-------- --------)\nabort\n",
                                block);
             break;
         }
-        int offset = block->getAlignment();
-        void* content = block->getContent();
-        const char* type = block->_isTempMemBlock() ? " temp" : "alloc";
 
-        JUTReportConsole_f("%s %08x: %08x  %3d %3d  (%08x %08x)\n", type, content, block->getSize(),
-                           block->getGroupId(), offset, block->getPrevBlock(),
-                           block->getNextBlock());
-        usedBytes += sizeof(CMemBlock) + block->getSize() + block->getAlignment();
+        JUTReportConsole_f("%s %08x: %08x  %3d %3d  (%08x %08x)\n",
+                           block->_isTempMemBlock() ? " temp" : "alloc", block->getContent(),
+                           block->size, block->mGroupId, block->getAlignment(), block->mPrev,
+                           block->mNext);
+        usedBytes += sizeof(CMemBlock) + block->size + block->getAlignment();
         usedCount++;
     }
+
     JUTReportConsole("(Free Blocks)\n");
     if (!mHeadFreeList) {
         JUTReportConsole(" NONE\n");
     }
-    for (CMemBlock* block = mHeadFreeList; block; block = block->getNextBlock()) {
+
+    for (CMemBlock* block = mHeadFreeList; block; block = block->mNext) {
         JUTReportConsole_f("%s %08x: %08x  %3d %3d  (%08x %08x)\n", " free", block->getContent(),
-                           block->getSize(), block->getGroupId(), block->getAlignment(),
-                           block->getPrevBlock(), block->getNextBlock());
+                           block->size, block->mGroupId, block->getAlignment(), block->mPrev,
+                           block->mNext);
         freeCount++;
     }
-    float percent = ((float)usedBytes / (float)getSize()) * 100.0f;
-    JUTReportConsole_f("%d / %d bytes (%6.2f%%) used (U:%d F:%d)\n", usedBytes, getSize(), percent,
+
+    float percent = ((float)usedBytes / (float)mSize) * 100.0f;
+    JUTReportConsole_f("%d / %d bytes (%6.2f%%) used (U:%d F:%d)\n", usedBytes, mSize, percent,
                        usedCount, freeCount);
     unlock();
     return result;
@@ -1067,6 +989,7 @@ asm bool JKRExpHeap::dump() {
 #endif
 
 /* 802D05CC-802D0810 2CAF0C 0244+00 1/0 0/0 0/0 .text            dump_sort__10JKRExpHeapFv */
+// using r0 instead of r4
 #ifdef NONMATCHING
 bool JKRExpHeap::dump_sort() {
     lock();
@@ -1076,48 +999,53 @@ bool JKRExpHeap::dump_sort() {
     u32 freeCount = 0;
     JUTReportConsole(" attr  address:   size    gid aln   prev_ptr next_ptr\n");
     JUTReportConsole("(Used Blocks)\n");
+
     if (mHeadUsedList == NULL) {
         JUTReportConsole(" NONE\n");
     } else {
         CMemBlock* var1 = NULL;
         while (true) {
             CMemBlock* block = (CMemBlock*)0xffffffff;
-            for (CMemBlock* iterBlock = mHeadUsedList; iterBlock;
-                 iterBlock = iterBlock->getNextBlock()) {
+            for (CMemBlock* iterBlock = mHeadUsedList; iterBlock; iterBlock = iterBlock->mNext) {
                 if (var1 < iterBlock && iterBlock < block) {
                     block = iterBlock;
                 }
             }
+
             if (block == (CMemBlock*)0xffffffff) {
                 break;
             }
+
             if (!block->isValid()) {
                 JUTReportConsole_f("xxxxx %08x: --------  --- ---  (-------- --------)\nabort\n");
                 break;
             }
+
             int offset = block->getAlignment();
             void* content = block->getContent();
             const char* type = block->_isTempMemBlock() ? " temp" : "alloc";
-            JUTReportConsole_f("%s %08x: %08x  %3d %3d  (%08x %08x)\n", type, content,
-                               block->getSize(), block->getGroupId(), offset, block->getPrevBlock(),
-                               block->getNextBlock());
-            usedBytes += sizeof(CMemBlock) + block->getSize() + block->getAlignment();
+            JUTReportConsole_f("%s %08x: %08x  %3d %3d  (%08x %08x)\n", type, content, block->size,
+                               block->getGroupId(), offset, block->mPrev, block->mNext);
+            usedBytes += sizeof(CMemBlock) + block->size + block->getAlignment();
             usedCount++;
             var1 = block;
         }
     }
+
     JUTReportConsole("(Free Blocks)\n");
     if (mHeadFreeList == NULL) {
         JUTReportConsole(" NONE\n");
     }
-    for (CMemBlock* block = mHeadFreeList; block; block = block->getNextBlock()) {
+
+    for (CMemBlock* block = mHeadFreeList; block; block = block->mNext) {
         JUTReportConsole_f("%s %08x: %08x  %3d %3d  (%08x %08x)\n", " free", block->getContent(),
-                           block->getSize(), block->getGroupId(), block->getAlignment(),
-                           block->getPrevBlock(), block->getNextBlock());
+                           block->size, block->getGroupId(), block->getAlignment(), block->mPrev,
+                           block->mNext);
         freeCount++;
     }
-    float percent = ((float)usedBytes / (float)getSize()) * 100.0f;
-    JUTReportConsole_f("%d / %d bytes (%6.2f%%) used (U:%d F:%d)\n", usedBytes, getSize(), percent,
+
+    float percent = ((float)usedBytes / (float)mSize) * 100.0f;
+    JUTReportConsole_f("%d / %d bytes (%6.2f%%) used (U:%d F:%d)\n", usedBytes, mSize, percent,
                        usedCount, freeCount);
     unlock();
     return result;
@@ -1212,6 +1140,7 @@ void JKRExpHeap::state_register(JKRHeap::TState* p, u32 param_1) const {
         s32 freeSize = const_cast<JKRExpHeap*>(this)->getTotalFreeSize();
         p->mUsedSize = getSize() - freeSize;
     }
+
     u32 checkCode = 0;
     for (CMemBlock* block = mHeadUsedList; block; block = block->getNextBlock()) {
         if (param_1 <= 0xff) {
@@ -1233,9 +1162,11 @@ bool JKRExpHeap::state_compare(JKRHeap::TState const& r1, JKRHeap::TState const&
     if (r1.mCheckCode != r2.mCheckCode) {
         result = false;
     }
+
     if (r1.mUsedSize != r2.mUsedSize) {
         result = false;
     }
+
     return result;
 }
 
@@ -1304,5 +1235,3 @@ SECTION_DEAD static char const* const stringBase_8039CE2A = "| ---- UsedLast\n";
 #pragma force_active on
 SECTION_DEAD static char const* const stringBase_8039CE3B = "+---------------End\n";
 #pragma pop
-
-/* 8039CAF0-8039CAF0 029150 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
diff --git a/libs/JSystem/JKernel/JKRFile.cpp b/libs/JSystem/JKernel/JKRFile.cpp
index 5b492c7fef0..ab585d65868 100644
--- a/libs/JSystem/JKernel/JKRFile.cpp
+++ b/libs/JSystem/JKernel/JKRFile.cpp
@@ -4,14 +4,8 @@
 //
 
 #include "JSystem/JKernel/JKRFile.h"
-#include "dol2asm.h"
-#include "dolphin/types.h"
 #include "dolphin/vi/vi.h"
 
-//
-// Declarations:
-//
-
 /* 802D9518-802D9584 2D3E58 006C+00 0/0 2/2 0/0 .text            read__7JKRFileFPvll */
 s32 JKRFile::read(void* data, s32 size, long offset) {
     while (true) {
diff --git a/libs/JSystem/JKernel/JKRFileCache.cpp b/libs/JSystem/JKernel/JKRFileCache.cpp
index b89aeaefdea..24da35f07f0 100644
--- a/libs/JSystem/JKernel/JKRFileCache.cpp
+++ b/libs/JSystem/JKernel/JKRFileCache.cpp
@@ -9,80 +9,8 @@
 #include "JSystem/JKernel/JKRHeap.h"
 #include "MSL_C/MSL_Common/Src/ctype.h"
 #include "MSL_C/MSL_Common/Src/string.h"
-#include "dol2asm.h"
 #include "global.h"
 
-//
-// Forward References:
-//
-
-extern "C" void mount__12JKRFileCacheFPCcP7JKRHeapPCc();
-extern "C" void __ct__12JKRFileCacheFPCcPCc();
-extern "C" void __dt__12JKRFileCacheFv();
-extern "C" void becomeCurrent__12JKRFileCacheFPCc();
-extern "C" void getResource__12JKRFileCacheFPCc();
-extern "C" void getResource__12JKRFileCacheFUlPCc();
-extern "C" void readResource__12JKRFileCacheFPvUlPCc();
-extern "C" void readResource__12JKRFileCacheFPvUlUlPCc();
-extern "C" void removeResourceAll__12JKRFileCacheFv();
-extern "C" void removeResource__12JKRFileCacheFPv();
-extern "C" void detachResource__12JKRFileCacheFPv();
-extern "C" void getResSize__12JKRFileCacheCFPCv();
-extern "C" void countFile__12JKRFileCacheCFPCc();
-extern "C" void getFirstFile__12JKRFileCacheCFPCc();
-extern "C" void findCacheBlock__12JKRFileCacheCFPCv();
-extern "C" void findCacheBlock__12JKRFileCacheCFUl();
-extern "C" void findFile__12JKRFileCacheCFPcPCc();
-extern "C" void getDvdPathName__12JKRFileCacheCFPCc();
-extern "C" void convStrLower__12JKRFileCacheCFPc();
-extern "C" void __ct__Q212JKRFileCache11CCacheBlockFUlUlPCv();
-extern "C" void getFsResource__12JKRFileCacheFPCc();
-extern "C" void getNameResource__12JKRFileCacheFUlPCc();
-extern "C" void readFsResource__12JKRFileCacheFPvUlPCc();
-extern "C" void readNameResource__12JKRFileCacheFPvUlUlPCc();
-extern "C" extern char const* const JKRFileCache__stringBase0;
-
-//
-// External References:
-//
-
-extern "C" void alloc__7JKRHeapFUliP7JKRHeap();
-extern "C" void alloc__7JKRHeapFUli();
-extern "C" void free__7JKRHeapFPvP7JKRHeap();
-extern "C" void free__7JKRHeapFPv();
-extern "C" void findFromRoot__7JKRHeapFPv();
-extern "C" void* __nw__FUlP7JKRHeapi();
-extern "C" void __dl__FPv();
-extern "C" void __ct__13JKRFileLoaderFv();
-extern "C" void __dt__13JKRFileLoaderFv();
-extern "C" void unmount__13JKRFileLoaderFv();
-extern "C" void __ct__12JKRDvdFinderFPCc();
-extern "C" void read__7JKRFileFPvll();
-extern "C" void __ct__10JKRDvdFileFPCc();
-extern "C" void __dt__10JKRDvdFileFv();
-extern "C" void __ct__10JSUPtrLinkFPv();
-extern "C" void __dt__10JSUPtrLinkFv();
-extern "C" void __dt__10JSUPtrListFv();
-extern "C" void initiate__10JSUPtrListFv();
-extern "C" void append__10JSUPtrListFP10JSUPtrLink();
-extern "C" void prepend__10JSUPtrListFP10JSUPtrLink();
-extern "C" void remove__10JSUPtrListFP10JSUPtrLink();
-extern "C" void _savegpr_26();
-extern "C" void _savegpr_27();
-extern "C" void _savegpr_28();
-extern "C" void _savegpr_29();
-extern "C" void _restgpr_26();
-extern "C" void _restgpr_27();
-extern "C" void _restgpr_28();
-extern "C" void _restgpr_29();
-extern "C" u8 sVolumeList__13JKRFileLoader[12];
-extern "C" u8 sSystemHeap__7JKRHeap[4];
-extern "C" u8 sCurrentVolume__13JKRFileLoader[4 + 4 /* padding */];
-
-//
-// Declarations:
-//
-
 /* 802D49B4-802D4AB4 2CF2F4 0100+00 0/0 2/2 0/0 .text mount__12JKRFileCacheFPCcP7JKRHeapPCc */
 JKRFileCache* JKRFileCache::mount(const char* path, JKRHeap* heap, const char* param_3) {
     if (!path || *path != '/') {
@@ -111,16 +39,6 @@ JKRFileCache* JKRFileCache::mount(const char* path, JKRHeap* heap, const char* p
     return new (heap, 0) JKRFileCache(path, param_3);
 }
 
-/* ############################################################################################## */
-/* 8039D158-8039D158 0297B8 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
-// #pragma push
-// #pragma force_active on
-// SECTION_DEAD static char const* const stringBase_8039D158 = "/";
-// SECTION_DEAD static char const* const stringBase_8039D15A = "dvd";
-// /* @stringBase0 padding */
-// SECTION_DEAD static char const* const pad_8039D15E = "\0";
-// #pragma pop
-
 /* 802D4AB4-802D4C70 2CF3F4 01BC+00 1/1 0/0 0/0 .text            __ct__12JKRFileCacheFPCcPCc */
 JKRFileCache::JKRFileCache(const char* path, const char* volume) : mCacheBlockList() {
     mParentHeap = JKRHeap::findFromRoot(this);
@@ -181,35 +99,23 @@ JKRFileCache::~JKRFileCache() {
 
 /* 802D4D44-802D4DD8 2CF684 0094+00 1/0 0/0 0/0 .text            becomeCurrent__12JKRFileCacheFPCc
  */
-#ifdef NONMATCHING
 bool JKRFileCache::becomeCurrent(const char* path) {
-    char* name = getDvdPathName(path);
-    BOOL result = DVDChangeDir(name);
-    bool didChangeDir = (result != 0);
-    if (didChangeDir) {
-        setCurrentVolume(this);
-        JKRFreeToSysHeap(mCurrentPath);
+    char* dvdPathName = getDvdPathName(path);
 
-        mCurrentPath = name;
-        if (mCurrentPath[1]) {
+    bool result = DVDChangeDir(dvdPathName);
+    if (result) {
+        sCurrentVolume = this;
+        JKRHeap::sSystemHeap->free(mCurrentPath);
+        mCurrentPath = dvdPathName;
+        if (mCurrentPath[1] != '\0') {
             strcat(mCurrentPath, "/");
         }
     } else {
-        JKRFreeToSysHeap(name);
+        JKRHeap::sSystemHeap->free(dvdPathName);
     }
 
-    return didChangeDir;
+    return result;
 }
-#else
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm bool JKRFileCache::becomeCurrent(char const* param_0) {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRFileCache/becomeCurrent__12JKRFileCacheFPCc.s"
-}
-#pragma pop
-#endif
 
 /* 802D4DD8-802D4EDC 2CF718 0104+00 1/0 0/0 0/0 .text            getResource__12JKRFileCacheFPCc */
 void* JKRFileCache::getResource(const char* path) {
@@ -217,11 +123,11 @@ void* JKRFileCache::getResource(const char* path) {
 
     void* buffer = NULL;
     char* name = getDvdPathName(path);
+
     JKRDvdFile dvdFile(name);
     if (dvdFile.isAvailable()) {
         CCacheBlock* cacheBlock = findCacheBlock(dvdFile.getFileID());
         if (!cacheBlock) {
-            // dvdFile.getFileSize() not inlined
             u32 fileSize = dvdFile.getFileInfo()->length;
             u32 alignedSize = ALIGN_NEXT(fileSize, 0x20);
             buffer = JKRAllocFromHeap(mParentHeap, alignedSize, 0x20);
@@ -272,7 +178,6 @@ u32 JKRFileCache::readResource(void* dst, u32 dstLength, const char* path) {
 // will would never exit the loop.
 loop:
     if (dvdFile.isAvailable()) {
-        // dvdFile.getFileSize() not inlined
         u32 fileSize = dvdFile.getFileInfo()->length;
         resourceSize = ALIGN_NEXT(fileSize, 0x20);
         dstLength = ALIGN_PREV(dstLength, 0x20);
@@ -531,5 +436,3 @@ u32 JKRFileCache::readFsResource(void* dst, u32 dstLength, const char* path) {
 u32 JKRFileCache::readNameResource(void* dst, u32 dstLength, u32 type, const char* path) {
     return readResource(dst, dstLength, type, path);
 }
-
-/* 8039D158-8039D158 0297B8 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
diff --git a/libs/JSystem/JKernel/JKRFileFinder.cpp b/libs/JSystem/JKernel/JKRFileFinder.cpp
index 57c7120e718..7835a5fac30 100644
--- a/libs/JSystem/JKernel/JKRFileFinder.cpp
+++ b/libs/JSystem/JKernel/JKRFileFinder.cpp
@@ -6,7 +6,6 @@
 #include "JSystem/JKernel/JKRFileFinder.h"
 #include "JSystem/JKernel/JKRArchive.h"
 #include "dol2asm.h"
-#include "dolphin/types.h"
 
 //
 // Forward References:
diff --git a/libs/JSystem/JKernel/JKRFileLoader.cpp b/libs/JSystem/JKernel/JKRFileLoader.cpp
index 7570bec0161..c019a58b0c5 100644
--- a/libs/JSystem/JKernel/JKRFileLoader.cpp
+++ b/libs/JSystem/JKernel/JKRFileLoader.cpp
@@ -180,14 +180,9 @@ SECTION_DEAD static char const* const pad_8039D152 = "\0\0\0\0\0";
 SECTION_SDATA static char rootPath[2] = "/";
 
 /* 802D44C4-802D45A0 2CEE04 00DC+00 1/1 0/0 0/0 .text fetchVolumeName__13JKRFileLoaderFPclPCc */
-// matches, but lbl_804508C0 is accessed through r13
+// matches, but rootPath is accessed through r13
 #ifdef NONMATCHING
 const char* JKRFileLoader::fetchVolumeName(char* buffer, long bufferSize, const char* path) {
-    // lbl_803D2D18 = MSL_C::__lower_map
-    // lbl_8039D150 = JKernel::@stringBase0 "/"
-    // lbl_804508C0 = JKernel::rootPath$2498 "/"
-    // lbl_803D2D18 = MSL_C::__lower_map
-
     if (strcmp(path, "/") == 0) {
         strcpy(buffer, rootPath);
         return rootPath;
@@ -228,5 +223,3 @@ asm const char* JKRFileLoader::fetchVolumeName(char* param_0, s32 param_1, char
 }
 #pragma pop
 #endif
-
-/* 8039D150-8039D150 0297B0 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
diff --git a/libs/JSystem/JKernel/JKRHeap.cpp b/libs/JSystem/JKernel/JKRHeap.cpp
index 71455819d9b..edc5fd935a0 100644
--- a/libs/JSystem/JKernel/JKRHeap.cpp
+++ b/libs/JSystem/JKernel/JKRHeap.cpp
@@ -1,99 +1,25 @@
-//
-// Generated By: dol2asm
-// Translation Unit: JKRHeap
-//
+/**
+ * JKRHeap.cpp
+ * JSystem Heap Framework
+ */
 
 #include "JSystem/JKernel/JKRHeap.h"
 #include "JSystem/JUtility/JUTAssert.h"
 #include "JSystem/JUtility/JUTException.h"
-#include "dol2asm.h"
-#include "global.h"
 
 //
 // Forward References:
 //
 
-extern "C" void __ct__7JKRHeapFPvUlP7JKRHeapb();
-extern "C" void __dt__7JKRHeapFv();
-extern "C" void initArena__7JKRHeapFPPcPUli();
-extern "C" void becomeSystemHeap__7JKRHeapFv();
-extern "C" void becomeCurrentHeap__7JKRHeapFv();
-extern "C" void destroy__7JKRHeapFv();
-extern "C" void alloc__7JKRHeapFUliP7JKRHeap();
-extern "C" void alloc__7JKRHeapFUli();
-extern "C" void free__7JKRHeapFPvP7JKRHeap();
-extern "C" void free__7JKRHeapFPv();
-extern "C" void callAllDisposer__7JKRHeapFv();
-extern "C" void freeAll__7JKRHeapFv();
-extern "C" void freeTail__7JKRHeapFv();
-extern "C" void resize__7JKRHeapFPvUlP7JKRHeap();
-extern "C" void resize__7JKRHeapFPvUl();
-extern "C" void getSize__7JKRHeapFPvP7JKRHeap();
-extern "C" void getSize__7JKRHeapFPv();
 extern "C" void getFreeSize__7JKRHeapFv();
 extern "C" void getMaxFreeBlock__7JKRHeapFv();
-extern "C" void getTotalFreeSize__7JKRHeapFv();
-extern "C" void changeGroupID__7JKRHeapFUc();
-extern "C" void getMaxAllocatableSize__7JKRHeapFi();
-extern "C" void findFromRoot__7JKRHeapFPv();
-extern "C" void find__7JKRHeapCFPv();
-extern "C" void findAllHeap__7JKRHeapCFPv();
-extern "C" void dispose_subroutine__7JKRHeapFUlUl();
-extern "C" void dispose__7JKRHeapFPvUl();
-extern "C" void dispose__7JKRHeapFPvPv();
-extern "C" void dispose__7JKRHeapFv();
-extern "C" void copyMemory__7JKRHeapFPvPvUl();
-extern "C" void JKRDefaultMemoryErrorRoutine__FPvUli();
-extern "C" void setErrorFlag__7JKRHeapFb();
-extern "C" void setErrorHandler__7JKRHeapFPFPvUli_v();
-extern "C" void isSubHeap__7JKRHeapCFP7JKRHeap();
-extern "C" void* __nw__FUl();
-extern "C" void* __nw__FUli();
-extern "C" void* __nw__FUlP7JKRHeapi();
-extern "C" void* __nwa__FUl();
-extern "C" void* __nwa__FUli();
-extern "C" void* __nwa__FUlP7JKRHeapi();
-extern "C" void __dl__FPv();
-extern "C" void __dla__FPv();
-extern "C" void state_register__7JKRHeapCFPQ27JKRHeap6TStateUl();
-extern "C" void state_compare__7JKRHeapCFRCQ27JKRHeap6TStateRCQ27JKRHeap6TState();
-extern "C" void state_dump__7JKRHeapCFRCQ27JKRHeap6TState();
-extern "C" bool do_changeGroupID__7JKRHeapFUc();
-extern "C" bool do_getCurrentGroupId__7JKRHeapFv();
-extern "C" extern char const* const JKRHeap__stringBase0;
-extern "C" u8 sSystemHeap__7JKRHeap[4];
-extern "C" u8 sCurrentHeap__7JKRHeap[4];
-extern "C" u8 sRootHeap__7JKRHeap[4];
-extern "C" u8 mErrorHandler__7JKRHeap[4];
-extern "C" u8 mCodeStart__7JKRHeap[4];
-extern "C" u8 mCodeEnd__7JKRHeap[4];
-extern "C" u8 mUserRamStart__7JKRHeap[4];
-extern "C" u8 mUserRamEnd__7JKRHeap[4];
-extern "C" u8 mMemorySize__7JKRHeap[4];
 
 //
 // External References:
 //
 
-extern "C" bool dump_sort__7JKRHeapFv();
-extern "C" void __ct__11JKRDisposerFv();
-extern "C" void __dt__11JKRDisposerFv();
-extern "C" void __ct__10JSUPtrLinkFPv();
-extern "C" void __dt__10JSUPtrLinkFv();
-extern "C" void __dt__10JSUPtrListFv();
-extern "C" void initiate__10JSUPtrListFv();
-extern "C" void append__10JSUPtrListFP10JSUPtrLink();
-extern "C" void remove__10JSUPtrListFP10JSUPtrLink();
-extern "C" void panic_f__12JUTExceptionFPCciPCce();
-extern "C" void _savegpr_26();
-extern "C" void _savegpr_27();
-extern "C" void _savegpr_28();
 extern "C" void _savegpr_29();
-extern "C" void _restgpr_26();
-extern "C" void _restgpr_27();
-extern "C" void _restgpr_28();
 extern "C" void _restgpr_29();
-extern "C" void* __vt__7JKRHeap;
 
 //
 // Declarations:
@@ -131,13 +57,14 @@ JKRHeap::JKRHeap(void* data, u32 size, JKRHeap* parent, bool errorFlag)
         if (getSystemHeap() == getRootHeap()) {
             becomeSystemHeap();
         }
+
         if (getCurrentHeap() == getRootHeap()) {
             becomeCurrentHeap();
         }
     }
 
     mErrorFlag = errorFlag;
-    if ((mErrorFlag == true) && (mErrorHandler == NULL)) {
+    if (mErrorFlag == true && mErrorHandler == NULL) {
         mErrorHandler = JKRDefaultMemoryErrorRoutine;
     }
 
@@ -147,45 +74,16 @@ JKRHeap::JKRHeap(void* data, u32 size, JKRHeap* parent, bool errorFlag)
 }
 
 /* 802CE264-802CE378 2C8BA4 0114+00 1/0 3/3 0/0 .text            __dt__7JKRHeapFv */
-// using the wrong register for storing the results
-#ifdef NONMATCHING
 JKRHeap::~JKRHeap() {
-    JSUTree<JKRHeap>* parent = mChildTree.getParent();
-    parent->removeChild(&mChildTree);
+    mChildTree.getParent()->removeChild(&mChildTree);
+    JSUTree<JKRHeap>* nextRootHeap = sRootHeap->mChildTree.getFirstChild();
 
-    JSUTree<JKRHeap>* nextRootHeap = getRootHeap()->mChildTree.getFirstChild();
+    if (sCurrentHeap == this)
+        sCurrentHeap = !nextRootHeap ? sRootHeap : nextRootHeap->getObject();
 
-    JKRHeap* rootHeap = getRootHeap();
-    JKRHeap* currentHeap = getCurrentHeap();
-    if (currentHeap == this) {
-        if (!nextRootHeap) {
-            currentHeap = rootHeap;
-        } else {
-            currentHeap = nextRootHeap->getObject();
-        }
-    }
-    setCurrentHeap(currentHeap);
-
-    JKRHeap* systemHeap = getSystemHeap();
-    if (systemHeap == this) {
-        if (!nextRootHeap) {
-            systemHeap = rootHeap;
-        } else {
-            systemHeap = nextRootHeap->getObject();
-        }
-    }
-    setSystemHeap(systemHeap);
+    if (sSystemHeap == this)
+        sSystemHeap = !nextRootHeap ? sRootHeap : nextRootHeap->getObject();
 }
-#else
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm JKRHeap::~JKRHeap() {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRHeap/__dt__7JKRHeapFv.s"
-}
-#pragma pop
-#endif
 
 /* ############################################################################################## */
 /* 80451384-80451388 000884 0004+00 1/1 1/1 0/0 .sbss            mCodeStart__7JKRHeap */
@@ -205,42 +103,46 @@ u32 JKRHeap::mMemorySize;
 
 /* 802CE378-802CE428 2C8CB8 00B0+00 0/0 1/1 0/0 .text            initArena__7JKRHeapFPPcPUli */
 bool JKRHeap::initArena(char** memory, u32* size, int maxHeaps) {
-    u32 ram_start;
-    u32 ram_end;
-    void* ram;
+    void* ram_start;
+    void* ram_end;
+    void* arenaStart;
 
-    void* low = OSGetArenaLo();
-    void* high = OSGetArenaHi();
-    if (low == high)
+    void* arenaLo = OSGetArenaLo();
+    void* arenaHi = OSGetArenaHi();
+    if (arenaLo == arenaHi)
         return false;
 
-    ram = OSInitAlloc(low, high, maxHeaps);
-    ram_start = ALIGN_NEXT((u32)ram, 0x20);
-    ram_end = ALIGN_PREV((u32)high, 0x20);
-    GLOBAL_MEMORY* globalMemory = (GLOBAL_MEMORY*)OSPhysicalToCached(0);
-    mCodeStart = globalMemory;
-    mCodeEnd = (void*)ram_start;
-    mUserRamStart = (void*)ram_start;
-    mUserRamEnd = (void*)ram_end;
-    mMemorySize = globalMemory->memory_size;
-    OSSetArenaLo((void*)ram_end);
-    OSSetArenaHi((void*)ram_end);
+    arenaStart = OSInitAlloc(arenaLo, arenaHi, maxHeaps);
+    ram_start = (void*)ALIGN_NEXT((u32)arenaStart, 0x20);
+    ram_end = (void*)ALIGN_PREV((u32)arenaHi, 0x20);
+
+    GLOBAL_MEMORY* codeStart = (GLOBAL_MEMORY*)OSPhysicalToCached(0);
+    mCodeStart = codeStart;
+    mCodeEnd = ram_start;
+
+    mUserRamStart = ram_start;
+    mUserRamEnd = ram_end;
+    mMemorySize = codeStart->memory_size;
+
+    OSSetArenaLo(ram_end);
+    OSSetArenaHi(ram_end);
+
     *memory = (char*)ram_start;
-    *size = ram_end - ram_start;
+    *size = (u32)ram_end - (u32)ram_start;
     return true;
 }
 
 /* 802CE428-802CE438 2C8D68 0010+00 1/1 0/0 0/0 .text            becomeSystemHeap__7JKRHeapFv */
 JKRHeap* JKRHeap::becomeSystemHeap() {
-    JKRHeap* prev = JKRHeap::getSystemHeap();
-    setSystemHeap(this);
+    JKRHeap* prev = sSystemHeap;
+    sSystemHeap = this;
     return prev;
 }
 
 /* 802CE438-802CE448 2C8D78 0010+00 1/1 22/22 1/1 .text            becomeCurrentHeap__7JKRHeapFv */
 JKRHeap* JKRHeap::becomeCurrentHeap() {
-    JKRHeap* prev = getCurrentHeap();
-    setCurrentHeap(this);
+    JKRHeap* prev = sCurrentHeap;
+    sCurrentHeap = this;
     return prev;
 }
 
@@ -255,8 +157,8 @@ void* JKRHeap::alloc(u32 size, int alignment, JKRHeap* heap) {
         return heap->alloc(size, alignment);
     }
 
-    if (getCurrentHeap() != NULL) {
-        return getCurrentHeap()->alloc(size, alignment);
+    if (sCurrentHeap != NULL) {
+        return sCurrentHeap->alloc(size, alignment);
     }
 
     return NULL;
@@ -284,6 +186,16 @@ void JKRHeap::free(void* ptr) {
 }
 
 /* 802CE574-802CE5CC 2C8EB4 0058+00 1/0 5/2 0/0 .text            callAllDisposer__7JKRHeapFv */
+// missing stack var
+#ifdef NONMATCHING
+void JKRHeap::callAllDisposer() {
+    JSUListIterator<JKRDisposer> iterator;
+
+    while (iterator = mDisposerList.getFirst(), iterator != mDisposerList.getEnd()) {
+        iterator->~JKRDisposer();
+    }
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -292,6 +204,7 @@ asm void JKRHeap::callAllDisposer() {
 #include "asm/JSystem/JKernel/JKRHeap/callAllDisposer__7JKRHeapFv.s"
 }
 #pragma pop
+#endif
 
 /* 802CE5CC-802CE5F8 2C8F0C 002C+00 0/0 12/12 0/0 .text            freeAll__7JKRHeapFv */
 void JKRHeap::freeAll() {
@@ -351,8 +264,8 @@ s32 JKRHeap::getTotalFreeSize() {
 }
 
 /* 802CE7B0-802CE7DC 2C90F0 002C+00 0/0 1/1 0/0 .text            changeGroupID__7JKRHeapFUc */
-s32 JKRHeap::changeGroupID(u8 param_1) {
-    return do_changeGroupID(param_1);
+s32 JKRHeap::changeGroupID(u8 groupID) {
+    return do_changeGroupID(groupID);
 }
 
 /* 802CE7DC-802CE83C 2C911C 0060+00 0/0 2/2 0/0 .text            getMaxAllocatableSize__7JKRHeapFi
@@ -381,16 +294,15 @@ asm u32 JKRHeap::getMaxAllocatableSize(int param_0) {
 
 /* 802CE83C-802CE894 2C917C 0058+00 3/3 8/8 0/0 .text            findFromRoot__7JKRHeapFPv */
 JKRHeap* JKRHeap::findFromRoot(void* ptr) {
-    JKRHeap* rootHeap = getRootHeap();
-    if (rootHeap == NULL) {
+    if (sRootHeap == NULL) {
         return NULL;
     }
 
-    if (rootHeap->getStartAddr() <= ptr && ptr < rootHeap->getEndAddr()) {
-        return rootHeap->find(ptr);
+    if (sRootHeap->mStart <= ptr && ptr < sRootHeap->mEnd) {
+        return sRootHeap->find(ptr);
     }
 
-    return rootHeap->findAllHeap(ptr);
+    return sRootHeap->findAllHeap(ptr);
 }
 
 /* 802CE894-802CE93C 2C91D4 00A8+00 1/1 1/1 0/0 .text            find__7JKRHeapCFPv */
@@ -415,21 +327,20 @@ JKRHeap* JKRHeap::find(void* memory) const {
 
 /* 802CE93C-802CE9E4 2C927C 00A8+00 1/1 0/0 0/0 .text            findAllHeap__7JKRHeapCFPv */
 JKRHeap* JKRHeap::findAllHeap(void* ptr) const {
-    const JSUTree<JKRHeap>& tree = mChildTree;
-    if (tree.getNumChildren() != 0) {
-        JSUTreeIterator<JKRHeap> iterator;
-        for (iterator = tree.getFirstChild(); iterator != tree.getEndChild(); iterator++) {
-            JKRHeap* child = iterator.getObject();
-            JKRHeap* result = child->findAllHeap(ptr);
+    if (mChildTree.getNumChildren() != 0) {
+        for (JSUTreeIterator<JKRHeap> iterator(mChildTree.getFirstChild());
+             iterator != mChildTree.getEndChild(); ++iterator)
+        {
+            JKRHeap* result = iterator->findAllHeap(ptr);
+
             if (result) {
                 return result;
             }
         }
     }
 
-    if (getStartAddr() <= ptr && ptr < getEndAddr()) {
-        // todo: not sure about this... casting away const for now.
-        return (JKRHeap*)this;
+    if (mStart <= ptr && ptr < mEnd) {
+        return const_cast<JKRHeap*>(this);
     }
 
     return NULL;
@@ -441,6 +352,7 @@ void JKRHeap::dispose_subroutine(u32 begin, u32 end) {
     JSUListIterator<JKRDisposer> last_iterator;
     JSUListIterator<JKRDisposer> next_iterator;
     JSUListIterator<JKRDisposer> iterator;
+
     for (iterator = mDisposerList.getFirst(); iterator != mDisposerList.getEnd();
          iterator = next_iterator)
     {
@@ -448,6 +360,7 @@ void JKRHeap::dispose_subroutine(u32 begin, u32 end) {
 
         if ((void*)begin <= disposer && disposer < (void*)end) {
             disposer->~JKRDisposer();
+
             if (last_iterator == NULL) {
                 next_iterator = mDisposerList.getFirst();
             } else {
@@ -513,7 +426,7 @@ void JKRHeap::copyMemory(void* dst, void* src, u32 size) {
 
 /* 802CEB40-802CEB78 2C9480 0038+00 2/2 0/0 0/0 .text JKRDefaultMemoryErrorRoutine__FPvUli */
 void JKRDefaultMemoryErrorRoutine(void* heap, u32 size, int alignment) {
-    JUTException::panic_f("JKRHeap.cpp", 0x33f, "%s", "abort\n");
+    JUTException::panic_f(__FILE__, 831, "%s", "abort\n");
 }
 
 /* 802CEB78-802CEB88 2C94B8 0010+00 0/0 2/2 0/0 .text            setErrorFlag__7JKRHeapFb */
@@ -541,17 +454,16 @@ bool JKRHeap::isSubHeap(JKRHeap* heap) const {
     if (!heap)
         return false;
 
-    const JSUTree<JKRHeap>& tree = mChildTree;
-    if (tree.getNumChildren() != 0) {
+    if (mChildTree.getNumChildren() != 0) {
         JSUTreeIterator<JKRHeap> iterator;
-        for (iterator = tree.getFirstChild(); iterator != tree.getEndChild(); ++iterator) {
-            JKRHeap* child = iterator.getObject();
-            if (child == heap) {
+        for (iterator = mChildTree.getFirstChild(); iterator != mChildTree.getEndChild();
+             ++iterator)
+        {
+            if (iterator.getObject() == heap) {
                 return true;
             }
 
-            bool is_sub_heap = child->isSubHeap(heap);
-            if (is_sub_heap) {
+            if (iterator.getObject()->isSubHeap(heap)) {
                 return true;
             }
         }
@@ -603,14 +515,14 @@ void operator delete[](void* ptr) {
 /* 802CED84-802CED88 2C96C4 0004+00 1/0 1/0 0/0 .text
  * state_register__7JKRHeapCFPQ27JKRHeap6TStateUl               */
 void JKRHeap::state_register(JKRHeap::TState* p, u32 id) const {
-    JUT_ASSERT("JKRHeap.cpp", 0x4bd, p != 0);
-    JUT_ASSERT("JKRHeap.cpp", 0x4be, p->getHeap() == this);
+    JUT_ASSERT(__FILE__, 1213, p != 0);
+    JUT_ASSERT(__FILE__, 1214, p->getHeap() == this);
 }
 
 /* 802CED88-802CEDA0 2C96C8 0018+00 1/0 1/0 0/0 .text
  * state_compare__7JKRHeapCFRCQ27JKRHeap6TStateRCQ27JKRHeap6TState */
 bool JKRHeap::state_compare(JKRHeap::TState const& r1, JKRHeap::TState const& r2) const {
-    JUT_ASSERT("JKRHeap.cpp", 0x4c6, r1.getHeap() == r2.getHeap());
+    JUT_ASSERT(__FILE__, 1222, r1.getHeap() == r2.getHeap());
     return r1.getCheckCode() == r2.getCheckCode();
 }
 
@@ -630,5 +542,3 @@ s32 JKRHeap::do_changeGroupID(u8 param_0) {
 u8 JKRHeap::do_getCurrentGroupId() {
     return 0;
 }
-
-/* 8039CAD8-8039CAD8 029138 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
diff --git a/libs/JSystem/JKernel/JKRMemArchive.cpp b/libs/JSystem/JKernel/JKRMemArchive.cpp
index 4d834d4dba6..5ec3502403c 100644
--- a/libs/JSystem/JKernel/JKRMemArchive.cpp
+++ b/libs/JSystem/JKernel/JKRMemArchive.cpp
@@ -9,85 +9,6 @@
 #include "JSystem/JUtility/JUTException.h"
 #include "MSL_C/MSL_Common/Src/string.h"
 #include "dol2asm.h"
-#include "dolphin/types.h"
-
-//
-// Types:
-//
-
-// struct JUTException {
-//     /* 802E21FC */ void panic_f(char const*, int, char const*, ...);
-// };
-
-// struct JSUPtrLink {};
-
-// struct JSUPtrList {
-//     /* 802DBFF0 */ void prepend(JSUPtrLink*);
-//     /* 802DC15C */ void remove(JSUPtrLink*);
-// };
-
-// struct JKRMemBreakFlag {};
-
-// struct JKRArchive {
-//     struct EMountDirection {};
-
-//     struct SDIFileEntry {};
-
-//     struct EMountMode {};
-
-//     /* 802D5A38 */ void becomeCurrent(char const*);
-//     /* 802D5C64 */ void getResource(u32, char const*);
-//     /* 802D5BE8 */ void getResource(char const*);
-//     /* 802D5D8C */ void readResource(void*, u32, u32, char const*);
-//     /* 802D5E30 */ void readResource(void*, u32, char const*);
-//     /* 802D609C */ void detachResource(void*);
-//     /* 802D60D8 */ void getResSize(void const*) const;
-//     /* 802D6150 */ void countFile(char const*) const;
-//     /* 802D61B0 */ void getFirstFile(char const*) const;
-//     /* 802D6294 */ JKRArchive(s32, JKRArchive::EMountMode);
-//     /* 802D6334 */ ~JKRArchive();
-//     /* 802D6734 */ void findPtrResource(void const*) const;
-//     /* 802D693C */ void setExpandSize(JKRArchive::SDIFileEntry*, u32);
-//     /* 802D6978 */ void getExpandSize(JKRArchive::SDIFileEntry*) const;
-// };
-
-// struct JKRMemArchive {
-//     /* 802D6A6C */ JKRMemArchive(void*, u32, JKRMemBreakFlag);
-//     /* 802D69B8 */ JKRMemArchive(s32, JKRArchive::EMountDirection);
-//     /* 802D6B24 */ ~JKRMemArchive();
-//     /* 802D6BCC */ void open(s32, JKRArchive::EMountDirection);
-//     /* 802D6D30 */ void open(void*, u32, JKRMemBreakFlag);
-//     /* 802D6E10 */ void fetchResource(void*, u32, JKRArchive::SDIFileEntry*, u32*);
-//     /* 802D6DDC */ void fetchResource(JKRArchive::SDIFileEntry*, u32*);
-//     /* 802D6ED0 */ void removeResourceAll();
-//     /* 802D6F20 */ void removeResource(void*);
-//     /* 802D6F5C */ void fetchResource_subroutine(u8*, u32, u8*, u32, int);
-//     /* 802D7030 */ void getExpandedResSize(void const*) const;
-// };
-
-// struct JKRHeap {
-//     /* 802CE500 */ void free(void*, JKRHeap*);
-//     /* 802CE83C */ void findFromRoot(void*);
-// };
-
-// struct JKRFileLoader {
-//     /* 802D41D4 */ void unmount();
-
-//     static u8 sVolumeList[12];
-// };
-
-// struct JKRExpandSwitch {};
-
-// struct JKRDvdRipper {
-//     struct EAllocDirection {};
-
-//     /* 802D9C54 */ void loadToMainRAM(s32, u8*, JKRExpandSwitch, u32, JKRHeap*,
-//                                       JKRDvdRipper::EAllocDirection, u32, int*, u32*);
-// };
-
-// struct JKRDecomp {
-//     /* 802DB988 */ void orderSync(u8*, u8*, u32, u32);
-// };
 
 //
 // Forward References:
@@ -209,16 +130,16 @@ bool JKRMemArchive::open(long entryNum, JKRArchive::EMountDirection mountDirecti
     if (mMountDirection == JKRArchive::MOUNT_DIRECTION_HEAD) {
         u32 loadedSize;
         mArcHeader = (SArcHeader*)JKRDvdRipper::loadToMainRAM(
-            entryNum, NULL, EXPAND_SWITCH_UNKNOWN1, 0, mHeap, JKRDvdRipper::ALLOC_DIRECTION_FORWARD, 0,
-            &mCompression, &loadedSize);
+            entryNum, NULL, EXPAND_SWITCH_UNKNOWN1, 0, mHeap, JKRDvdRipper::ALLOC_DIRECTION_FORWARD,
+            0, &mCompression, &loadedSize);
         if (mArcHeader) {
             DCInvalidateRange(mArcHeader, loadedSize);
         }
     } else {
         u32 loadedSize;
         mArcHeader = (SArcHeader*)JKRDvdRipper::loadToMainRAM(
-            entryNum, NULL, EXPAND_SWITCH_UNKNOWN1, 0, mHeap, JKRDvdRipper::ALLOC_DIRECTION_BACKWARD, 0,
-            &mCompression, &loadedSize);
+            entryNum, NULL, EXPAND_SWITCH_UNKNOWN1, 0, mHeap,
+            JKRDvdRipper::ALLOC_DIRECTION_BACKWARD, 0, &mCompression, &loadedSize);
         if (mArcHeader) {
             DCInvalidateRange(mArcHeader, loadedSize);
         }
@@ -354,17 +275,6 @@ bool JKRMemArchive::removeResource(void* resource) {
     return true;
 }
 
-/* ############################################################################################## */
-/* 8039D160-8039D160 0297C0 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
-// #pragma push
-// #pragma force_active on
-// SECTION_DEAD static char const* const stringBase_8039D160 = "JKRMemArchive.cpp";
-// SECTION_DEAD static char const* const stringBase_8039D172 = "%s";
-// SECTION_DEAD static char const* const stringBase_8039D175 = "??? bad sequence\n";
-// /* @stringBase0 padding */
-// SECTION_DEAD static char const* const pad_8039D187 = "";
-// #pragma pop
-
 /* 802D6F5C-802D7030 2D189C 00D4+00 1/1 1/1 0/0 .text
  * fetchResource_subroutine__13JKRMemArchiveFPUcUlPUcUli        */
 u32 JKRMemArchive::fetchResource_subroutine(u8* src, u32 srcLength, u8* dst, u32 dstLength,
@@ -390,7 +300,7 @@ u32 JKRMemArchive::fetchResource_subroutine(u8* src, u32 srcLength, u8* dst, u32
         return srcLength;
 
     default: {
-        JUTException::panic_f("JKRMemArchive.cpp", 0x2d3, "%s", "??? bad sequence\n");
+        JUTException::panic_f(__FILE__, 723, "%s", "??? bad sequence\n");
     } break;
     }
 
@@ -409,5 +319,3 @@ u32 JKRMemArchive::getExpandedResSize(const void* resource) const {
         return JKRDecompExpandSize((SArcHeader*)resource);
     }
 }
-
-/* 8039D160-8039D160 0297C0 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
diff --git a/libs/JSystem/JKernel/JKRSolidHeap.cpp b/libs/JSystem/JKernel/JKRSolidHeap.cpp
index ab4185671ad..dc64429e7b6 100644
--- a/libs/JSystem/JKernel/JKRSolidHeap.cpp
+++ b/libs/JSystem/JKernel/JKRSolidHeap.cpp
@@ -149,8 +149,8 @@ void* JKRSolidHeap::do_alloc(u32 size, int alignment) {
     // TODO(Julgodis): JUTAssertion::setConfirmMessage
     if (alignment != 0) {
         int u = abs(alignment);
-        JUT_ASSERT("JKRSolidHeap.cpp", 0xdb, u < 0x80);
-        JUT_ASSERT("JKRSolidHeap.cpp", 0xdc, JGadget::binary::isPower2(u));
+        JUT_ASSERT(__FILE__, 0xdb, u < 0x80);
+        JUT_ASSERT(__FILE__, 0xdc, JGadget::binary::isPower2(u));
     }
 #endif
 
@@ -318,8 +318,8 @@ bool JKRSolidHeap::dump(void) {
 // full match expect using the wrong register
 #ifdef NONMATCHING
 void JKRSolidHeap::state_register(JKRHeap::TState* p, u32 id) const {
-    JUT_ASSERT("JKRSolidHeap.cpp", 0x25c, p != 0);
-    JUT_ASSERT("JKRSolidHeap.cpp", 0x25d, p->getHeap() == this);
+    JUT_ASSERT(__FILE__, 0x25c, p != 0);
+    JUT_ASSERT(__FILE__, 0x25d, p->getHeap() == this);
 
     getState_(p);
     setState_u32ID_(p, id);
@@ -340,7 +340,7 @@ asm void JKRSolidHeap::state_register(JKRHeap::TState* param_0, u32 param_1) con
 /* 802D1258-802D1288 2CBB98 0030+00 1/0 0/0 0/0 .text
  * state_compare__12JKRSolidHeapCFRCQ27JKRHeap6TStateRCQ27JKRHeap6TState */
 bool JKRSolidHeap::state_compare(JKRHeap::TState const& r1, JKRHeap::TState const& r2) const {
-    JUT_ASSERT("JKRSolidHeap.cpp", 0x278, r1.getHeap() == r2.getHeap());
+    JUT_ASSERT(__FILE__, 632, r1.getHeap() == r2.getHeap());
 
     bool result = true;
     if (r1.getCheckCode() != r2.getCheckCode()) {
@@ -373,5 +373,3 @@ void* JKRSolidHeap::do_getMaxFreeBlock(void) {
 s32 JKRSolidHeap::do_getTotalFreeSize(void) {
     return getFreeSize();
 }
-
-/* 8039CE50-8039CE50 0294B0 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
diff --git a/libs/JSystem/JKernel/JKRThread.cpp b/libs/JSystem/JKernel/JKRThread.cpp
index a59da1fc76a..7235ed8799b 100644
--- a/libs/JSystem/JKernel/JKRThread.cpp
+++ b/libs/JSystem/JKernel/JKRThread.cpp
@@ -6,29 +6,9 @@
 #include "JSystem/JKernel/JKRThread.h"
 #include "JSystem/JKernel/JKRExpHeap.h"
 #include "JSystem/JUtility/JUTAssert.h"
+#include "JSystem/JUtility/JUTConsole.h"
 #include "MSL_C/MSL_Common/Src/printf.h"
 #include "dol2asm.h"
-#include "dolphin/types.h"
-
-//
-// Types:
-//
-
-struct JUTConsole {
-    /* 802E75EC */ void clear();
-    /* 802E7BB8 */ void print_f(char const*, ...);
-    /* 802E7C38 */ void print(char const*);
-};
-
-//
-// External References:
-//
-
-extern "C" void JUTWarningConsole(const char*);
-
-//
-// Declarations:
-//
 
 /* 8043428C-80434298 060FAC 000C+00 5/6 0/0 0/0 .bss             sThreadList__9JKRThread */
 JSUList<JKRThread> JKRThread::sThreadList(0);
@@ -164,7 +144,7 @@ JKRThreadSwitch::JKRThreadSwitch(JKRHeap* param_0) {
 /* 802D1A14-802D1A70 2CC354 005C+00 0/0 1/1 0/0 .text createManager__15JKRThreadSwitchFP7JKRHeap
  */
 JKRThreadSwitch* JKRThreadSwitch::createManager(JKRHeap* heap) {
-    JUT_ASSERT("JKRThread.cpp", 0x157, sManager == 0);
+    JUT_ASSERT(__FILE__, 343, sManager == 0);
 
     if (!heap) {
         heap = JKRGetCurrentHeap();
@@ -245,8 +225,7 @@ void JKRThreadSwitch::callback(OSThread* current, OSThread* next) {
                 } else {
                     switch (thread->getCurrentHeapError()) {
                     case 0:
-                        JUT_PANIC("JKRThread.cpp", 0x1fc,
-                                  "JKRThreadSwitch: currentHeap destroyed.");
+                        JUT_PANIC(__FILE__, 508, "JKRThreadSwitch: currentHeap destroyed.");
                         break;
                     case 1:
                         JUTWarningConsole("JKRThreadSwitch: currentHeap destroyed.\n");
@@ -345,13 +324,6 @@ void JKRThreadSwitch::draw(JKRThreadName_* thread_name_list) {
 /* 802D1E4C-802D1E94 2CC78C 0048+00 1/0 0/0 0/0 .text            __dt__15JKRThreadSwitchFv */
 JKRThreadSwitch::~JKRThreadSwitch() {}
 
-/* ############################################################################################## */
-/* 80434298-804342A4 060FB8 000C+00 0/1 0/0 0/0 .bss             @989 */
-// #pragma push
-// #pragma force_active on
-// static u8 lit_989[12];
-// #pragma pop
-
 /* 804342A4-804342B0 060FC4 000C+00 0/1 0/0 0/0 .bss             sTaskList__7JKRTask */
 #pragma push
 #pragma force_active on
@@ -364,5 +336,3 @@ JSUList<JKRTask> JKRTask::sTaskList;
 #pragma force_active on
 u8 JKRTask::sEndMesgQueue[32];
 #pragma pop
-
-/* 8039CFA8-8039CFA8 029608 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
diff --git a/libs/JSystem/JUtility/JUTConsole.cpp b/libs/JSystem/JUtility/JUTConsole.cpp
index 7c3a5d3dfd6..9cba998b838 100644
--- a/libs/JSystem/JUtility/JUTConsole.cpp
+++ b/libs/JSystem/JUtility/JUTConsole.cpp
@@ -501,5 +501,3 @@ void JUTWarningConsole_f(const char* fmt, ...) {
 void JUTWarningConsole(const char* message) {
     JUTReportConsole_f("%s", message);
 }
-
-/* 8039D9A8-8039D9A8 02A008 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */