Merge remote-tracking branch 'upstream/main'

13 files changed, 1979 insertions, 345 deletions

diff --git a/src/DynamicLink.cpp b/src/DynamicLink.cpp
index 0bc3cc71..a9d3cd5b 100644
--- a/src/DynamicLink.cpp
+++ b/src/DynamicLink.cpp
@@ -13,14 +13,9 @@
 #include "MSL_C/stdio.h"
 #include "REL/executor.h"
 #include "m_Do/m_Do_dvd_thread.h"
+#include "m_Do/m_Do_ext.h"
 #include "dolphin/os/OS.h"
 
-// TODO 
-// #include "m_Do/m_Do_ext.h"
-JKRExpHeap* mDoExt_getArchiveHeap();
-extern JKRExpHeap* archiveHeap;
-// end m_Do_ext.h
-
 DynamicModuleControlBase* DynamicModuleControlBase::mFirst;
 DynamicModuleControlBase* DynamicModuleControlBase::mLast;
 
diff --git a/src/JSystem/J2DGraph/J2DPane.cpp b/src/JSystem/J2DGraph/J2DPane.cpp
index 09f06091..66b9a60d 100644
--- a/src/JSystem/J2DGraph/J2DPane.cpp
+++ b/src/JSystem/J2DGraph/J2DPane.cpp
@@ -5,6 +5,7 @@
 
 #include "JSystem/J2DGraph/J2DPane.h"
 #include "JSystem/JSupport/JSURandomInputStream.h"
+#include "dolphin/gx/GXEnum.h"
 #include "dolphin/types.h"
 
 /* 802CF8F4-802CF984       .text __ct__7J2DPaneFv */
@@ -180,8 +181,18 @@ J2DPane* J2DPane::search(u32 tag) {
 }
 
 /* 802D0714-802D0800       .text makeMatrix__7J2DPaneFff */
-void J2DPane::makeMatrix(float, float) {
-    /* Nonmatching */
+void J2DPane::makeMatrix(f32 x, f32 y) {
+    Mtx stack1, stack2, stack3;
+    if (mRotation != 0.0f) {
+        MTXTrans(stack1, -mBasePosition.x, -mBasePosition.y, 0.0f);
+        f32 rot = mRotationAxis == ROTATE_Z ? -mRotation : mRotation;
+        MTXRotRad(stack2, mRotationAxis, rot * 0.017445329f);
+        MTXTrans(stack3, mBasePosition.x + x, mBasePosition.y + y, 0.0f);
+        MTXConcat(stack2, stack1, mMtx);
+        MTXConcat(stack3, mMtx, mMtx);
+    } else {
+        MTXTrans(mMtx, x, y, 0.0f);
+    }
 }
 
 /* 802D0800-802D08D8       .text setBasePosition__7J2DPaneF15J2DBasePosition */
@@ -209,13 +220,3 @@ void J2DPane::setBasePosition(J2DBasePosition pos) {
     mRotationAxis = ROTATE_Z;
     calcMtx();
 }
-
-/* 802D08D8-802D08DC       .text drawSelf__7J2DPaneFffPA3_A4_f */
-// void J2DPane::drawSelf(float, float, float (*)[3][4]) {
-//     /* Nonmatching */
-// }
-
-/* 802D08DC-802D08E4       .text getTypeID__7J2DPaneFv */
-// u16 J2DPane::getTypeID() {
-//     /* Nonmatching */
-// }
diff --git a/src/JSystem/JKernel/JKRDisposer.cpp b/src/JSystem/JKernel/JKRDisposer.cpp
index 110700a4..8f697e96 100644
--- a/src/JSystem/JKernel/JKRDisposer.cpp
+++ b/src/JSystem/JKernel/JKRDisposer.cpp
@@ -4,14 +4,20 @@
 //
 
 #include "JSystem/JKernel/JKRDisposer.h"
-#include "dolphin/types.h"
+#include "JSystem/JKernel/JKRHeap.h"
 
 /* 802B3C30-802B3C98       .text __ct__11JKRDisposerFv */
-JKRDisposer::JKRDisposer() {
-    /* Nonmatching */
+JKRDisposer::JKRDisposer() : mLink(this) {
+    mHeap = JKRHeap::findFromRoot(this);
+    if (mHeap) {
+        mHeap->appendDisposer(this);
+    }
 }
 
 /* 802B3C98-802B3D1C       .text __dt__11JKRDisposerFv */
 JKRDisposer::~JKRDisposer() {
-    /* Nonmatching */
+    JKRHeap* heap = mHeap;
+    if (heap) {
+        heap->removeDisposer(this);
+    }
 }
diff --git a/src/JSystem/JKernel/JKRHeap.cpp b/src/JSystem/JKernel/JKRHeap.cpp
index 10bcd98b..1ee6dc7f 100644
--- a/src/JSystem/JKernel/JKRHeap.cpp
+++ b/src/JSystem/JKernel/JKRHeap.cpp
@@ -4,229 +4,473 @@
 //
 
 #include "JSystem/JKernel/JKRHeap.h"
+#include "JSystem/JUtility/JUTAssert.h"
+#include "dolphin/os/OS.h"
 #include "dolphin/types.h"
+#include "global.h"
+
+bool JKRHeap::sDefaultFillFlag = true;
+JKRHeap* JKRHeap::sSystemHeap;
+JKRHeap* JKRHeap::sCurrentHeap;
+JKRHeap* JKRHeap::sRootHeap;
+JKRErrorHandler JKRHeap::mErrorHandler;
 
 /* 802B0100-802B0224       .text __ct__7JKRHeapFPvUlP7JKRHeapb */
-JKRHeap::JKRHeap(void*, unsigned long, JKRHeap*, bool) {
-    /* Nonmatching */
+JKRHeap::JKRHeap(void* data, u32 size, JKRHeap* parent, bool errorFlag) : JKRDisposer(), mChildTree(this), mDisposerList() {
+    OSInitMutex(&mMutex);
+    mSize = size;
+    mStart = (u8*)data;
+    mEnd = (u8*)data + size;
+
+    if (parent == NULL) {
+        becomeSystemHeap();
+        becomeCurrentHeap();
+    } else {
+        parent->mChildTree.appendChild(&mChildTree);
+
+        if (getSystemHeap() == getRootHeap()) {
+            becomeSystemHeap();
+        }
+
+        if (getCurrentHeap() == getRootHeap()) {
+            becomeCurrentHeap();
+        }
+    }
+
+    mErrorFlag = errorFlag;
+    if (mErrorFlag == true && mErrorHandler == NULL) {
+        mErrorHandler = JKRDefaultMemoryErrorRoutine;
+    }
+
+    mDebugFill = sDefaultFillFlag;
+    mInitFlag = false;
 }
 
 /* 802B0224-802B0338       .text __dt__7JKRHeapFv */
 JKRHeap::~JKRHeap() {
-    /* Nonmatching */
+    mChildTree.getParent()->removeChild(&mChildTree);
+    JSUTree<JKRHeap>* nextRootHeap = sRootHeap->mChildTree.getFirstChild();
+
+    if (sCurrentHeap == this) {
+        sCurrentHeap = !nextRootHeap ? sRootHeap : nextRootHeap->getObject();
+    }
+
+    if (sSystemHeap == this) {
+        sSystemHeap = !nextRootHeap ? sRootHeap : nextRootHeap->getObject();
+    }
 }
 
+void* JKRHeap::mCodeStart;
+void* JKRHeap::mCodeEnd;
+void* JKRHeap::mUserRamStart;
+void* JKRHeap::mUserRamEnd;
+u32 JKRHeap::mMemorySize;
+
 /* 802B0338-802B03E8       .text initArena__7JKRHeapFPPcPUli */
-void JKRHeap::initArena(char**, unsigned long*, int) {
-    /* Nonmatching */
+bool JKRHeap::initArena(char** memory, u32* size, int maxHeaps) {
+    void* ram_start;
+    void* ram_end;
+    void* arenaStart;
+
+    void* arenaLo = OSGetArenaLo();
+    void* arenaHi = OSGetArenaHi();
+    if (arenaLo == arenaHi)
+        return false;
+
+    arenaStart = OSInitAlloc(arenaLo, arenaHi, maxHeaps);
+    ram_start = OSRoundUpPtr(arenaStart, 0x20);
+    ram_end = OSRoundDownPtr(arenaHi, 0x20);
+
+    OSBootInfo* codeStart = (OSBootInfo*)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 = (u32)ram_end - (u32)ram_start;
+    return true;
 }
 
 /* 802B03E8-802B03F8       .text becomeSystemHeap__7JKRHeapFv */
-void JKRHeap::becomeSystemHeap() {
-    /* Nonmatching */
+JKRHeap* JKRHeap::becomeSystemHeap() {
+    JKRHeap* prev = sSystemHeap;
+    sSystemHeap = this;
+    return prev;
 }
 
 /* 802B03F8-802B0408       .text becomeCurrentHeap__7JKRHeapFv */
-void JKRHeap::becomeCurrentHeap() {
-    /* Nonmatching */
+JKRHeap* JKRHeap::becomeCurrentHeap() {
+    JKRHeap* prev = sCurrentHeap;
+    sCurrentHeap = this;
+    return prev;
 }
 
 /* 802B0408-802B0434       .text destroy__7JKRHeapFv */
 void JKRHeap::destroy() {
-    /* Nonmatching */
+    do_destroy();
 }
 
 /* 802B0434-802B0494       .text alloc__7JKRHeapFUliP7JKRHeap */
-void JKRHeap::alloc(unsigned long, int, JKRHeap*) {
-    /* Nonmatching */
+void* JKRHeap::alloc(u32 size, int alignment, JKRHeap* heap) {
+    if (heap != NULL) {
+        return heap->alloc(size, alignment);
+    }
+
+    if (sCurrentHeap != NULL) {
+        return sCurrentHeap->alloc(size, alignment);
+    }
+
+    return NULL;
+}
+
+static void dummy1(JKRHeap* heap) {
+    JUT_ASSERT(0, heap != 0);
 }
 
 /* 802B0494-802B0518       .text alloc__7JKRHeapFUli */
-void JKRHeap::alloc(unsigned long, int) {
-    /* Nonmatching */
+void* JKRHeap::alloc(u32 size, int alignment) {
+    if (mInitFlag) {
+        JUT_WARN(308, "alloc %x byte in heap %x", size, this);
+    }
+    return do_alloc(size, alignment);
 }
 
 /* 802B0518-802B0560       .text free__7JKRHeapFPvP7JKRHeap */
-void JKRHeap::free(void*, JKRHeap*) {
-    /* Nonmatching */
+void JKRHeap::free(void* ptr, JKRHeap* heap) {
+    if (!heap) {
+        heap = findFromRoot(ptr);
+        if (!heap)
+            return;
+    }
+
+    heap->free(ptr);
 }
 
 /* 802B0560-802B05DC       .text free__7JKRHeapFPv */
-void JKRHeap::free(void*) {
-    /* Nonmatching */
+void JKRHeap::free(void* ptr) {
+    if (mInitFlag) {
+        JUT_WARN(356, "free %x in heap %x", ptr, this);
+    }
+    do_free(ptr);
 }
 
 /* 802B05DC-802B0634       .text callAllDisposer__7JKRHeapFv */
 void JKRHeap::callAllDisposer() {
-    /* Nonmatching */
+    JSUListIterator<JKRDisposer> iterator;
+
+    while ((iterator = mDisposerList.getFirst()) != mDisposerList.getEnd()) {
+        iterator->~JKRDisposer();
+    }
 }
 
 /* 802B0634-802B069C       .text freeAll__7JKRHeapFv */
 void JKRHeap::freeAll() {
-    /* Nonmatching */
+    if (mInitFlag) {
+        JUT_WARN(408, "freeAll in heap %x", this);
+    }
+    do_freeAll();
 }
 
 /* 802B069C-802B0704       .text freeTail__7JKRHeapFv */
 void JKRHeap::freeTail() {
-    /* Nonmatching */
+    if (mInitFlag) {
+        JUT_WARN(422, "freeTail in heap %x", this);
+    }
+    do_freeTail();
 }
 
 /* 802B0704-802B0764       .text resize__7JKRHeapFPvUlP7JKRHeap */
-void JKRHeap::resize(void*, unsigned long, JKRHeap*) {
-    /* Nonmatching */
+s32 JKRHeap::resize(void* ptr, u32 size, JKRHeap* heap) {
+    if (!heap) {
+        heap = findFromRoot(ptr);
+        if (!heap)
+            return -1;
+    }
+
+    return heap->resize(ptr, size);
 }
 
 /* 802B0764-802B07EC       .text resize__7JKRHeapFPvUl */
-void JKRHeap::resize(void*, unsigned long) {
-    /* Nonmatching */
+s32 JKRHeap::resize(void* ptr, u32 size) {
+    if (mInitFlag) {
+        JUT_WARN(466, "resize block %x into %x in heap %x", ptr, size, this);
+    }
+    return do_resize(ptr, size);
 }
 
 /* 802B07EC-802B083C       .text getSize__7JKRHeapFPvP7JKRHeap */
-void JKRHeap::getSize(void*, JKRHeap*) {
-    /* Nonmatching */
+s32 JKRHeap::getSize(void* ptr, JKRHeap* heap) {
+    if (!heap) {
+        heap = findFromRoot(ptr);
+        if (!heap)
+            return -1;
+    }
+
+    return heap->getSize(ptr);
 }
 
 /* 802B083C-802B0868       .text getSize__7JKRHeapFPv */
-void JKRHeap::getSize(void*) {
-    /* Nonmatching */
+s32 JKRHeap::getSize(void* ptr) {
+    return do_getSize(ptr);
 }
 
 /* 802B0868-802B0894       .text getFreeSize__7JKRHeapFv */
-void JKRHeap::getFreeSize() {
-    /* Nonmatching */
+s32 JKRHeap::getFreeSize() {
+    return do_getFreeSize();
 }
 
 /* 802B0894-802B08C0       .text getMaxFreeBlock__7JKRHeapFv */
-void JKRHeap::getMaxFreeBlock() {
-    /* Nonmatching */
+void* JKRHeap::getMaxFreeBlock() {
+    return do_getMaxFreeBlock();
 }
 
 /* 802B08C0-802B08EC       .text getTotalFreeSize__7JKRHeapFv */
-void JKRHeap::getTotalFreeSize() {
-    /* Nonmatching */
+s32 JKRHeap::getTotalFreeSize() {
+    return do_getTotalFreeSize();
 }
 
 /* 802B08EC-802B0918       .text getCurrentGroupId__7JKRHeapFv */
-void JKRHeap::getCurrentGroupId() {
-    /* Nonmatching */
+u8 JKRHeap::getCurrentGroupId() {
+    return do_getCurrentGroupId();
+}
+
+static void dummy2() {
+    OSReport("change heap ID into %x in heap %x");
 }
 
 /* 802B0918-802B0978       .text getMaxAllocatableSize__7JKRHeapFi */
-void JKRHeap::getMaxAllocatableSize(int) {
-    /* Nonmatching */
+u32 JKRHeap::getMaxAllocatableSize(int alignment) {
+    u32 maxFreeBlock = (u32)getMaxFreeBlock();
+    u32 ptrOffset = (alignment - 1) & alignment - (maxFreeBlock & 0xf);
+    return ~(alignment - 1) & (getFreeSize() - ptrOffset);
 }
 
 /* 802B0978-802B09B0       .text findFromRoot__7JKRHeapFPv */
-void JKRHeap::findFromRoot(void*) {
-    /* Nonmatching */
+JKRHeap* JKRHeap::findFromRoot(void* ptr) {
+    if (sRootHeap) {
+        return sRootHeap->find(ptr);
+    }
+
+    return NULL;
 }
 
 /* 802B09B0-802B0A58       .text find__7JKRHeapCFPv */
-void JKRHeap::find(void*) const {
-    /* Nonmatching */
+JKRHeap* JKRHeap::find(void* memory) const {
+    if (mStart <= memory && memory < mEnd) {
+        if (mChildTree.getNumChildren() != 0) {
+            for (JSUTreeIterator<JKRHeap> iterator(mChildTree.getFirstChild());
+                 iterator != mChildTree.getEndChild(); ++iterator)
+            {
+                JKRHeap* result = iterator->find(memory);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+
+        return const_cast<JKRHeap*>(this);
+    }
+
+    return NULL;
 }
 
 /* 802B0A58-802B0AEC       .text dispose_subroutine__7JKRHeapFUlUl */
-void JKRHeap::dispose_subroutine(unsigned long, unsigned long) {
-    /* Nonmatching */
+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)
+    {
+        JKRDisposer* disposer = iterator.getObject();
+
+        if ((void*)begin <= disposer && disposer < (void*)end) {
+            disposer->~JKRDisposer();
+
+            if (last_iterator == NULL) {
+                next_iterator = mDisposerList.getFirst();
+            } else {
+                next_iterator = last_iterator;
+                next_iterator++;
+            }
+        } else {
+            last_iterator = iterator;
+            next_iterator = iterator;
+            next_iterator++;
+        }
+    }
 }
 
 /* 802B0AEC-802B0B14       .text dispose__7JKRHeapFPvUl */
-void JKRHeap::dispose(void*, unsigned long) {
-    /* Nonmatching */
+bool JKRHeap::dispose(void* ptr, u32 size) {
+    dispose_subroutine((u32)ptr, (u32)ptr + size);
+    return false;
 }
 
 /* 802B0B14-802B0B34       .text dispose__7JKRHeapFPvPv */
-void JKRHeap::dispose(void*, void*) {
-    /* Nonmatching */
+void JKRHeap::dispose(void* begin, void* end) {
+    dispose_subroutine((u32)begin, (u32)end);
 }
 
 /* 802B0B34-802B0B8C       .text dispose__7JKRHeapFv */
 void JKRHeap::dispose() {
-    /* Nonmatching */
+    JSUListIterator<JKRDisposer> iterator;
+    while ((iterator = mDisposerList.getFirst()) != mDisposerList.getEnd()) {
+        iterator->~JKRDisposer();
+    }
 }
 
 /* 802B0B8C-802B0BB4       .text copyMemory__7JKRHeapFPvPvUl */
-void JKRHeap::copyMemory(void*, void*, unsigned long) {
-    /* Nonmatching */
+void JKRHeap::copyMemory(void* dst, void* src, u32 size) {
+    u32 count = (size + 3) / 4;
+
+    u32* dst_32 = (u32*)dst;
+    u32* src_32 = (u32*)src;
+    while (count > 0) {
+        *dst_32 = *src_32;
+        dst_32++;
+        src_32++;
+        count--;
+    }
 }
 
 /* 802B0BB4-802B0C08       .text JKRDefaultMemoryErrorRoutine__FPvUli */
-void JKRDefaultMemoryErrorRoutine(void*, unsigned long, int) {
-    /* Nonmatching */
+void JKRDefaultMemoryErrorRoutine(void* heap, u32 size, int alignment) {
+    OSReport("Error: Cannot allocate memory %d(0x%x)byte in %d byte alignment from %08x\n", size, size, alignment, heap);
+    OSPanic(__FILE__, 767, "abort\n");
 }
 
 /* 802B0C08-802B0C18       .text setErrorFlag__7JKRHeapFb */
-void JKRHeap::setErrorFlag(bool) {
-    /* Nonmatching */
+bool JKRHeap::setErrorFlag(bool errorFlag) {
+    bool prev = mErrorFlag;
+    mErrorFlag = errorFlag;
+    return prev;
 }
 
 /* 802B0C18-802B0C38       .text setErrorHandler__7JKRHeapFPFPvUli_v */
-void JKRHeap::setErrorHandler(void (*)(void*, unsigned long, int)) {
-    /* Nonmatching */
+JKRErrorHandler JKRHeap::setErrorHandler(JKRErrorHandler errorHandler) {
+    JKRErrorHandler prev = mErrorHandler;
+
+    if (!errorHandler) {
+        errorHandler = JKRDefaultMemoryErrorRoutine;
+    }
+
+    mErrorHandler = errorHandler;
+    return prev;
 }
 
 /* 802B0C38-802B0C60       .text __nw__FUl */
-void operator new(unsigned long) {
-    /* Nonmatching */
+void* operator new(size_t size) {
+    return JKRHeap::alloc(size, 4, NULL);
 }
 
 /* 802B0C60-802B0C84       .text __nw__FUli */
-void operator new(unsigned long, int) {
-    /* Nonmatching */
+void* operator new(size_t size, int alignment) {
+    return JKRHeap::alloc(size, alignment, NULL);
 }
 
 /* 802B0C84-802B0CB0       .text __nw__FUlP7JKRHeapi */
-void operator new(unsigned long, JKRHeap*, int) {
-    /* Nonmatching */
+void* operator new(size_t size, JKRHeap* heap, int alignment) {
+    return JKRHeap::alloc(size, alignment, heap);
 }
 
 /* 802B0CB0-802B0CD8       .text __nwa__FUl */
-void operator new[](unsigned long) {
-    /* Nonmatching */
+void* operator new[](size_t size) {
+    return JKRHeap::alloc(size, 4, NULL);
 }
 
 /* 802B0CD8-802B0CFC       .text __nwa__FUli */
-void operator new[](unsigned long, int) {
-    /* Nonmatching */
+void* operator new[](size_t size, int alignment) {
+    return JKRHeap::alloc(size, alignment, NULL);
 }
 
 /* 802B0CFC-802B0D28       .text __nwa__FUlP7JKRHeapi */
-void operator new[](unsigned long, JKRHeap*, int) {
-    /* Nonmatching */
+void* operator new[](size_t size, JKRHeap* heap, int alignment) {
+    return JKRHeap::alloc(size, alignment, heap);
 }
 
 /* 802B0D28-802B0D4C       .text __dl__FPv */
-void operator delete(void*) {
-    /* Nonmatching */
+void operator delete(void* ptr) {
+    JKRHeap::free(ptr, NULL);
 }
 
 /* 802B0D4C-802B0D70       .text __dla__FPv */
-void operator delete[](void*) {
-    /* Nonmatching */
+void operator delete[](void* ptr) {
+    JKRHeap::free(ptr, NULL);
+}
+
+static void dummy3() {
+#if VERSION != VERSION_JPN
+    OSReport("\x1B[41;37m:::addr %08x size %08x: Freeされた領域が浸食されている (%08x=%02x)\n\x1B[m");
+#endif
+    OSReport("%s");
+    OSReport("heap unchanged");
+    OSReport("**** heap changed ****");
+    OSReport("location   : [%s:%d]");
+    OSReport("**** heap changed : old ****");
+    OSReport("**** heap changed : new ****");
 }
 
 /* 802B0D70-802B0E14       .text state_register__7JKRHeapCFPQ27JKRHeap6TStateUl */
-void JKRHeap::state_register(JKRHeap::TState*, unsigned long) const {
-    /* Nonmatching */
+void JKRHeap::state_register(JKRHeap::TState* p, u32 id) const {
+#if VERSION == VERSION_JP
+    JUT_ASSERT(1034, p != 0);
+    JUT_ASSERT(1035, p->getHeap() == this);
+#else
+    JUT_ASSERT(1090, p != 0);
+    JUT_ASSERT(1091, p->getHeap() == this);
+#endif
 }
 
 /* 802B0E14-802B0E9C       .text state_compare__7JKRHeapCFRCQ27JKRHeap6TStateRCQ27JKRHeap6TState */
-void JKRHeap::state_compare(const JKRHeap::TState&, const JKRHeap::TState&) const {
-    /* Nonmatching */
+bool JKRHeap::state_compare(const JKRHeap::TState& r1, const JKRHeap::TState& r2) const {
+#if VERSION == VERSION_JP
+    JUT_ASSERT(1043, r1.getHeap() == r2.getHeap());
+#else
+    JUT_ASSERT(1099, r1.getHeap() == r2.getHeap());
+#endif
+    return r1.getCheckCode() == r2.getCheckCode();
+}
+
+static void dummy4() {
+    OSReport("heap       : %p / %p");
+    OSReport("check-code : 0x%08x / 0x%08x");
+    OSReport("id         : 0x%08x / 0x%08x");
+    OSReport("used size  : %10u / %10u");
 }
 
 /* 802B0E9C-802B0F24       .text state_dump__7JKRHeapCFRCQ27JKRHeap6TState */
-void JKRHeap::state_dump(const JKRHeap::TState&) const {
-    /* Nonmatching */
+void JKRHeap::state_dump(const JKRHeap::TState& p) const {
+#if VERSION == VERSION_JP
+    JUT_LOG(1067, "check-code : 0x%08x", p.getCheckCode());
+    JUT_LOG(1068, "id         : 0x%08x", p.getId());
+    JUT_LOG(1069, "used size  : %u", p.getUsedSize());
+#else
+    JUT_LOG(1123, "check-code : 0x%08x", p.getCheckCode());
+    JUT_LOG(1124, "id         : 0x%08x", p.getId());
+    JUT_LOG(1125, "used size  : %u", p.getUsedSize());
+#endif
 }
 
 /* 802B0F24-802B0F2C       .text do_changeGroupID__7JKRHeapFUc */
-void JKRHeap::do_changeGroupID(unsigned char) {
-    /* Nonmatching */
+s32 JKRHeap::do_changeGroupID(u8 param_0) {
+    return 0;
 }
 
 /* 802B0F2C-802B0F34       .text do_getCurrentGroupId__7JKRHeapFv */
-void JKRHeap::do_getCurrentGroupId() {
-    /* Nonmatching */
+u8 JKRHeap::do_getCurrentGroupId() {
+    return 0;
+}
+
+#if VERSION == VERSION_JP
+static void dummy5() {
+    OSReport("\x1B[41;37m:::addr %08x size %08x: Freeされた領域が浸食されている (%08x=%02x)\n\x1B[m");
 }
+#endif
diff --git a/src/JSystem/JUtility/JUTResFont.cpp b/src/JSystem/JUtility/JUTResFont.cpp
index c9cb9e30..135861bc 100644
--- a/src/JSystem/JUtility/JUTResFont.cpp
+++ b/src/JSystem/JUtility/JUTResFont.cpp
@@ -4,104 +4,457 @@
 //
 
 #include "JSystem/JUtility/JUTResFont.h"
+#include "JSystem/JKernel/JKRHeap.h"
+#include "JSystem/JUtility/JUTAssert.h"
+#include "JSystem/JUtility/JUTConsole.h"
+#include "dolphin/gx/GX.h"
 #include "dolphin/types.h"
 
+// Only used for an assert
+#define suAboutEncoding_ 3
+
+IsLeadByte_func const JUTResFont::saoAboutEncoding_[3] = {
+    isLeadByte_1Byte,
+    isLeadByte_2Byte,
+    isLeadByte_ShiftJIS,
+};
+
 /* 802C2044-802C2090       .text __ct__10JUTResFontFv */
 JUTResFont::JUTResFont() {
-    /* Nonmatching */
+    initialize_state();
+    JUTFont::initialize_state();
 }
 
 /* 802C2090-802C20F4       .text __ct__10JUTResFontFPC7ResFONTP7JKRHeap */
-JUTResFont::JUTResFont(const ResFONT*, JKRHeap*) {
-    /* Nonmatching */
+JUTResFont::JUTResFont(const ResFONT* pFont, JKRHeap* pHeap) {
+    initialize_state();
+    initiate(pFont, pHeap);
 }
 
 /* 802C20F4-802C2180       .text __dt__10JUTResFontFv */
 JUTResFont::~JUTResFont() {
-    /* Nonmatching */
+    if (mValid) {
+        delete_and_initialize();
+        JUTFont::initialize_state();
+    }
 }
 
 /* 802C2180-802C21A4       .text deleteMemBlocks_ResFont__10JUTResFontFv */
 void JUTResFont::deleteMemBlocks_ResFont() {
-    /* Nonmatching */
+    delete[] mpMemBlocks;
 }
 
 /* 802C21A4-802C21D0       .text initialize_state__10JUTResFontFv */
 void JUTResFont::initialize_state() {
-    /* Nonmatching */
+    mResFont = NULL;
+    mpMemBlocks = NULL;
+    mpWidthBlocks = NULL;
+    mpGlyphBlocks = NULL;
+    mpMapBlocks = NULL;
+    mWidth = 0;
+    mHeight = 0;
+    mTexPageIdx = -1;
 }
 
 /* 802C21D0-802C2230       .text initiate__10JUTResFontFPC7ResFONTP7JKRHeap */
-void JUTResFont::initiate(const ResFONT*, JKRHeap*) {
-    /* Nonmatching */
+bool JUTResFont::initiate(const ResFONT* pFont, JKRHeap* pHeap) {
+    u8 initiated = protected_initiate(pFont, pHeap);
+    if (!initiated) {
+        delete_and_initialize();
+        JUTFont::initialize_state();
+        mValid = false;
+        return false;
+    }
+    return true;
 }
 
 /* 802C2230-802C233C       .text protected_initiate__10JUTResFontFPC7ResFONTP7JKRHeap */
-void JUTResFont::protected_initiate(const ResFONT*, JKRHeap*) {
-    /* Nonmatching */
+bool JUTResFont::protected_initiate(const ResFONT* pFont, JKRHeap* pHeap) {
+    delete_and_initialize();
+    JUTFont::initialize_state();
+    if (pFont == NULL) {
+        return false;
+    }
+    mResFont = pFont;
+    mValid = true;
+    countBlock();
+
+    u32 blockNum = mWidthBlockNum + mGlyphBlockNum + mMapBlockNum;
+    mpMemBlocks = new (pHeap, 0) void*[blockNum];
+
+    void** block = mpMemBlocks;
+
+    if (block == NULL) {
+        return false;
+    } else {
+        if (mWidthBlockNum != 0) {
+            mpWidthBlocks = (ResFONT::WID1**)block;
+            block += mWidthBlockNum;
+        }
+        if (mGlyphBlockNum != 0) {
+            mpGlyphBlocks = (ResFONT::GLY1**)block;
+            block += mGlyphBlockNum;
+        }
+        if (mMapBlockNum != 0) {
+            mpMapBlocks = (ResFONT::MAP1**)block;
+        }
+        setBlock();
+        return true;
+    }
 }
 
 /* 802C233C-802C2438       .text countBlock__10JUTResFontFv */
 void JUTResFont::countBlock() {
-    /* Nonmatching */
+    mWidthBlockNum = 0;
+    mGlyphBlockNum = 0;
+    mMapBlockNum = 0;
+
+    const BlockHeader* header = (BlockHeader*)mResFont->data;
+    for (u32 i = 0; i < mResFont->numBlocks; i++, header = header->getNext()) {
+        switch (header->magic) {
+        case 'WID1':
+            mWidthBlockNum++;
+            break;
+        case 'GLY1':
+            mGlyphBlockNum++;
+            break;
+        case 'MAP1':
+            mMapBlockNum++;
+            break;
+        case 'INF1':
+            break;
+        default:
+            JUTReportConsole("JUTResFont: Unknown data block\n");
+        }
+    }
 }
 
 /* 802C2438-802C25C0       .text setBlock__10JUTResFontFv */
 void JUTResFont::setBlock() {
-    /* Nonmatching */
+    int widthNum = 0;
+    int glyphNum = 0;
+    int mapNum = 0;
+    mMaxCode = -1;
+
+    const BlockHeader* header = (BlockHeader*)mResFont->data;
+    for (u32 i = 0; i < mResFont->numBlocks; i++, header = header->getNext()) {
+        switch (header->magic) {
+        case 'INF1':
+            mInfoBlock = (ResFONT::INF1*)header;
+            u32 u = mInfoBlock->fontType;
+            JUT_ASSERT(0xF3, u < suAboutEncoding_)
+            mIsLeadByte = (IsLeadByte_func*)&saoAboutEncoding_[u];
+            break;
+        case 'WID1':
+            mpWidthBlocks[widthNum] = (ResFONT::WID1*)header;
+            widthNum++;
+            break;
+        case 'GLY1':
+            mpGlyphBlocks[glyphNum] = (ResFONT::GLY1*)header;
+            glyphNum++;
+            break;
+        case 'MAP1':
+            mpMapBlocks[mapNum] = (ResFONT::MAP1*)header;
+            if (mMaxCode > mpMapBlocks[mapNum]->startCode) {
+                mMaxCode = mpMapBlocks[mapNum]->startCode;
+            }
+            mapNum++;
+            break;
+        default:
+            JUTReportConsole("Unknown data block\n");
+            break;
+        }
+    }
 }
 
 /* 802C25C0-802C26B8       .text setGX__10JUTResFontFv */
 void JUTResFont::setGX() {
-    /* Nonmatching */
+    GXSetNumChans(1);
+    GXSetNumTevStages(1);
+    GXSetNumTexGens(1);
+    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0);
+    GXSetChanCtrl(GX_COLOR0A0, false, GX_SRC_REG, GX_SRC_VTX, 0, GX_DF_NONE, GX_AF_NONE);
+    GXSetTevOp(GX_TEVSTAGE0, GX_MODULATE);
+    GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
+    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_RGBA4, 0);
+    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0);
+    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_CLR_RGBA, GX_RGBX8, 0xf);
+    GXClearVtxDesc();
+    GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
+    GXSetVtxDesc(GX_VA_CLR0, GX_DIRECT);
+    GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT);
 }
 
 /* 802C26B8-802C28F8       .text setGX__10JUTResFontFQ28JUtility6TColorQ28JUtility6TColor */
-void JUTResFont::setGX(JUtility::TColor, JUtility::TColor) {
-    /* Nonmatching */
+void JUTResFont::setGX(JUtility::TColor col1, JUtility::TColor col2) {
+    if (col1 == 0 && col2 == -1) {
+        setGX();
+    } else {
+        GXSetNumChans(1);
+        GXSetNumTevStages(2);
+        GXSetNumTexGens(1);
+        GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL);
+        GXSetChanCtrl(GX_COLOR0A0, false, GX_SRC_REG, GX_SRC_VTX, 0, GX_DF_NONE, GX_AF_NONE);
+        GXSetTevColor(GX_TEVREG0, col1);
+        GXSetTevColor(GX_TEVREG1, col2);
+        GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_C0, GX_CC_C1, GX_CC_TEXC, GX_CC_ZERO);
+        GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_A0, GX_CA_A1, GX_CA_TEXA, GX_CA_ZERO);
+        GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, true, GX_TEVPREV);
+        GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, true, GX_TEVPREV);
+        GXSetTevOrder(GX_TEVSTAGE1, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
+        GXSetTevColorIn(GX_TEVSTAGE1, GX_CC_ZERO, GX_CC_CPREV, GX_CC_RASC, GX_CC_ZERO);
+        GXSetTevAlphaIn(GX_TEVSTAGE1, GX_CA_ZERO, GX_CA_APREV, GX_CA_RASA, GX_CA_ZERO);
+        GXSetTevColorOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, true, GX_TEVPREV);
+        GXSetTevAlphaOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, true, GX_TEVPREV);
+        GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
+        GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_RGBA4, 0);
+        GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0);
+        GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_CLR_RGBA, GX_RGBX8, 15);
+        GXClearVtxDesc();
+        GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
+        GXSetVtxDesc(GX_VA_CLR0, GX_DIRECT);
+        GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT);
+    }
 }
 
 /* 802C28F8-802C2D6C       .text drawChar_scale__10JUTResFontFffffib */
-void JUTResFont::drawChar_scale(float, float, float, float, int, bool) {
+f32 JUTResFont::drawChar_scale(f32 posX, f32 posY, f32 scaleX, f32 scaleY, int chr, bool flag) {
     /* Nonmatching */
+    JUTFont::TWidth width;
+    f32 posMinX;
+    f32 posMinY;
+    f32 scaledHeight;
+    f32 posMaxX;
+
+    JUT_ASSERT(0x179, mValid)
+    loadFont(chr, GX_TEXMAP0, &width);
+
+    if (mFixed || !flag) {
+        posMinX = posX;
+    } else {
+        posMinX = (posX - width.field_0x0 * (scaleX / getCellWidth()));
+    }
+    f32 retval = mFixedWidth * (scaleX / getCellWidth());
+    if (!mFixed) {
+        if (!flag) {
+            retval = (width.field_0x1 + width.field_0x0) * (scaleX / getCellWidth());
+        } else {
+            retval = width.field_0x1 * (scaleX / getCellWidth());
+        }
+    }
+    posMaxX = posMinX + scaleX;
+    posMinY = posY - getAscent() * (scaleY / getHeight());
+    scaledHeight = scaleY / getHeight();
+    f32 descent = getDescent();
+    f32 posMaxY = descent * scaledHeight + posY;
+
+    // Glyph details
+    ResFONT::GLY1* used_glyphs = mpGlyphBlocks[field_0x66];
+    u16 texWidth = used_glyphs->textureWidth;
+    u16 texHeight = used_glyphs->textureHeight;
+    int tWidth = mWidth;
+    int tHeight = mHeight;
+    int shiftWidth = (tWidth + used_glyphs->cellWidth) << 15;
+    int texMinX = (tWidth << 15) / texWidth;
+    int texMinY = (tHeight << 15) / texHeight;
+    int shiftHeight = (tHeight + used_glyphs->cellHeight) << 15;
+    s32 texMaxX = shiftWidth / texWidth;
+    s32 texMaxY = shiftHeight / texHeight;
+
+    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
+    GXBegin(GX_QUADS, GX_VTXFMT0, 4);
+
+    // Bottom Left
+    GXPosition3f32(posMinX, posMinY, 0.0f);
+    GXColor1u32(mColor1);
+    GXTexCoord2s16(texMinX, texMinY);
+
+    // Bottom Right
+    GXPosition3f32(posMaxX, posMinY, 0.0f);
+    GXColor1u32(mColor2);
+    GXTexCoord2s16(texMaxX, texMinY);
+
+    // Top Right
+    GXPosition3f32(posMaxX, posMaxY, 0.0f);
+    GXColor1u32(mColor4);
+    GXTexCoord2s16(texMaxX, texMaxY);
+
+    // Top Left
+    GXPosition3f32(posMinX, posMaxY, 0.0f);
+    GXColor1u32(mColor3);
+    GXTexCoord2s16(texMinX, texMaxY);
+
+    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_S16, 0);
+
+    return retval;
 }
 
 /* 802C2D6C-802C2DE8       .text loadFont__10JUTResFontFi11_GXTexMapIDPQ27JUTFont6TWidth */
-void JUTResFont::loadFont(int, _GXTexMapID, JUTFont::TWidth*) {
-    /* Nonmatching */
+void JUTResFont::loadFont(int code, _GXTexMapID texMapID, JUTFont::TWidth* pDstWidth) {
+    if (pDstWidth) {
+        getWidthEntry(code, pDstWidth);
+    }
+    u32 fontCode = getFontCode(code);
+    loadImage(fontCode, texMapID);
 }
 
 /* 802C2DE8-802C2E90       .text getWidthEntry__10JUTResFontCFiPQ27JUTFont6TWidth */
-void JUTResFont::getWidthEntry(int, JUTFont::TWidth*) const {
+void JUTResFont::getWidthEntry(int code, JUTFont::TWidth* width) const {
     /* Nonmatching */
+    int fontCode = getFontCode(code);
+    width->field_0x0 = 0;
+    width->field_0x1 = mInfoBlock->width;
+
+    for (int i = 0; i < mWidthBlockNum; i++) {
+        ResFONT::WID1* block = mpWidthBlocks[i];
+        if (block->startCode <= fontCode && fontCode <= block->endCode) {
+            int chunkNum = (fontCode - mpWidthBlocks[i]->startCode) * 2;
+            u8* ptr = &mpWidthBlocks[i]->mChunkNum[chunkNum];
+            width->field_0x0 = ptr[0];
+            width->field_0x1 = ptr[1];
+            break;
+        }
+    }
 }
 
 /* 802C2E90-802C2EDC       .text getCellWidth__10JUTResFontCFv */
-void JUTResFont::getCellWidth() const {
-    /* Nonmatching */
+int JUTResFont::getCellWidth() const {
+    if (mpGlyphBlocks) {
+        ResFONT::GLY1* glyph = *mpGlyphBlocks;
+        if (glyph) {
+            return glyph->cellWidth;
+        }
+    }
+    return getWidth();
 }
 
 /* 802C2EDC-802C2F28       .text getCellHeight__10JUTResFontCFv */
-void JUTResFont::getCellHeight() const {
-    /* Nonmatching */
+s32 JUTResFont::getCellHeight() const {
+    if (mpGlyphBlocks) {
+        ResFONT::GLY1* glyph = *mpGlyphBlocks;
+        if (glyph) {
+            return glyph->cellHeight;
+        }
+    }
+    return getHeight();
 }
 
 /* 802C2F28-802C2F5C       .text isLeadByte__10JUTResFontCFi */
-void JUTResFont::isLeadByte(int) const {
-    /* Nonmatching */
+bool JUTResFont::isLeadByte(int chr) const {
+    return (*mIsLeadByte)(chr);
 }
 
 /* 802C2F5C-802C30E4       .text getFontCode__10JUTResFontCFi */
-void JUTResFont::getFontCode(int) const {
+int JUTResFont::getFontCode(int chr) const {
     /* Nonmatching */
+    static const u16 halftofull[95] = {
+        0x8140, 0x8149, 0x8168, 0x8194, 0x8190, 0x8193, 0x8195, 0x8166, 0x8169, 0x816A, 0x8196,
+        0x817B, 0x8143, 0x817C, 0x8144, 0x815E, 0x824F, 0x8250, 0x8251, 0x8252, 0x8253, 0x8254,
+        0x8255, 0x8256, 0x8257, 0x8258, 0x8146, 0x8147, 0x8183, 0x8181, 0x8184, 0x8148, 0x8197,
+        0x8260, 0x8261, 0x8262, 0x8263, 0x8264, 0x8265, 0x8266, 0x8267, 0x8268, 0x8269, 0x826A,
+        0x826B, 0x826C, 0x826D, 0x826E, 0x826F, 0x8270, 0x8271, 0x8272, 0x8273, 0x8274, 0x8275,
+        0x8276, 0x8277, 0x8278, 0x8279, 0x816D, 0x818F, 0x816E, 0x814F, 0x8151, 0x8165, 0x8281,
+        0x8282, 0x8283, 0x8284, 0x8285, 0x8286, 0x8287, 0x8288, 0x8289, 0x828A, 0x828B, 0x828C,
+        0x828D, 0x828E, 0x828F, 0x8290, 0x8291, 0x8292, 0x8293, 0x8294, 0x8295, 0x8296, 0x8297,
+        0x8298, 0x8299, 0x829A, 0x816F, 0x8162, 0x8170, 0x8160,
+    };
+
+    int ret = mInfoBlock->defaultCode;
+    if ((getFontType() == 2) && (mMaxCode >= 0x8000u) && (chr >= 0x20) && (chr < 0x7Fu)) {
+        chr = halftofull[chr - 32];
+    }
+    int j = 0;
+    for (int i = mMapBlockNum; i > 0; j++, i--) {
+        if ((mpMapBlocks[j]->startCode <= chr) && (chr <= mpMapBlocks[j]->endCode)) {
+            ResFONT::MAP1* map = mpMapBlocks[j];
+            if (map->mappingMethod == 0) {
+                ret = chr - map->startCode;
+                break;
+            } else if (map->mappingMethod == 2) {
+                ret = *(&mpMapBlocks[j]->mLeading + ((chr - mpMapBlocks[j]->startCode)));
+                break;
+            } else if (map->mappingMethod == 3) {
+                u16* leading_temp = &map->mLeading;
+                int phi_r5 = 0;
+                int phi_r6_2 = map->numEntries - 1;
+
+                while (phi_r6_2 >= phi_r5) {
+                    u32 temp_r3 = phi_r6_2 + phi_r5;
+                    int temp_r7 = (int)((temp_r3 >> 0x1FU) + phi_r6_2 + phi_r5) >> 1;
+
+                    if (chr < leading_temp[temp_r7 * 2]) {
+                        phi_r6_2 = temp_r7 - 1;
+                        continue;
+                    }
+
+                    if (chr > leading_temp[temp_r7 * 2]) {
+                        phi_r5 = temp_r7 + 1;
+                        continue;
+                    }
+
+                    ret = leading_temp[temp_r7 * 2 + 1];
+                    break;
+                }
+            } else if (map->mappingMethod == 1) {
+                u16* phi_r5_2 = NULL;
+                if (map->numEntries == 1) {
+                    phi_r5_2 = &map->mLeading;
+                }
+                ret = JUTResFont::convertSjis(chr, phi_r5_2);
+                break;
+            }
+            break;
+        }
+    }
+    return ret;
 }
 
 /* 802C30E4-802C3248       .text loadImage__10JUTResFontFi11_GXTexMapID */
-void JUTResFont::loadImage(int, _GXTexMapID) {
-    /* Nonmatching */
+void JUTResFont::loadImage(int code, _GXTexMapID id) {
+    int i = 0;
+    for (; i < mGlyphBlockNum; i++) {
+        if (mpGlyphBlocks[i]->startCode <= code && code <= mpGlyphBlocks[i]->endCode) {
+            code -= mpGlyphBlocks[i]->startCode;
+            break;
+        }
+    }
+
+    if (i == mGlyphBlockNum)
+        return;
+
+    s32 pageNumCells = mpGlyphBlocks[i]->numRows * mpGlyphBlocks[i]->numColumns;
+    s32 pageIdx = code / pageNumCells;
+    s32 cellIdxInPage = code % pageNumCells;
+    s32 cellCol = (cellIdxInPage % mpGlyphBlocks[i]->numRows);
+    s32 cellRow = (cellIdxInPage / mpGlyphBlocks[i]->numRows);
+    mWidth = cellCol * mpGlyphBlocks[i]->cellWidth;
+    mHeight = cellRow * mpGlyphBlocks[i]->cellHeight;
+
+    if (pageIdx != mTexPageIdx || i != field_0x66) {
+        GXInitTexObj(&field_0x24, &mpGlyphBlocks[i]->data[pageIdx * mpGlyphBlocks[i]->textureSize],
+                     mpGlyphBlocks[i]->textureWidth, mpGlyphBlocks[i]->textureHeight,
+                     (GXTexFmt)mpGlyphBlocks[i]->textureFormat, GX_CLAMP, GX_CLAMP, 0);
+
+        GXInitTexObjLOD(&field_0x24, GX_LINEAR, GX_LINEAR, 0.0f, 0.0f, 0.0f, 0U, 0U, GX_ANISO_1);
+        mTexPageIdx = pageIdx;
+        field_0x66 = i;
+    }
+
+    GXLoadTexObj(&field_0x24, id);
 }
 
 /* 802C3248-802C328C       .text convertSjis__10JUTResFontCFiPUs */
-void JUTResFont::convertSjis(int, unsigned short*) const {
+int JUTResFont::convertSjis(int inChar, u16* inLead) const {
     /* Nonmatching */
+    int outChar = (u8)inChar;
+    inChar = inChar >> 8 & 0xFF;
+    outChar -= 0x40;
+    if (0x40 <= outChar) {
+        outChar--;
+    }
+    u16 lead = 0x31C;
+    if (inLead) {
+        lead = *inLead;
+    }
+    return outChar + (inChar - 0x88) * 0xBC + -0x5E + lead;
 }
diff --git a/src/d/actor/d_a_alldie.cpp b/src/d/actor/d_a_alldie.cpp
index 58877555..35a965fa 100644
--- a/src/d/actor/d_a_alldie.cpp
+++ b/src/d/actor/d_a_alldie.cpp
@@ -3,9 +3,10 @@
 // Translation Unit: d_a_alldie.cpp
 //
 
-#include "f_op/f_op_actor_mng.h"
 #include "JSystem/JKernel/JKRHeap.h"
+#include "d/d_com_inf_game.h"
 #include "d/d_procname.h"
+#include "f_op/f_op_actor_mng.h"
 
 enum {
     ACT_WAIT,
@@ -25,12 +26,12 @@ public:
 
 public:
     u8 mAction;
-    u16 mTimer;
+    s16 mTimer;
 };
 
 /* 00000078-00000084       .text getSwbit__10daAlldie_cFv */
 u8 daAlldie_c::getSwbit() {
-    return fopAcM_GetParam(this) >> 0x8; 
+    return fopAcM_GetParam(this) >> 0x8;
 }
 
 /* 00000084-0000008C       .text actionWait__10daAlldie_cFv */
@@ -52,13 +53,11 @@ s32 daAlldie_c::actionCheck() {
 s32 daAlldie_c::actionTimer() {
     if (fopAcM_myRoomSearchEnemy(fopAcM_GetRoomNo(this))) {
         mAction = ACT_CHECK;
+    } else if (mTimer > 0) {
+        mTimer--;
     } else {
-        if (mTimer > 0) {
-            mTimer--;
-        } else {
-            mAction = ACT_WAIT;
-            dComIfGs_onSwitch(getSwbit(), fopAcM_GetRoomNo(this));
-        }
+        mAction = ACT_WAIT;
+        dComIfGs_onSwitch(getSwbit(), fopAcM_GetRoomNo(this));
     }
     return 1;
 }
@@ -83,9 +82,7 @@ s32 daAlldie_c::execute() {
 s32 daAlldie_c::create() {
     fopAcM_SetupActor(this, daAlldie_c);
 
-    s8 roomNo = fopAcM_GetRoomNo(this);
-
-    if (!dComIfGs_isSwitch(this->getSwbit(), roomNo)) {
+    if (!dComIfGs_isSwitch(getSwbit(), fopAcM_GetRoomNo(this))) {
         mAction = ACT_CHECK;
     } else {
         mAction = ACT_WAIT;
@@ -100,29 +97,29 @@ s32 daAlldie_c::create() {
 }
 
 /* 000001BC-000001C4       .text daAlldie_Draw__FP10daAlldie_c */
-s32 daAlldie_Draw(daAlldie_c*) {
+static s32 daAlldie_Draw(daAlldie_c*) {
     return 1;
 }
 
 /* 000001C4-000001E8       .text daAlldie_Execute__FP10daAlldie_c */
-s32 daAlldie_Execute(daAlldie_c* i_this) {
+static s32 daAlldie_Execute(daAlldie_c* i_this) {
     i_this->execute();
     return 1;
 }
 
 /* 000001E8-000001F0       .text daAlldie_IsDelete__FP10daAlldie_c */
-s32 daAlldie_IsDelete(daAlldie_c*) {
+static s32 daAlldie_IsDelete(daAlldie_c*) {
     return 1;
 }
 
 /* 000001F0-00000220       .text daAlldie_Delete__FP10daAlldie_c */
-s32 daAlldie_Delete(daAlldie_c* i_this) {
+static s32 daAlldie_Delete(daAlldie_c* i_this) {
     i_this->~daAlldie_c();
     return 1;
 }
 
 /* 00000220-000002CC       .text daAlldie_Create__FP10fopAc_ac_c */
-s32 daAlldie_Create(fopAc_ac_c* ac) {
+static s32 daAlldie_Create(fopAc_ac_c* ac) {
     return ((daAlldie_c*)ac)->create();
 }
 
diff --git a/src/d/actor/d_a_andsw0.cpp b/src/d/actor/d_a_andsw0.cpp
index 6b18cd74..6daa4fa2 100644
--- a/src/d/actor/d_a_andsw0.cpp
+++ b/src/d/actor/d_a_andsw0.cpp
@@ -6,6 +6,7 @@
 #include "JSystem/JKernel/JKRHeap.h"
 #include "f_op/f_op_actor_mng.h"
 #include "d/d_com_inf_game.h"
+#include "d/d_procname.h"
 
 enum {
     ACT_ON_ALL = 0,
@@ -19,76 +20,259 @@ enum {
 struct andsw0_class : public fopAc_ac_c {
 public:
     /* 0x290 */ u32 _pad[2];
-    /* 0x298 */ u8 mAction;
+    /* 0x298 */ s8 mAction;
     /* 0x299 */ u8 mNumSwitchesToCheck;
     /* 0x29A */ u8 mBehaviorType;
     /* 0x29B */ u8 mSwitchToSet;
     /* 0x29C */ u8 mFirstSwitchToCheck;
     /* 0x29E */ u16 mTimer;
-    /* 0x2A0 */ u16 mEventMapToolNo;
-    /* 0x292 */ u8 mEventIdx;
-    /* 0x293 */ u8 mEventState;
+    /* 0x2A0 */ s16 mEventIdx;
+    /* 0x2A2 */ u8 mEventNo;
+    /* 0x2A3 */ s8 mEventState;
 };
 
-/* 00000078-00000080       .text daAndsw0_Draw__FP12andsw0_class */
-s32 daAndsw0_Draw(andsw0_class*) {
+static s32 daAndsw0_Draw(andsw0_class*) {
     return 1;
 }
 
-/* 00000080-000003C4       .text daAndsw0_check__FP12andsw0_class */
-void daAndsw0_check(andsw0_class*) {
+static void daAndsw0_check(andsw0_class* i_this) {
     /* Nonmatching */
+    u8 numToCheck = i_this->mNumSwitchesToCheck;
+    u32 switchIdxToCheck = i_this->mFirstSwitchToCheck ? i_this->mFirstSwitchToCheck : i_this->mSwitchToSet + 1;
+
+    switch(i_this->mAction) {
+        case ACT_ON_ALL:
+            for(int i = 0; i < numToCheck; i++) {
+                if(dComIfGs_isSwitch(switchIdxToCheck, i_this->current.roomNo) == false) {
+                    break;
+                }
+
+                if(i == numToCheck - 1) {
+                    if(i_this->mBehaviorType != 3) {
+                        dComIfGs_onSwitch(i_this->mSwitchToSet, i_this->current.roomNo);
+                    }
+
+                    switch(i_this->mBehaviorType) {
+                        case 0:
+                            i_this->mAction = ACT_WAIT;
+                            break;
+                        case 3:
+                            i_this->mAction = ACT_TIMER_SET;
+                            i_this->mTimer = 0x41;
+                            break;
+                        default:
+                            i_this->mAction = ACT_OFF_ALL;
+                            break;
+                    }
+                }
+
+                switchIdxToCheck += 1;
+            }
+
+            break;
+        case ACT_OFF_ALL:
+            switchIdxToCheck = i_this->mFirstSwitchToCheck ? i_this->mFirstSwitchToCheck : i_this->mSwitchToSet + 1;
+
+            for(int i = 0; i < numToCheck; i++) {
+                if(dComIfGs_isSwitch(switchIdxToCheck, i_this->current.roomNo) == false) {
+                    dComIfGs_offSwitch(i_this->mSwitchToSet, i_this->current.roomNo);
+                    i_this->mAction  = ACT_ON_ALL;
+                    break;
+                }
+                
+                switchIdxToCheck += 1;
+            }
+
+            break;
+        case ACT_TIMER:
+            i_this->mTimer = (i_this->orig.angle.z & 0xFF) * 0xF;
+            if(fopAcM_isSwitch(i_this, i_this->mSwitchToSet)) {
+                i_this->mAction = ACT_WAIT;
+            }
+            else {
+                for(int i = 0; i < numToCheck; i++) {
+                    if(fopAcM_isSwitch(i_this, switchIdxToCheck)) {
+                        i_this->mAction += 1;
+                        break;
+                    }
+                    
+                    switchIdxToCheck += 1;
+                }
+            }
+
+            break;
+        case ACT_TIMER2:
+            i_this->mTimer -= 1;
+            if(i_this->mTimer == 0) {
+                for(int i = 0; i < numToCheck; i++) {
+                    fopAcM_offSwitch(i_this, switchIdxToCheck);
+                    switchIdxToCheck += 1;
+                }
+                
+                i_this->mAction = ACT_TIMER;
+            }
+            else {
+                switchIdxToCheck = i_this->mFirstSwitchToCheck ? i_this->mFirstSwitchToCheck : i_this->mSwitchToSet + 1;
+
+                for(int i = 0; i < numToCheck; i++) {
+                    if(fopAcM_isSwitch(i_this, switchIdxToCheck) == false) {
+                        break;
+                    }
+
+                    if(i == numToCheck - 1) {
+                        fopAcM_onSwitch(i_this, i_this->mSwitchToSet);
+                        i_this->mAction = ACT_WAIT;
+                    }
+                    
+                    switchIdxToCheck += 1;
+                }
+            }
+
+            break;
+        case ACT_TIMER_SET:
+            i_this->mTimer -= 1;
+            if(i_this->mTimer == 0) {
+                fopAcM_onSwitch(i_this, i_this->mSwitchToSet);
+                i_this->mAction = ACT_WAIT;
+            }
+
+            break;
+        case ACT_WAIT:
+        default:
+            break;
+    }
 }
 
-/* 000003C4-0000044C       .text bk_s_sub1__FPvPv */
-void bk_s_sub1(void*, void*) {
-    /* Nonmatching */
+static void* ac[7];
+static s32 check_count;
+
+static void* bk_s_sub1(void* i_this, void*) {
+    if(fopAcM_IsActor(i_this) && fopAcM_GetName(i_this) == 0xBE && (fopAcM_GetParam(i_this) & 0xF) == 7)  {
+        s32 count = check_count; //regswaps without this
+        if(count < 2) {
+            ac[check_count] = i_this;
+            check_count++;
+        }
+
+        return 0;
+    }
+
+    return 0;
 }
 
-/* 0000044C-000004D4       .text bk_s_sub2__FPvPv */
-void bk_s_sub2(void*, void*) {
-    /* Nonmatching */
+static void* bk_s_sub2(void* i_this, void*) {
+    if(fopAcM_IsActor(i_this) && fopAcM_GetName(i_this) == 0xBE && (fopAcM_GetParam(i_this) & 0xF) == 4)  {
+        s32 count = check_count; //regswaps without this
+        if(count == 2) {
+            ac[check_count] = i_this;
+            check_count++;
+        }
+
+        return 0;
+    }
+
+    return 0;
 }
 
-/* 000004D4-0000055C       .text bk_s_sub3__FPvPv */
-void bk_s_sub3(void*, void*) {
-    /* Nonmatching */
+static void* bk_s_sub3(void* i_this, void*) {
+    if(fopAcM_IsActor(i_this) && fopAcM_GetName(i_this) == 0xBE && (fopAcM_GetParam(i_this) & 0xF) == 5)  {
+        s32 count = check_count; //regswaps without this
+        if(count < 5) {
+            ac[check_count] = i_this;
+            check_count++;
+        }
+
+        return 0;
+    }
+
+    return 0;
 }
 
-/* 0000055C-000005D4       .text bb_s_sub__FPvPv */
-void bb_s_sub(void*, void*) {
-    /* Nonmatching */
+static void* bb_s_sub(void* i_this, void*) {
+    if(fopAcM_IsActor(i_this) && fopAcM_GetName(i_this) == 0xB6)  {
+        s32 count = check_count; //regswaps without this
+        if(count < 7) {
+            ac[check_count] = i_this;
+            check_count++;
+        }
+
+        return 0;
+    }
+
+    return 0;
 }
 
-/* 000005D4-000006AC       .text hajimari_actor_entry__FP12andsw0_class */
-s32 hajimari_actor_entry(andsw0_class*) {
-    /* Nonmatching */
+static s32 hajimari_actor_entry(andsw0_class* i_this) {
+    for(int i = 0; i < 7; i++) {
+        ac[i] = 0;
+    }
+    check_count = 0;
+
+    i_fpcM_Search(&bk_s_sub1, i_this);
+    i_fpcM_Search(&bk_s_sub2, i_this);
+    i_fpcM_Search(&bk_s_sub3, i_this);
+    check_count = 5;
+    i_fpcM_Search(&bb_s_sub, i_this);
+
+    for(int i = 0; i < 7; i++) {
+        if(ac[i] == 0) {
+            return 0;
+        }
+    }
+
+    return 1;
 }
 
-/* 000006AC-0000081C       .text hajimarinomori_check__FP12andsw0_class */
-void hajimarinomori_check(andsw0_class* i_this) {
+static void hajimarinomori_check(andsw0_class* i_this) {
+    /* Nonmatching */
     if (i_this->mBehaviorType == 0) {
-        if (hajimari_actor_entry(i_this))
+        if (hajimari_actor_entry(i_this)) {
             i_this->mBehaviorType = 1;
-    } else {
+        }
+    }
+    else {
+        for(int i = 0; i < 7; i++) {}
+
+        //looks like these have something to do with bk_class and bb_class (based on the 0xB6/0xBE proc names earlier)
+        //finishing this probably needs some work on those
         if (dComIfGs_isEventBit(4)) {
-            //
+            fopAcM_delete((fopAc_ac_c*)ac[5]);
+            fopAcM_delete((fopAc_ac_c*)ac[6]);
+            //ac[3]->field_0x121C = 1;
+            //ac[4]->field_0x121C = 1;
+            
+            if (dComIfGs_isEventBit(0x301)) {
+                //ac[0]->field_0x121C = 1;
+            }
+            if (dComIfGs_isEventBit(0x480)) {
+                //ac[1]->field_0x121C = 1;
+            }
+            if (dComIfGs_isEventBit(0x301) && dComIfGs_isEventBit(0x480)) {
+                //ac[2]->field_0x121C = 1;
+            }
+        }
+        else {
+            //ac[0]->field_0x121C = 1;
+            //ac[1]->field_0x121C = 1;
         }
     }
+
+    fopAcM_delete(i_this);
 }
 
-/* 0000081C-00000914       .text event_start_check__FP12andsw0_class */
 static void event_start_check(andsw0_class* i_this) {
+    /* Nonmatching */
     switch (i_this->mEventState) {
     case 0:
-    default:
         if (i_this->mEventIdx != -1 && fopAcM_isSwitch(i_this, i_this->mSwitchToSet)) {
             if (i_this->mEvtInfo.i_checkCommandDemoAccrpt()) {
                 i_this->mEventState++;
             } else {
-                fopAcM_orderOtherEventId(i_this, i_this->mEventIdx, i_this->mEventMapToolNo, 0xFFFF, 0, 1);
+                fopAcM_orderOtherEventId(i_this, i_this->mEventIdx, i_this->mEventNo, 0xFFFF, 0, 1);
             }
         }
+
+        break;
     case 1:
         if (dComIfGp_evmng_endCheck(i_this->mEventIdx)) {
             dComIfGp_event_onEventFlag(8);
@@ -98,8 +282,7 @@ static void event_start_check(andsw0_class* i_this) {
     }
 }
 
-/* 00000914-00000964       .text daAndsw0_Execute__FP12andsw0_class */
-s32 daAndsw0_Execute(andsw0_class* i_this) {
+static s32 daAndsw0_Execute(andsw0_class* i_this) {
     event_start_check(i_this);
     if (i_this->mNumSwitchesToCheck == 0xFF)
         hajimarinomori_check(i_this);
@@ -108,18 +291,15 @@ s32 daAndsw0_Execute(andsw0_class* i_this) {
     return 1;
 }
 
-/* 00000964-0000096C       .text daAndsw0_IsDelete__FP12andsw0_class */
-s32 daAndsw0_IsDelete(andsw0_class*) {
+static s32 daAndsw0_IsDelete(andsw0_class*) {
     return 1;
 }
 
-/* 0000096C-00000974       .text daAndsw0_Delete__FP12andsw0_class */
-s32 daAndsw0_Delete(andsw0_class*) {
+static s32 daAndsw0_Delete(andsw0_class*) {
     return 1;
 }
 
-/* 00000974-00000A64       .text daAndsw0_Create__FP10fopAc_ac_c */
-s32 daAndsw0_Create(fopAc_ac_c* ac) {
+static s32 daAndsw0_Create(fopAc_ac_c* ac) {
     fopAcM_SetupActor(ac, andsw0_class);
 
     andsw0_class * i_this = (andsw0_class *)ac;
@@ -127,9 +307,9 @@ s32 daAndsw0_Create(fopAc_ac_c* ac) {
     i_this->mBehaviorType = (fopAcM_GetParam(ac) >> 8) & 0xFF;
     i_this->mSwitchToSet = (fopAcM_GetParam(ac) >> 24) & 0xFF;
     i_this->mFirstSwitchToCheck = (fopAcM_GetParam(ac) >> 16) & 0xFF;
-    i_this->mTimer = (i_this->orig.angle.z & 0xFF) * 16;
-    i_this->mEventMapToolNo = i_this->orig.angle.x;
-    i_this->mEventIdx = dComIfGp_evmng_getEventIdx(NULL, i_this->mEventMapToolNo);
+    i_this->mTimer = (i_this->orig.angle.z & 0xFF) * 0xF;
+    i_this->mEventNo = i_this->orig.angle.x;
+    i_this->mEventIdx = dComIfGp_evmng_getEventIdx(NULL, i_this->mEventNo);
     if (i_this->mBehaviorType == 2)
         i_this->mAction = ACT_TIMER;
     if (i_this->mFirstSwitchToCheck == 0xFF)
@@ -142,3 +322,27 @@ s32 daAndsw0_Create(fopAc_ac_c* ac) {
     return cPhs_COMPLEATE_e;
 }
 
+static actor_method_class l_daAndsw0_Method = {
+    (process_method_func)daAndsw0_Create,
+    (process_method_func)daAndsw0_Delete,
+    (process_method_func)daAndsw0_Execute,
+    (process_method_func)daAndsw0_IsDelete,
+    (process_method_func)daAndsw0_Draw,
+};
+
+extern actor_process_profile_definition g_profile_ANDSW0 = {
+    fpcLy_CURRENT_e,
+    7,
+    fpcPi_CURRENT_e,
+    PROC_ANDSW0,
+    &g_fpcLf_Method.mBase,
+    sizeof(andsw0_class),
+    0,
+    0,
+    &g_fopAc_Method.base,
+    0x0135,
+    &l_daAndsw0_Method,
+    0x00040000,
+    fopAc_ACTOR_e,
+    fopAc_CULLBOX_0_e,
+};
diff --git a/src/d/actor/d_a_kaji.cpp b/src/d/actor/d_a_kaji.cpp
index d3f850ee..c420f407 100644
--- a/src/d/actor/d_a_kaji.cpp
+++ b/src/d/actor/d_a_kaji.cpp
@@ -3,41 +3,171 @@
 // Translation Unit: d_a_kaji.cpp
 //
 
-#include "d_a_kaji.h"
+#include "f_op/f_op_actor_mng.h"
+#include "JSystem/JKernel/JKRHeap.h"
+#include "JSystem/JUtility/JUTAssert.h"
+#include "m_Do/m_Do_mtx.h"
+#include "d/d_com_inf_game.h"
+#include "d/d_s_play.h"
+#include "d/actor/d_a_obj_pirateship.h"
+#include "d/d_procname.h"
 #include "dolphin/types.h"
 
+extern dScnPly_reg_HIO_c g_regHIO;
+
+struct daKaji_c : fopAc_ac_c {
+public:
+    BOOL CreateHeap();
+    inline s32 _create();
+    inline BOOL _delete();
+    inline BOOL _execute();
+    inline bool _draw();
+
+public:
+    /* 0x290 */ request_of_phase_process_class mPhs;
+    /* 0x298 */ u8 pad[0x29C - 0x298];
+    /* 0x29C */ mDoExt_McaMorf* mpMorf;
+    /* 0x2A0 */ Mtx mMtx;
+    
+    static const char M_arcname[];
+};
+
+static daObjPirateship::Act_c* l_p_ship;
+
+const char daKaji_c::M_arcname[] = "Kaji";
+
 /* 00000078-00000098       .text CheckCreateHeap__FP10fopAc_ac_c */
-void CheckCreateHeap(fopAc_ac_c*) {
-    /* Nonmatching */
+static BOOL CheckCreateHeap(fopAc_ac_c* i_this) {
+    return ((daKaji_c*)i_this)->CreateHeap();
 }
 
 /* 00000098-000001F4       .text CreateHeap__8daKaji_cFv */
-void daKaji_c::CreateHeap() {
-    /* Nonmatching */
+BOOL daKaji_c::CreateHeap() {
+    J3DModelData* modelData = (J3DModelData*)dComIfG_getObjectRes(M_arcname, 0x11); // asoda.bdl
+    JUT_ASSERT(0x55, modelData != 0);
+    
+    mpMorf = new mDoExt_McaMorf(
+        modelData,
+        NULL, NULL,
+        (J3DAnmTransformKey*)dComIfG_getObjectRes("Kaji", 0xE), // kj_wait.bck
+        2, 0.0f, 0, -1, 1,
+        dComIfG_getObjectRes("Kaji", 0x8), // kj_wait.bas
+        0x00080000, 
+        0x11000002
+    );
+    
+    return mpMorf && mpMorf->getModel();
+}
+
+s32 daKaji_c::_create() {
+    fopAcM_SetupActor(this, daKaji_c);
+    
+    s32 phase_state = dComIfG_resLoad(&mPhs, M_arcname);
+    if (phase_state == cPhs_COMPLEATE_e) {
+        if (fopAcM_entrySolidHeap(this, (heapCallbackFunc)&CheckCreateHeap, 0x660)) {
+            mDoMtx_stack_c::transS(getPosition());
+            mDoMtx_stack_c::YrotM(shape_angle.y);
+            mDoMtx_stack_c::scaleM(mScale.x, mScale.y, mScale.z);
+            MTXCopy(mDoMtx_stack_c::get(), mMtx);
+            
+            l_p_ship = (daObjPirateship::Act_c*)fopAcM_SearchByID(mParentPcId);
+        } else {
+            return cPhs_ERROR_e;
+        }
+        
+        fopAcM_SetMtx(this, mpMorf->getModel()->getBaseTRMtx());
+        fopAcM_setCullSizeBox(this, -80.0f, -80.0f, -20.0f, 80.0f, 80.0f, 20.0f);
+        
+        MTXCopy(mpMorf->getModel()->getBaseTRMtx(), mMtx);
+    }
+    
+    return phase_state;
+}
+
+BOOL daKaji_c::_delete() {
+    dComIfG_resDelete(&mPhs, M_arcname);
+    return TRUE;
+}
+
+BOOL daKaji_c::_execute() {
+    // Copy the ship's transform (plus an offset) to the helm.
+    cXyz* offset = &cXyz(0.0f, 740.0f, -858.0f);
+    offset->y += g_regHIO.mChild[10].mFloatRegs[10];
+    offset->z += g_regHIO.mChild[10].mFloatRegs[11];
+    cMtx_multVec( l_p_ship->mpModel->getBaseTRMtx(), offset, &current.pos);
+    
+    daObjPirateship::Act_c* ship = l_p_ship;
+    shape_angle = ship->shape_angle;
+    current.angle = shape_angle;
+    
+    mpMorf->play(NULL, 0, 0);
+    
+    mpMorf->getModel()->setBaseScale(mScale);
+    PSMTXTrans(mDoMtx_stack_c::get(), current.pos.x, current.pos.y, current.pos.z);
+    mDoMtx_stack_c::ZXYrotM(shape_angle.x, shape_angle.y, shape_angle.z);
+    
+    mpMorf->getModel()->i_setBaseTRMtx(mDoMtx_stack_c::get());
+    MTXCopy(mDoMtx_stack_c::get(), mMtx);
+    
+    return FALSE;
+}
+
+bool daKaji_c::_draw() {
+    if (!l_p_ship->unk2CC) {
+        return true;
+    }
+    g_env_light.settingTevStruct(TEV_TYPE_ACTOR, &current.pos, &mTevStr);
+    g_env_light.setLightTevColorType(mpMorf->getModel(), &mTevStr);
+    mpMorf->update();
+    return true;
 }
 
 /* 000001F4-00000344       .text daKajiCreate__FPv */
-void daKajiCreate(void*) {
-    /* Nonmatching */
+static s32 daKajiCreate(void* i_this) {
+    return ((daKaji_c*)i_this)->_create();
 }
 
 /* 00000344-00000374       .text daKajiDelete__FPv */
-void daKajiDelete(void*) {
-    /* Nonmatching */
+static BOOL daKajiDelete(void* i_this) {
+    return ((daKaji_c*)i_this)->_delete();
 }
 
 /* 00000374-000004D4       .text daKajiExecute__FPv */
-void daKajiExecute(void*) {
-    /* Nonmatching */
+static BOOL daKajiExecute(void* i_this) {
+    return ((daKaji_c*)i_this)->_execute();
 }
 
 /* 000004D4-00000568       .text daKajiDraw__FPv */
-void daKajiDraw(void*) {
-    /* Nonmatching */
+static BOOL daKajiDraw(void* i_this) {
+    return ((daKaji_c*)i_this)->_draw();
 }
 
 /* 00000568-00000570       .text daKajiIsDelete__FPv */
-void daKajiIsDelete(void*) {
-    /* Nonmatching */
+static BOOL daKajiIsDelete(void* actor) {
+    return TRUE;
 }
 
+static actor_method_class daKajiMethodTable = {
+    (process_method_func)daKajiCreate, 
+    (process_method_func)daKajiDelete,
+    (process_method_func)daKajiExecute,
+    (process_method_func)daKajiIsDelete,
+    (process_method_func)daKajiDraw,
+};
+
+extern actor_process_profile_definition g_profile_Kaji = {
+    fpcLy_CURRENT_e,
+    3,
+    fpcLy_CURRENT_e,
+    PROC_Kaji,
+    &g_fpcLf_Method.mBase,
+    sizeof(daKaji_c),
+    0,
+    0,
+    &g_fopAc_Method.base,
+    0x01AC,
+    &daKajiMethodTable,
+    0x00040100,
+    fopAc_ACTOR_e,
+    fopAc_CULLBOX_CUSTOM_e,
+};
diff --git a/src/d/actor/d_a_obj_pirateship.cpp b/src/d/actor/d_a_obj_pirateship.cpp
index 5c381a31..7e0dac19 100644
--- a/src/d/actor/d_a_obj_pirateship.cpp
+++ b/src/d/actor/d_a_obj_pirateship.cpp
@@ -3,7 +3,7 @@
 // Translation Unit: d_a_obj_pirateship.cpp
 //
 
-#include "d_a_obj_pirateship.h"
+#include "d/actor/d_a_obj_pirateship.h"
 #include "dolphin/types.h"
 
 /* 000000EC-000000FC       .text ride_call_back__FP4dBgWP10fopAc_ac_cP10fopAc_ac_c */
diff --git a/src/d/d_com_inf_game.cpp b/src/d/d_com_inf_game.cpp
index 8daaed28..ad4681cc 100644
--- a/src/d/d_com_inf_game.cpp
+++ b/src/d/d_com_inf_game.cpp
@@ -183,11 +183,11 @@ int dComIfG_play_c::getLayerNo(int i_roomNo) {
     int layer = dComIfGp_getStartStageLayer();
 
     if (layer < 0) {
-        int hour = dKy_getdaytime_hour();
+        layer = dKy_getdaytime_hour();
         if (dKy_checkEventNightStop()) {
             layer = 1;
         } else {
-            layer = (hour >= 6 && hour < 18) == 0;
+            layer = (layer >= 6 && layer < 18) ? 0 : 1;
         }
 
         if (strcmp(dComIfGp_getStartStageName(), "sea") == 0) {
@@ -494,12 +494,12 @@ int dComIfG_resetToOpening(scene_class* i_scene) {
 
 /* 800532D8-80053330       .text phase_1__FPc */
 // matches with stringbase
-int phase_1(char* i_arcName) {
+static int phase_1(char* i_arcName) {
     return !dComIfG_setObjectRes(i_arcName, (u8)0, NULL) ? cPhs_ERROR_e : cPhs_NEXT_e;
 }
 
 /* 80053330-80053388       .text phase_2__FPc */
-int phase_2(char* i_arcName) {
+static int phase_2(char* i_arcName) {
     int syncStatus = dComIfG_syncObjectRes(i_arcName);
 
     if (syncStatus < 0) {
@@ -510,7 +510,7 @@ int phase_2(char* i_arcName) {
 }
 
 /* 80053388-80053390       .text phase_3__FPc */
-int phase_3(char* i_arcName) {
+static int phase_3(char* i_arcName) {
     return cPhs_COMPLEATE_e;
 }
 
@@ -711,7 +711,6 @@ BOOL dComIfGs_isStageLife(int i_stageNo) {
 }
 
 /* 80053B30-80053F70       .text dComIfGs_checkGetItem__FUc */
-// NONMATCHING - almost, just a couple small things
 u8 dComIfGs_checkGetItem(u8 i_itemNo) {
     u8 get_item = 0;
 
@@ -819,15 +818,15 @@ u8 dComIfGs_checkGetItem(u8 i_itemNo) {
             } else if (i < 24) {
                 item = NO_ITEM;
             } else if (i < 32) {
-                item = g_dComIfG_gameInfo.save.getPlayer().getGetItem().mItemFlags[i - 0x18];
+                item = dComIfGs_getBeast(i - 24);
             } else if (i < 36) {
                 item = NO_ITEM;
             } else if (i < 44) {
-                item = g_dComIfG_gameInfo.save.getPlayer().getGetItem().mItemFlags[i - 0x1C];
+                item = dComIfGs_getBait(i - 36);
             } else if (i < 48) {
                 item = NO_ITEM;
             } else if (i < 56) {
-                item = g_dComIfG_gameInfo.save.getPlayer().getGetItem().mItemFlags[i - 0x20];
+                item = dComIfGs_getReserve(i - 48);
             } else {
                 item = NO_ITEM;
             }
@@ -843,8 +842,8 @@ u8 dComIfGs_checkGetItem(u8 i_itemNo) {
             }
         }
 
-        if (i_itemNo >= 0xBF && i_itemNo <= 0xFE &&
-            g_dComIfG_gameInfo.save.getPlayer().getMap().isGetMap(i_itemNo - 1))
+        if (i_itemNo >= 0xBF && i_itemNo <= NO_ITEM - 1 &&
+            dComIfGs_isGetCollectMap(NO_ITEM - i_itemNo))
         {
             get_item++;
         }
@@ -855,15 +854,229 @@ u8 dComIfGs_checkGetItem(u8 i_itemNo) {
 }
 
 /* 80053F70-80054578       .text dComIfGs_checkGetItemNum__FUc */
-void dComIfGs_checkGetItemNum(u8) {
-    /* Nonmatching */
+u8 dComIfGs_checkGetItemNum(u8 i_itemNo) {
+    u8 get_item = 0;
+
+    switch (i_itemNo) {
+    case TACT_SONG1:
+        if (dComIfGs_isTact(0)) {
+            get_item = 1;
+        }
+        break;
+    case TACT_SONG2:
+        if (dComIfGs_isTact(1)) {
+            get_item = 1;
+        }
+        break;
+    case TACT_SONG3:
+        if (dComIfGs_isTact(2)) {
+            get_item = 1;
+        }
+        break;
+    case TACT_SONG4:
+        if (dComIfGs_isTact(3)) {
+            get_item = 1;
+        }
+        break;
+    case TACT_SONG5:
+        if (dComIfGs_isTact(4)) {
+            get_item = 1;
+        }
+        break;
+    case TACT_SONG6:
+        if (dComIfGs_isTact(5)) {
+            get_item = 1;
+        }
+        break;
+    case TRIFORCE1:
+        if (dComIfGs_isTriforce(0)) {
+            get_item = 1;
+        }
+        break;
+    case TRIFORCE2:
+        if (dComIfGs_isTriforce(1)) {
+            get_item = 1;
+        }
+        break;
+    case TRIFORCE3:
+        if (dComIfGs_isTriforce(2)) {
+            get_item = 1;
+        }
+        break;
+    case TRIFORCE4:
+        if (dComIfGs_isTriforce(3)) {
+            get_item = 1;
+        }
+        break;
+    case TRIFORCE5:
+        if (dComIfGs_isTriforce(4)) {
+            get_item = 1;
+        }
+        break;
+    case TRIFORCE6:
+        if (dComIfGs_isTriforce(5)) {
+            get_item = 1;
+        }
+        break;
+    case TRIFORCE7:
+        if (dComIfGs_isTriforce(6)) {
+            get_item = 1;
+        }
+        break;
+    case TRIFORCE8:
+        if (dComIfGs_isTriforce(7)) {
+            get_item = 1;
+        }
+        break;
+    case PEARL1:
+        if (dComIfGs_isSymbol(0)) {
+            get_item = 1;
+        }
+        break;
+    case PEARL2:
+        if (dComIfGs_isSymbol(1)) {
+            get_item = 1;
+        }
+        break;
+    case PEARL3:
+        if (dComIfGs_isSymbol(2)) {
+            get_item = 1;
+        }
+        break;
+    case PIRATES_OMAMORI:
+        if (dComIfGs_isCollect(3, 0)) {
+            get_item = 1;
+        }
+        break;
+    case HEROS_OMAMORI:
+        if (dComIfGs_isCollect(4, 0)) {
+            get_item = 1;
+        }
+        break;
+    case BOW:
+        if (dComIfGs_getItem(12)) {
+            get_item = dComIfGs_getArrowNum();
+        }
+        break;
+    case BOMB_BAG:
+        if (dComIfGs_getItem(13)) {
+            get_item = dComIfGs_getBombNum();
+        }
+        break;
+    case SKULL_NECKLACE:
+        for (int i = 0; i < 8; i++) {
+            if (dComIfGs_getBeast(i) == SKULL_NECKLACE) {
+                get_item = dComIfGs_getBeastNum(0);
+            }
+        }
+        break;
+    case BOKOBABA_SEED:
+        for (int i = 0; i < 8; i++) {
+            if (dComIfGs_getBeast(i) == BOKOBABA_SEED) {
+                get_item = dComIfGs_getBeastNum(1);
+            }
+        }
+        break;
+    case GOLDEN_FEATHER:
+        for (int i = 0; i < 8; i++) {
+            if (dComIfGs_getBeast(i) == GOLDEN_FEATHER) {
+                get_item = dComIfGs_getBeastNum(2);
+            }
+        }
+        break;
+    case BOKO_BELT:
+        for (int i = 0; i < 8; i++) {
+            if (dComIfGs_getBeast(i) == BOKO_BELT) {
+                get_item = dComIfGs_getBeastNum(3);
+            }
+        }
+        break;
+    case RED_JELLY:
+        for (int i = 0; i < 8; i++) {
+            if (dComIfGs_getBeast(i) == RED_JELLY) {
+                get_item = dComIfGs_getBeastNum(4);
+            }
+        }
+        break;
+    case GREEN_JELLY:
+        for (int i = 0; i < 8; i++) {
+            if (dComIfGs_getBeast(i) == GREEN_JELLY) {
+                get_item = dComIfGs_getBeastNum(5);
+            }
+        }
+        break;
+    case BLUE_JELLY:
+        for (int i = 0; i < 8; i++) {
+            if (dComIfGs_getBeast(i) == BLUE_JELLY) {
+                get_item = dComIfGs_getBeastNum(6);
+            }
+        }
+        break;
+    case PENDANT:
+        for (int i = 0; i < 8; i++) {
+            if (dComIfGs_getBeast(i) == PENDANT) {
+                get_item = dComIfGs_getBeastNum(7);
+            }
+        }
+        break;
+    default:
+        u8 item = 0;
+        for (int i = 0; i < 60; i++) {
+            if (i < 21) {
+                item = dComIfGs_getItem(i);
+            } else if (i < 24) {
+                item = NO_ITEM;
+            } else if (i < 32) {
+                item = dComIfGs_getBeast(i - 24);
+            } else if (i < 36) {
+                item = NO_ITEM;
+            } else if (i < 44) {
+                item = dComIfGs_getBait(i - 36);
+            } else if (i < 48) {
+                item = NO_ITEM;
+            } else if (i < 56) {
+                item = dComIfGs_getReserve(i - 48);
+            } else {
+                item = NO_ITEM;
+            }
+
+            if (i_itemNo == item) {
+                get_item = 1;
+            }
+        }
+
+        for (int i = 0; i < 3; i++) {
+            if (i_itemNo == dComIfGs_getSelectEquip(i)) {
+                get_item = 1;
+            }
+        }
+
+        if (i_itemNo >= 0xBF && i_itemNo <= NO_ITEM - 1 &&
+            dComIfGs_isGetCollectMap(NO_ITEM - i_itemNo))
+        {
+            get_item = 1;
+        }
+        break;
+    }
+
+    return get_item;
 }
 
 /* 80054578-8005468C       .text
  * dComIfGd_setShadow__FUlScP8J3DModelP4cXyzffffR13cBgS_PolyInfoP12dKy_tevstr_csfP9_GXTexObj */
-void dComIfGd_setShadow(u32, s8, J3DModel*, cXyz*, f32, f32, f32, f32, cBgS_PolyInfo&,
-                        dKy_tevstr_c*, s16, f32, _GXTexObj*) {
-    /* Nonmatching */
+int dComIfGd_setShadow(u32 id, s8 param_2, J3DModel* pModel, cXyz* pPos, f32 param_5, f32 param_6,
+                       f32 y, f32 param_8, cBgS_PolyInfo& pFloorPoly, dKy_tevstr_c* param_10,
+                       s16 rotY, f32 param_12, GXTexObj* pTexObj) {
+    if (param_8 <= -1000000000.0f) {
+        return 0;
+    }
+
+    int sid = dComIfGd_setRealShadow2(id, param_2, pModel, pPos, param_5, y - param_8, param_10);
+    if (sid == 0) {
+        cXyz i_pos(pPos->x, y, pPos->z);
+        dComIfGd_setSimpleShadow2(&i_pos, param_8, param_6, pFloorPoly, rotY, param_12, pTexObj);
+    }
+    return sid;
 }
 
 /* 8005468C-800547BC       .text getSceneList__Fi */
@@ -880,8 +1093,20 @@ stage_scls_info_class* getSceneList(int i_no) {
 }
 
 /* 800547BC-80054870       .text dComIfGd_getMeshSceneList__FR3Vec */
-stage_scls_info_class* dComIfGd_getMeshSceneList(Vec&) {
-    /* Nonmatching */
+stage_scls_info_class* dComIfGd_getMeshSceneList(Vec& vec) {
+    s32 x = (s32)((vec.x + 350000.0f) * 2e-05f);
+    s32 z = (s32)((vec.z + 350000.0f) * 2e-05f);
+    if (x < 0) {
+        x = 0;
+    } else if (13 < x) {
+        x = 13;
+    }
+    if (z < 0) {
+        z = 0;
+    } else if (13 < z) {
+        z = 13;
+    }
+    return getSceneList((x & 1) + ((x >> 1) + (z >> 1) * 7) * 4 + (z & 1) * 2);
 }
 
 /* 80054870-800548FC       .text dComIfGs_checkSeaLandingEvent__FSc */
@@ -926,7 +1151,7 @@ void dComIfGs_setGameStartStage() {
     };
 
     check_data* data_p = l_checkData;
-    for (int i = 0; i < 5; i++) {
+    for (u32 i = 0; i < 5; i++) {
         if (data_p->mbHasEvent == true && dComIfGs_isEventBit(data_p->mEvent)) {
             break;
         }
diff --git a/src/d/d_drawlist.cpp b/src/d/d_drawlist.cpp
index 34570262..cc53b8f0 100644
--- a/src/d/d_drawlist.cpp
+++ b/src/d/d_drawlist.cpp
@@ -7,12 +7,12 @@
 #include "dolphin/types.h"
 
 /* 800804A4-800804C0       .text setViewPort__14dDlst_window_cFffffff */
-void dDlst_window_c::setViewPort(float, float, float, float, float, float) {
+void dDlst_window_c::setViewPort(f32, f32, f32, f32, f32, f32) {
     /* Nonmatching */
 }
 
 /* 800804C0-800804D4       .text setScissor__14dDlst_window_cFffff */
-void dDlst_window_c::setScissor(float, float, float, float) {
+void dDlst_window_c::setScissor(f32, f32, f32, f32) {
     /* Nonmatching */
 }
 
@@ -37,7 +37,7 @@ void dDlst_2DT2_c::draw() {
 }
 
 /* 800811E8-800812F4       .text init__12dDlst_2DT2_cFP7ResTIMGffffUcUcUcff */
-void dDlst_2DT2_c::init(ResTIMG*, float, float, float, float, unsigned char, unsigned char, unsigned char, float, float) {
+void dDlst_2DT2_c::init(ResTIMG*, f32, f32, f32, f32, u8, u8, u8, f32, f32) {
     /* Nonmatching */
 }
 
@@ -47,22 +47,22 @@ void dDlst_2DM_c::draw() {
 }
 
 /* 800817CC-80081850       .text init__11dDlst_2Dm_cFP7ResTIMGP7ResTIMGff */
-void dDlst_2Dm_c::init(ResTIMG*, ResTIMG*, float, float) {
+void dDlst_2Dm_c::init(ResTIMG*, ResTIMG*, f32, f32) {
     /* Nonmatching */
 }
 
 /* 80081850-80081864       .text setPos__11dDlst_2Dm_cFssss */
-void dDlst_2Dm_c::setPos(short, short, short, short) {
+void dDlst_2Dm_c::setPos(s16, s16, s16, s16) {
     /* Nonmatching */
 }
 
 /* 80081864-80081870       .text setScale__11dDlst_2Dm_cFff */
-void dDlst_2Dm_c::setScale(float, float) {
+void dDlst_2Dm_c::setScale(f32, f32) {
     /* Nonmatching */
 }
 
 /* 80081870-80081888       .text setScroll__11dDlst_2Dm_cFiss */
-void dDlst_2Dm_c::setScroll(int, short, short) {
+void dDlst_2Dm_c::setScroll(int, s16, s16) {
     /* Nonmatching */
 }
 
@@ -77,7 +77,7 @@ void dDlst_2DMt_c::draw() {
 }
 
 /* 80082130-800821B0       .text __ct__10dDlst_2D_cFP7ResTIMGssUc */
-dDlst_2D_c::dDlst_2D_c(ResTIMG*, short, short, unsigned char) {
+dDlst_2D_c::dDlst_2D_c(ResTIMG*, s16, s16, u8) {
     /* Nonmatching */
 }
 
@@ -97,17 +97,17 @@ void cM_rnd_c::get() {
 }
 
 /* 80082368-800823A0       .text getF__8cM_rnd_cFf */
-void cM_rnd_c::getF(float) {
+void cM_rnd_c::getF(f32) {
     /* Nonmatching */
 }
 
 /* 800823A0-800823E8       .text getFX__8cM_rnd_cFf */
-void cM_rnd_c::getFX(float) {
+void cM_rnd_c::getFX(f32) {
     /* Nonmatching */
 }
 
 /* 800823E8-80082424       .text getValue__8cM_rnd_cFff */
-void cM_rnd_c::getValue(float, float) {
+void cM_rnd_c::getValue(f32, f32) {
     /* Nonmatching */
 }
 
@@ -117,17 +117,17 @@ void dDlst_effectLine_c::draw() {
 }
 
 /* 80082794-80082828       .text update__18dDlst_effectLine_cFR4cXyzR8_GXColorUsUsUsUsffff */
-void dDlst_effectLine_c::update(cXyz&, _GXColor&, unsigned short, unsigned short, unsigned short, unsigned short, float, float, float, float) {
+void dDlst_effectLine_c::update(cXyz&, _GXColor&, u16, u16, u16, u16, f32, f32, f32, f32) {
     /* Nonmatching */
 }
 
 /* 80082828-80082838       .text set__22dDlst_alphaModelData_cFUcPA4_fUc */
-void dDlst_alphaModelData_c::set(unsigned char, float(*)[4], unsigned char) {
+void dDlst_alphaModelData_c::set(u8, f32(*)[4], u8) {
     /* Nonmatching */
 }
 
 /* 80082838-80082E44       .text draw__22dDlst_alphaModelData_cFPA4_f */
-void dDlst_alphaModelData_c::draw(float(*)[4]) {
+void dDlst_alphaModelData_c::draw(f32(*)[4]) {
     /* Nonmatching */
 }
 
@@ -152,12 +152,12 @@ dDlst_alphaModelData_c::dDlst_alphaModelData_c() {
 }
 
 /* 80082F3C-80082F9C       .text set__18dDlst_alphaModel_cFUcPA4_fUc */
-void dDlst_alphaModel_c::set(unsigned char, float(*)[4], unsigned char) {
+void dDlst_alphaModel_c::set(u8, f32(*)[4], u8) {
     /* Nonmatching */
 }
 
 /* 80082F9C-80083064       .text draw__18dDlst_alphaModel_cFPA4_f */
-void dDlst_alphaModel_c::draw(float(*)[4]) {
+void dDlst_alphaModel_c::draw(f32(*)[4]) {
     /* Nonmatching */
 }
 
@@ -167,7 +167,7 @@ void dDlst_alphaModelPacket::draw() {
 }
 
 /* 800832C4-800833CC       .text set__18dDlst_shadowPoly_cFP10cBgD_Vtx_tUsUsUsP8cM3dGPla */
-void dDlst_shadowPoly_c::set(cBgD_Vtx_t*, unsigned short, unsigned short, unsigned short, cM3dGPla*) {
+void dDlst_shadowPoly_c::set(cBgD_Vtx_t*, u16, u16, u16, cM3dGPla*) {
     /* Nonmatching */
 }
 
@@ -207,7 +207,7 @@ void dDlst_shadowReal_c::reset() {
 }
 
 /* 80083850-8008398C       .text imageDraw__18dDlst_shadowReal_cFPA4_f */
-void dDlst_shadowReal_c::imageDraw(float(*)[4]) {
+void dDlst_shadowReal_c::imageDraw(f32(*)[4]) {
     /* Nonmatching */
 }
 
@@ -227,7 +227,7 @@ void seaRealCallBack(void*, cXyz&, cXyz&, cXyz&) {
 }
 
 /* 80083E18-800840B0       .text realPolygonCheck__FP4cXyzffP4cXyzP18dDlst_shadowPoly_c */
-void realPolygonCheck(cXyz*, float, float, cXyz*, dDlst_shadowPoly_c*) {
+void realPolygonCheck(cXyz*, f32, f32, cXyz*, dDlst_shadowPoly_c*) {
     /* Nonmatching */
 }
 
@@ -242,17 +242,17 @@ cBgS_ShdwDraw::~cBgS_ShdwDraw() {
 }
 
 /* 800841B0-8008450C       .text setShadowRealMtx__FPA4_fPA4_fPA4_fP4cXyzP4cXyzffP18dDlst_shadowPoly_cf */
-void setShadowRealMtx(float(*)[4], float(*)[4], float(*)[4], cXyz*, cXyz*, float, float, dDlst_shadowPoly_c*, float) {
+void setShadowRealMtx(f32(*)[4], f32(*)[4], f32(*)[4], cXyz*, cXyz*, f32, f32, dDlst_shadowPoly_c*, f32) {
     /* Nonmatching */
 }
 
 /* 8008450C-800846C8       .text set__18dDlst_shadowReal_cFUlScP8J3DModelP4cXyzffP12dKy_tevstr_c */
-void dDlst_shadowReal_c::set(unsigned long, signed char, J3DModel*, cXyz*, float, float, dKy_tevstr_c*) {
+void dDlst_shadowReal_c::set(u32, s8, J3DModel*, cXyz*, f32, f32, dKy_tevstr_c*) {
     /* Nonmatching */
 }
 
 /* 800846C8-80084844       .text set2__18dDlst_shadowReal_cFUlScP8J3DModelP4cXyzffP12dKy_tevstr_c */
-void dDlst_shadowReal_c::set2(unsigned long, signed char, J3DModel*, cXyz*, float, float, dKy_tevstr_c*) {
+void dDlst_shadowReal_c::set2(u32, s8, J3DModel*, cXyz*, f32, f32, dKy_tevstr_c*) {
     /* Nonmatching */
 }
 
@@ -267,7 +267,7 @@ void dDlst_shadowSimple_c::draw() {
 }
 
 /* 80084AC8-80084D48       .text set__20dDlst_shadowSimple_cFP4cXyzffP4cXyzsfP9_GXTexObj */
-void dDlst_shadowSimple_c::set(cXyz*, float, float, cXyz*, short, float, _GXTexObj*) {
+void dDlst_shadowSimple_c::set(cXyz*, f32, f32, cXyz*, s16, f32, _GXTexObj*) {
     /* Nonmatching */
 }
 
@@ -282,32 +282,32 @@ void dDlst_shadowControl_c::reset() {
 }
 
 /* 80084DEC-80084EF0       .text imageDraw__21dDlst_shadowControl_cFPA4_f */
-void dDlst_shadowControl_c::imageDraw(float(*)[4]) {
+void dDlst_shadowControl_c::imageDraw(f32(*)[4]) {
     /* Nonmatching */
 }
 
 /* 80084EF0-800850D4       .text draw__21dDlst_shadowControl_cFPA4_f */
-void dDlst_shadowControl_c::draw(float(*)[4]) {
+void dDlst_shadowControl_c::draw(f32(*)[4]) {
     /* Nonmatching */
 }
 
 /* 800850D4-80085170       .text setReal__21dDlst_shadowControl_cFUlScP8J3DModelP4cXyzffP12dKy_tevstr_c */
-void dDlst_shadowControl_c::setReal(unsigned long, signed char, J3DModel*, cXyz*, float, float, dKy_tevstr_c*) {
+void dDlst_shadowControl_c::setReal(u32, s8, J3DModel*, cXyz*, f32, f32, dKy_tevstr_c*) {
     /* Nonmatching */
 }
 
 /* 80085170-8008520C       .text setReal2__21dDlst_shadowControl_cFUlScP8J3DModelP4cXyzffP12dKy_tevstr_c */
-void dDlst_shadowControl_c::setReal2(unsigned long, signed char, J3DModel*, cXyz*, float, float, dKy_tevstr_c*) {
+void dDlst_shadowControl_c::setReal2(u32, s8, J3DModel*, cXyz*, f32, f32, dKy_tevstr_c*) {
     /* Nonmatching */
 }
 
 /* 8008520C-80085274       .text addReal__21dDlst_shadowControl_cFUlP8J3DModel */
-void dDlst_shadowControl_c::addReal(unsigned long, J3DModel*) {
+void dDlst_shadowControl_c::addReal(u32, J3DModel*) {
     /* Nonmatching */
 }
 
 /* 80085274-800852D8       .text setSimple__21dDlst_shadowControl_cFP4cXyzffP4cXyzsfP9_GXTexObj */
-void dDlst_shadowControl_c::setSimple(cXyz*, float, float, cXyz*, short, float, _GXTexObj*) {
+void dDlst_shadowControl_c::setSimple(cXyz*, f32, f32, cXyz*, s16, f32, _GXTexObj*) {
     /* Nonmatching */
 }
 
@@ -327,12 +327,12 @@ void dDlst_mirrorPacket::init(ResTIMG*) {
 }
 
 /* 80085624-80085808       .text mirrorPolygonCheck__FP4cXyzP4cXyzfP18dDlst_shadowPoly_c */
-void mirrorPolygonCheck(cXyz*, cXyz*, float, dDlst_shadowPoly_c*) {
+void mirrorPolygonCheck(cXyz*, cXyz*, f32, dDlst_shadowPoly_c*) {
     /* Nonmatching */
 }
 
 /* 80085808-800859DC       .text update__18dDlst_mirrorPacketFPA4_fUcf */
-void dDlst_mirrorPacket::update(float(*)[4], unsigned char, float) {
+void dDlst_mirrorPacket::update(f32(*)[4], u8, f32) {
     /* Nonmatching */
 }
 
@@ -347,7 +347,7 @@ void dDlst_alphaInvVolPacket::draw() {
 }
 
 /* 80085BBC-80085BFC       .text newData__13dDlst_peekZ_cFssPUl */
-void dDlst_peekZ_c::newData(short, short, unsigned long*) {
+void dDlst_peekZ_c::newData(s16, s16, u32*) {
     /* Nonmatching */
 }
 
@@ -427,12 +427,12 @@ void dDlst_list_c::draw(dDlst_base_c**, dDlst_base_c**) {
 }
 
 /* 800865C8-800866C8       .text wipeIn__12dDlst_list_cFfR8_GXColor */
-void dDlst_list_c::wipeIn(float, _GXColor&) {
+void dDlst_list_c::wipeIn(f32, _GXColor&) {
     /* Nonmatching */
 }
 
 /* 800866C8-800866F0       .text wipeIn__12dDlst_list_cFf */
-void dDlst_list_c::wipeIn(float) {
+void dDlst_list_c::wipeIn(f32) {
     /* Nonmatching */
 }
 
@@ -442,7 +442,7 @@ void dDlst_list_c::calcWipe() {
 }
 
 /* 80086790-8008696C       .text dDlst_texSpecmapST__FPC4cXyzPC12dKy_tevstr_cP12J3DModelDataf */
-void dDlst_texSpecmapST(const cXyz*, const dKy_tevstr_c*, J3DModelData*, float) {
+void dDlst_texSpecmapST(const cXyz*, const dKy_tevstr_c*, J3DModelData*, f32) {
     /* Nonmatching */
 }
 
@@ -520,4 +520,3 @@ dDlst_2DPoint_c::~dDlst_2DPoint_c() {
 dDlst_2DTri_c::~dDlst_2DTri_c() {
     /* Nonmatching */
 }
-
diff --git a/src/m_Do/m_Do_controller_pad.cpp b/src/m_Do/m_Do_controller_pad.cpp
index 282ef0ee..1caeb335 100644
--- a/src/m_Do/m_Do_controller_pad.cpp
+++ b/src/m_Do/m_Do_controller_pad.cpp
@@ -4,9 +4,12 @@
 //
 
 #include "m_Do/m_Do_controller_pad.h"
+#include "JSystem/JUtility/JUTGba.h"
 #include "SSystem/SComponent/c_lib.h"
-#include "m_Do/m_Do_main.h"
+#include "f_ap/f_ap_game.h"
 #include "m_Do/m_Do_Reset.h"
+#include "m_Do/m_Do_gba_com.h"
+#include "m_Do/m_Do_main.h"
 
 JUTGamePad* g_mDoCPd_gamePad[4];
 interface_of_controller_pad g_mDoCPd_cpadInfo[4];
@@ -26,6 +29,7 @@ inline void mDoCPd_TRIGGER_CONV(u8 analog, f32& param_1) {
 }
 
 /* 80007598-800078C0       .text mDoCPd_Convert__FP27interface_of_controller_padP10JUTGamePad */
+// NONMATCHING
 static s32 mDoCPd_Convert(interface_of_controller_pad* pInterface, JUTGamePad* pPad) {
     // pInterface->mButtonFlags = pPad->getButton();
     pInterface->mMainStickPosX = pPad->getMainStickX();
@@ -47,7 +51,7 @@ static s32 mDoCPd_Convert(interface_of_controller_pad* pInterface, JUTGamePad* p
 }
 
 /* 800078C0-80007A70       .text mDoCPd_Read__Fv */
-void mDoCPd_Read(void) {
+int mDoCPd_Read() {
     JUTGamePad::read();
 
     if (!mDoRst::isReset() && mDoRst::is3ButtonReset()) {
@@ -61,32 +65,60 @@ void mDoCPd_Read(void) {
     JUTGamePad** pad = g_mDoCPd_gamePad;
     interface_of_controller_pad* interface = g_mDoCPd_cpadInfo;
 
-    for (u32 i = 0; i < 4; i++) {
+    for (int i = 0; i < 4; i++) {
         if (*pad == NULL) {
-            cLib_memSet(interface, 0, sizeof(interface_of_controller_pad));
+            cLib_memSet(interface++, 0, sizeof(interface_of_controller_pad));
         } else {
-            mDoCPd_Convert(interface, *pad);
+            mDoCPd_Convert(interface++, *pad);
         }
 
         pad++;
-        interface++;
     }
-    
-    for (u32 i = 0; i < 4; i++) {
+
+    for (int i = 0; i < 4; i++) {
+        f32 threshold_lo = g_HIO.mTriggerThreshLo;
+        f32 threshold_hi = g_HIO.mTriggerThreshHi;
+
+        f32 trigL = g_mDoCPd_cpadInfo[i].mTriggerLeft;
         g_mDoCPd_cpadInfo[i].mTrigLockL = false;
         g_mDoCPd_cpadInfo[i].mTrigLockR = false;
+
+        if (trigL > threshold_lo) {
+            if (g_mDoCPd_cpadInfo[i].mHoldLockL != true) {
+                g_mDoCPd_cpadInfo[i].mTrigLockL = true;
+            }
+
+            g_mDoCPd_cpadInfo[i].mHoldLockL = true;
+        } else if (trigL < threshold_hi) {
+            g_mDoCPd_cpadInfo[i].mHoldLockL = false;
+        }
+
+        f32 trigR = g_mDoCPd_cpadInfo[i].mTriggerRight;
+        if (trigR > threshold_lo) {
+            if (g_mDoCPd_cpadInfo[i].mHoldLockR != true) {
+                g_mDoCPd_cpadInfo[i].mTrigLockR = true;
+            }
+
+            g_mDoCPd_cpadInfo[i].mHoldLockR = true;
+        } else if (trigR < threshold_hi) {
+            g_mDoCPd_cpadInfo[i].mHoldLockR = false;
+        }
     }
+
+    g_mDoGaC_gbaCom.mDoGaC_Connect();
+    return 1;
 }
 
 /* 80007A70-80007BBC       .text mDoCPd_Create__Fv */
-void mDoCPd_Create(void) {
+// NONMATCHING - weird ending
+int mDoCPd_Create() {
     JUTGamePad::sSuppressPadReset = 1;
 
     JUTGamePad* pad = new JUTGamePad(JUTGamePad::Port_1);
     g_mDoCPd_gamePad[0] = pad;
     g_mDoCPd_gamePad[1] = NULL;
 
-    if (mDoMain::developmentMode != 0) {
+    if (mDoMain::developmentMode) {
         g_mDoCPd_gamePad[2] = new JUTGamePad(JUTGamePad::Port_3);
         g_mDoCPd_gamePad[3] = new JUTGamePad(JUTGamePad::Port_4);
     } else {
@@ -100,15 +132,15 @@ void mDoCPd_Create(void) {
         JUTGamePad::setResetCallback(mDoRst_resetCallBack, NULL);
     }
 
-    // JUTGba::create();
-    // mDoGaC_Initial();
+    JUTGba::create();
+    g_mDoGaC_gbaCom.mDoGaC_Initial(TestDataManager, 16);
 
-    interface_of_controller_pad* cpad = &g_mDoCPd_cpadInfo[0];
     for (int i = 0; i < 4; i++) {
-        cpad->mTrigLockL = false;
-        cpad->mHoldLockL = false;
-        cpad->mTrigLockR = false;
-        cpad->mHoldLockR = false;
-        cpad++;
+        g_mDoCPd_cpadInfo[i].mTrigLockL = false;
+        g_mDoCPd_cpadInfo[i].mHoldLockL = false;
+        g_mDoCPd_cpadInfo[i].mTrigLockR = false;
+        g_mDoCPd_cpadInfo[i].mHoldLockR = false;
     }
+
+    return 1;
 }
diff --git a/src/m_Do/m_Do_gba_com.cpp b/src/m_Do/m_Do_gba_com.cpp
index f81cac6b..e2cc1624 100644
--- a/src/m_Do/m_Do_gba_com.cpp
+++ b/src/m_Do/m_Do_gba_com.cpp
@@ -4,249 +4,697 @@
 //
 
 #include "m_Do/m_Do_gba_com.h"
-#include "dolphin/types.h"
+#include "JSystem/JUtility/JUTGba.h"
+#include "SSystem/SComponent/c_math.h"
+#include "m_Do/m_Do_Reset.h"
+
+mDoGaC_agbCom_c g_mDoGaC_gbaCom;
+mDoGaC_DataManag_c TestDataManager[16];
+
+static u32 BigLittleChange(u32);
 
 /* 8001A498-8001A4C0       .text ProbeCheck_0__FP11JUTGbaParamPv */
 void ProbeCheck_0(JUTGbaParam*, void*) {
-    /* Nonmatching */
+    g_mDoGaC_gbaCom.mDoGaC_ProbeCheck0();
 }
 
 /* 8001A4C0-8001A4E8       .text ProbeCheck_1__FP11JUTGbaParamPv */
 void ProbeCheck_1(JUTGbaParam*, void*) {
-    /* Nonmatching */
+    g_mDoGaC_gbaCom.mDoGaC_ProbeCheck1();
 }
 
 /* 8001A4E8-8001A510       .text CodeExchange_0__FP11JUTGbaParamPv */
 void CodeExchange_0(JUTGbaParam*, void*) {
-    /* Nonmatching */
+    g_mDoGaC_gbaCom.mDoGaC_CodeExchange0();
 }
 
 /* 8001A510-8001A538       .text CodeExchange_1__FP11JUTGbaParamPv */
 void CodeExchange_1(JUTGbaParam*, void*) {
-    /* Nonmatching */
+    g_mDoGaC_gbaCom.mDoGaC_CodeExchange1();
 }
 
 /* 8001A538-8001A560       .text CodeExchange_2__FP11JUTGbaParamPv */
 void CodeExchange_2(JUTGbaParam*, void*) {
-    /* Nonmatching */
+    g_mDoGaC_gbaCom.mDoGaC_CodeExchange2();
 }
 
 /* 8001A560-8001A588       .text CodeExchange_3__FP11JUTGbaParamPv */
 void CodeExchange_3(JUTGbaParam*, void*) {
-    /* Nonmatching */
+    g_mDoGaC_gbaCom.mDoGaC_CodeExchange3();
 }
 
 /* 8001A588-8001A5B0       .text CodeExchange_4__FP11JUTGbaParamPv */
 void CodeExchange_4(JUTGbaParam*, void*) {
-    /* Nonmatching */
+    g_mDoGaC_gbaCom.mDoGaC_CodeExchange4();
 }
 
 /* 8001A5B0-8001A5D8       .text ContextCheck__FP11JUTGbaParamPv */
 void ContextCheck(JUTGbaParam*, void*) {
-    /* Nonmatching */
+    g_mDoGaC_gbaCom.mDoGaC_ContextCheck();
 }
 
 /* 8001A5D8-8001A600       .text ContextSend__FP11JUTGbaParamPv */
 void ContextSend(JUTGbaParam*, void*) {
-    /* Nonmatching */
+    g_mDoGaC_gbaCom.mDoGaC_ContextSend();
 }
 
 /* 8001A600-8001A628       .text ContextRead__FP11JUTGbaParamPv */
 void ContextRead(JUTGbaParam*, void*) {
-    /* Nonmatching */
+    g_mDoGaC_gbaCom.mDoGaC_ContextRead();
 }
 
 /* 8001A628-8001A650       .text GbaWriteResult__FP11JUTGbaParamPv */
 void GbaWriteResult(JUTGbaParam*, void*) {
-    /* Nonmatching */
+    g_mDoGaC_gbaCom.mDoGaC_WriteResult();
 }
 
 /* 8001A650-8001A678       .text GbaReadResult__FP11JUTGbaParamPv */
 void GbaReadResult(JUTGbaParam*, void*) {
-    /* Nonmatching */
+    g_mDoGaC_gbaCom.mDoGaC_ReadResult();
 }
 
 /* 8001A678-8001A6A0       .text GbaReset__FP11JUTGbaParamPv */
 void GbaReset(JUTGbaParam*, void*) {
-    /* Nonmatching */
+    g_mDoGaC_gbaCom.mDoGaC_GbaReset();
 }
 
 /* 8001A6A0-8001A7B8       .text mDoGaC_Initial__15mDoGaC_agbCom_cFP18mDoGaC_DataManag_cUc */
-void mDoGaC_agbCom_c::mDoGaC_Initial(mDoGaC_DataManag_c*, unsigned char) {
-    /* Nonmatching */
+// NONMATCHING - loop / end issues
+void mDoGaC_agbCom_c::mDoGaC_Initial(mDoGaC_DataManag_c* param_0, u8 param_1) {
+    field_0x0 = 0;
+    field_0x1 = 0;
+    field_0x2 = 0;
+    field_0x3 = 0;
+    field_0x4 = 1;
+    field_0x5 = 0;
+    mPortNo = 1;
+    field_0x10e = 0;
+    field_0x7 = 0;
+    field_0x8 = 0;
+    field_0x10c = param_1;
+    field_0x9 = 0;
+    field_0xa = 0;
+    field_0xb = 0;
+
+    for (int i = 0; i < 16; i++) {
+        field_0xc[i].field_0x0 = 0;
+        field_0xc[i].field_0x4 = 0;
+        field_0xc[i].field_0x8 = 0;
+        field_0xc[i].field_0xc = 0;
+    }
+
+    field_0x110 = param_0;
+    if (param_1 != 0) {
+        for (int i = 0; i < param_1; i++) {
+            param_0[i].field_0x0 = 0;
+            param_0[i].field_0x4 = 0;
+            param_0[i].field_0x5 = 0;
+        }
+    }
+
+    field_0x114 = -1;
+    field_0x118 = 0;
+
+    field_0x12c.U16._12e |= (u32)cM_rndF(32767.0f);
+    field_0x12c.U32 |= (u32)cM_rndF(32767.0f);
+    field_0x12c.U8 = (field_0x12c.U8 & 0x3F) | 0x40;
+    field_0x128 = 0;
 }
 
 /* 8001A7B8-8001A7C4       .text mDoGaC_ComOpen__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_ComOpen() {
-    /* Nonmatching */
+    field_0x2 = 2;
 }
 
 /* 8001A7C4-8001A814       .text mDoGaC_ComClose__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_ComClose() {
-    /* Nonmatching */
+    field_0x4 = 1;
+    field_0x2 = 0;
+    field_0x10e = 0;
+
+    for (int i = 0; i < field_0x10c; i++) {
+        field_0x110[i].field_0x4 = 9;
+        field_0x110[i].field_0x5 = 1;
+    }
 }
 
 /* 8001A814-8001A820       .text mDoGaC_ComStart__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_ComStart() {
-    /* Nonmatching */
+    field_0x1 = 1;
 }
 
 /* 8001A820-8001A858       .text mDoGaC_ComStop__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_ComStop() {
-    /* Nonmatching */
+    mDoGaC_ComClose();
+    field_0x1 = 0;
+    field_0x5 = 0;
 }
 
 /* 8001A858-8001A8B4       .text mDoGaC_GbaReboot__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_GbaReboot() {
-    /* Nonmatching */
+    mDoGaC_ComStop();
+    field_0x0 = 0;
+    field_0x3 = 0;
+    field_0x12c.U32 |= (u32)cM_rndF(32767.0f);
+    field_0x128 = 0;
 }
 
 /* 8001A8B4-8001A94C       .text mDoGaC_GbaReset__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_GbaReset() {
-    /* Nonmatching */
+    u8 sp8[16];
+
+    if (JUTGba::getManager()->resultReset(mDoGaC_getPortNo(), sp8)) {
+        mDoGaC_GbaReboot();
+    } else {
+        field_0x6++;
+        if (field_0x6 > 60) {
+            mDoGaC_GbaReboot();
+        } else {
+            JUTGba::getManager()->doReset(mDoGaC_getPortNo(), GbaReset, NULL);
+        }
+    }
 }
 
 /* 8001A94C-8001A9A4       .text mDoGaC_ComRestart__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_ComRestart() {
-    /* Nonmatching */
+    field_0x4 = 0;
+    field_0x7 = 0;
+    field_0x8 = 0;
+    field_0x9 = 0;
+    field_0xa = 0;
+    field_0xb = 0;
+
+    for (int i = 0; i < field_0x10c; i++) {
+        field_0x110[i].field_0x4 = 0;
+        field_0x110[i].field_0x5 = 0;
+    }
 }
 
 /* 8001A9A4-8001AAD4       .text mDoGaC_Connect__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_Connect() {
-    /* Nonmatching */
+    if (field_0x0 != 0) {
+        if (mDoRst::isReset()) {
+            mDoGaC_ComStop();
+            field_0x6 = 0;
+            JUTGba::getManager()->doReset(mDoGaC_getPortNo(), GbaReset, NULL);
+        } else if (field_0x1 != 0) {
+            switch (field_0x2) {
+            case 0:
+                field_0x2 = 1;
+                JUTGba::getManager()->doProbe(mDoGaC_getPortNo(), ProbeCheck_0, NULL);
+                if (field_0x10e < 3) {
+                    field_0x10e++;
+                }
+                break;
+            case 2:
+                mDoGaC_ComRestart();
+                mDoGaC_GbaWrite();
+                field_0x2 = 3;
+                break;
+            case 3:
+                if (field_0x5 == 0) {
+                    mDoGaC_SendDataWrite();
+                }
+
+                if (field_0x4 == 1) {
+                    mDoGaC_ComClose();
+                }
+
+                field_0x10e = 0;
+                break;
+            case 4:
+                break;
+            }
+        }
+    }
 }
 
 /* 8001AAD4-8001AAEC       .text mDoGaC_ConnectSleep__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_ConnectSleep() {
-    /* Nonmatching */
+    if (field_0x2 == 0) {
+        field_0x2 = 4;
+    }
 }
 
 /* 8001AAEC-8001AAF8       .text mDoGaC_ConnectWake__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_ConnectWake() {
-    /* Nonmatching */
+    field_0x2 = 0;
 }
 
 /* 8001AAF8-8001AB4C       .text mDoGaC_GbaLink__15mDoGaC_agbCom_cFv */
-void mDoGaC_agbCom_c::mDoGaC_GbaLink() {
-    /* Nonmatching */
+int mDoGaC_agbCom_c::mDoGaC_GbaLink() {
+    if (field_0x0 == 1 && field_0x2 == 3 && field_0x4 == 0) {
+        return 1;
+    }
+
+    if (field_0x128 == 1 && field_0x10e < 3) {
+        return 1;
+    }
+
+    return 0;
 }
 
 /* 8001AB4C-8001AC14       .text mDoGaC_SendDataSet__15mDoGaC_agbCom_cFPUliUcUl */
-void mDoGaC_agbCom_c::mDoGaC_SendDataSet(unsigned long*, int, unsigned char, unsigned long) {
-    /* Nonmatching */
+int mDoGaC_agbCom_c::mDoGaC_SendDataSet(u32* param_0, int param_1, u8 param_2, u32 param_3) {
+    u8 uvar1 = field_0x9 + 1;
+    if (uvar1 >= 16) {
+        uvar1 = 0;
+    }
+
+    if (uvar1 == field_0xa || param_1 <= 0) {
+        return 0;
+    }
+
+    if (param_1 < 4) {
+        param_1 = 4;
+    }
+
+    field_0xc[field_0x9].field_0x0 = param_0;
+    field_0xc[field_0x9].field_0x4 = param_1;
+    field_0xc[field_0x9].field_0x8 = param_2;
+    field_0xc[field_0x9].field_0xc = param_3;
+    field_0x110[param_2].field_0x4 = 2;
+
+    field_0x9++;
+    if (field_0x9 >= 16) {
+        field_0x9 = 0;
+    }
+
+    field_0xb++;
+
+    return 1;
 }
 
 /* 8001AC14-8001AD48       .text mDoGaC_SendDataWrite__15mDoGaC_agbCom_cFv */
+// NONMATCHING - regswap
 void mDoGaC_agbCom_c::mDoGaC_SendDataWrite() {
-    /* Nonmatching */
+    u8 var_r5 = 0;
+    while (field_0x10c > var_r5) {
+        u8 var_r0 = field_0x110[var_r5].field_0x5;
+        if (var_r0 != 0) {
+            u8 temp_r0 = field_0x9 + 1;
+            if (temp_r0 >= 16) {
+                temp_r0 = 0;
+            }
+
+            if (temp_r0 == field_0xa) {
+                return;
+            }
+
+            if (field_0x110[var_r5].field_0x4 == 0 || field_0x110[var_r5].field_0x4 == 1) {
+                if (var_r0 == 1) {
+                    field_0xc[field_0x9].field_0x0 = &field_0x11C;
+                    field_0xc[field_0x9].field_0x4 = 4;
+                } else {
+                    field_0xc[field_0x9].field_0x0 = &field_0x120;
+                    field_0xc[field_0x9].field_0x4 = 8;
+                }
+
+                field_0xc[field_0x9].field_0x8 = var_r5;
+                field_0xc[field_0x9].field_0xc = 0;
+                field_0x110[var_r5].field_0x4 = 2;
+
+                field_0x9++;
+                if (field_0x9 >= 16) {
+                    field_0x9 = 0;
+                }
+
+                field_0xb++;
+                field_0x110[var_r5].field_0x5 = 0;
+            }
+        }
+
+        var_r5++;
+    }
 }
 
 /* 8001AD48-8001AD84       .text mDoGaC_SendEntry__15mDoGaC_agbCom_cFUcUl */
-void mDoGaC_agbCom_c::mDoGaC_SendEntry(unsigned char, unsigned long) {
-    /* Nonmatching */
+int mDoGaC_agbCom_c::mDoGaC_SendEntry(u8 param_0, u32 param_1) {
+    if (field_0x110[param_0].field_0x5 == 0) {
+        field_0x11C = param_1;
+        field_0x110[param_0].field_0x5 = 1;
+        return 1;
+    }
+
+    return 0;
 }
 
 /* 8001AD84-8001ADB4       .text mDoGaC_SendStatusCheck__15mDoGaC_agbCom_cFUc */
-void mDoGaC_agbCom_c::mDoGaC_SendStatusCheck(unsigned char) {
-    /* Nonmatching */
+int mDoGaC_agbCom_c::mDoGaC_SendStatusCheck(u8 param_0) {
+    if (field_0x110[param_0].field_0x4 == 0 || field_0x110[param_0].field_0x4 == 1) {
+        return 1;
+    }
+
+    return 0;
 }
 
 /* 8001ADB4-8001ADE4       .text mDoGaC_SendEndCheck__15mDoGaC_agbCom_cFUc */
-void mDoGaC_agbCom_c::mDoGaC_SendEndCheck(unsigned char) {
-    /* Nonmatching */
+int mDoGaC_agbCom_c::mDoGaC_SendEndCheck(u8 param_0) {
+    if (field_0x110[param_0].field_0x4 == 4 || field_0x110[param_0].field_0x4 == 0) {
+        return 1;
+    }
+
+    return 0;
 }
 
 /* 8001ADE4-8001AE04       .text mDoGaC_RecvStatusCheck__15mDoGaC_agbCom_cFUc */
-void mDoGaC_agbCom_c::mDoGaC_RecvStatusCheck(unsigned char) {
-    /* Nonmatching */
+bool mDoGaC_agbCom_c::mDoGaC_RecvStatusCheck(u8 param_0) {
+    return field_0x110[param_0].field_0x4 == 8;
 }
 
 /* 8001AE04-8001AE44       .text mDoGaC_DataStatusReset__15mDoGaC_agbCom_cFUc */
-void mDoGaC_agbCom_c::mDoGaC_DataStatusReset(unsigned char) {
-    /* Nonmatching */
+void mDoGaC_agbCom_c::mDoGaC_DataStatusReset(u8 param_0) {
+    if (field_0x110[param_0].field_0x4 == 8) {
+        field_0x110[param_0].field_0x4 = 0;
+        mDoGaC_StatusSendSet(param_0);
+    }
 }
 
 /* 8001AE44-8001AEE4       .text mDoGaC_StatusSendSet__15mDoGaC_agbCom_cFUc */
-void mDoGaC_agbCom_c::mDoGaC_StatusSendSet(unsigned char) {
-    /* Nonmatching */
+int mDoGaC_agbCom_c::mDoGaC_StatusSendSet(u8 param_0) {
+    u8 temp_r0 = field_0x9 + 1;
+    if (temp_r0 >= 16) {
+        temp_r0 = 0;
+    }
+
+    if (temp_r0 == field_0xa) {
+        return 0;
+    }
+
+    field_0xc[field_0x9].field_0x0 = 0;
+    field_0xc[field_0x9].field_0x4 = 0;
+    field_0xc[field_0x9].field_0x8 = param_0;
+    field_0xc[field_0x9].field_0xc = 0;
+
+    field_0x9++;
+    if (field_0x9 >= 16) {
+        field_0x9 = 0;
+    }
+
+    field_0xb++;
+    return 1;
 }
 
 /* 8001AEE4-8001AF68       .text mDoGaC_ProbeCheck0__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_ProbeCheck0() {
-    /* Nonmatching */
+    u32 sp8;
+    if (!JUTGba::getManager()->resultProbe(mDoGaC_getPortNo(), &sp8) && sp8 == 0x40000) {
+        JUTGba::getManager()->doReset(mDoGaC_getPortNo(), ProbeCheck_1, NULL);
+    } else {
+        field_0x2 = 0;
+    }
 }
 
 /* 8001AF68-8001AFDC       .text mDoGaC_ProbeCheck1__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_ProbeCheck1() {
-    /* Nonmatching */
+    u8 sp8[16];
+    if (!JUTGba::getManager()->resultReset(mDoGaC_getPortNo(), sp8)) {
+        JUTGba::getManager()->doGetStatus(mDoGaC_getPortNo(), CodeExchange_0, NULL);
+    } else {
+        field_0x2 = 0;
+    }
 }
 
 /* 8001AFDC-8001B060       .text mDoGaC_CodeExchange0__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_CodeExchange0() {
-    /* Nonmatching */
+    u8 sp8[16];
+    if (!JUTGba::getManager()->resultGetStatus(mDoGaC_getPortNo(), sp8) && sp8[0] == 0x28) {
+        JUTGba::getManager()->doRead(mDoGaC_getPortNo(), (u8*)&field_0x118, CodeExchange_1, NULL);
+    } else {
+        field_0x2 = 0;
+    }
 }
 
 /* 8001B060-8001B0F4       .text mDoGaC_CodeExchange1__15mDoGaC_agbCom_cFv */
+// NONMATCHING - weird string load
 void mDoGaC_agbCom_c::mDoGaC_CodeExchange1() {
-    /* Nonmatching */
+    u8 sp8[16];
+    if (!JUTGba::getManager()->resultRead(mDoGaC_getPortNo(), sp8)) {
+        if (field_0x118 == (u32) "GZLE") {
+            JUTGba::getManager()->doGetStatus(mDoGaC_getPortNo(), CodeExchange_2, NULL);
+        } else {
+            mDoGaC_GbaReboot();
+        }
+    } else {
+        field_0x2 = 0;
+    }
 }
 
 /* 8001B0F4-8001B184       .text mDoGaC_CodeExchange2__15mDoGaC_agbCom_cFv */
+// NONMATCHING - weird string load
 void mDoGaC_agbCom_c::mDoGaC_CodeExchange2() {
-    /* Nonmatching */
+    u8 sp8[16];
+    if (!JUTGba::getManager()->resultGetStatus(mDoGaC_getPortNo(), sp8) && sp8[0] == 0x20) {
+        field_0x114 = (u32) "GZLE";
+        JUTGba::getManager()->doWrite(mDoGaC_getPortNo(), (u8*)&field_0x114, CodeExchange_3, NULL);
+    } else {
+        field_0x2 = 0;
+    }
 }
 
 /* 8001B184-8001B1F8       .text mDoGaC_CodeExchange3__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_CodeExchange3() {
-    /* Nonmatching */
+    u8 sp8[16];
+    if (!JUTGba::getManager()->resultWrite(mDoGaC_getPortNo(), sp8)) {
+        JUTGba::getManager()->doGetStatus(mDoGaC_getPortNo(), CodeExchange_4, NULL);
+    } else {
+        field_0x2 = 0;
+    }
 }
 
 /* 8001B1F8-8001B298       .text mDoGaC_CodeExchange4__15mDoGaC_agbCom_cFv */
+// NONMATCHING - weird bit shifting
 void mDoGaC_agbCom_c::mDoGaC_CodeExchange4() {
-    /* Nonmatching */
+    u8 sp8[16];
+    if (!JUTGba::getManager()->resultGetStatus(mDoGaC_getPortNo(), sp8) && sp8[0] == 0x30) {
+        field_0x12c.U8 = (field_0x12c.U8 & ~0xC0) | (mDoGaC_getPortNo() & 0xC0);
+        field_0x114 = BigLittleChange(field_0x12c.U32);
+        JUTGba::getManager()->doWrite(mDoGaC_getPortNo(), (u8*)&field_0x114, ContextSend, NULL);
+    } else {
+        field_0x2 = 0;
+    }
 }
 
 /* 8001B298-8001B334       .text mDoGaC_ContextCheck__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_ContextCheck() {
-    /* Nonmatching */
+    u8 sp8[16];
+    if (!JUTGba::getManager()->resultRead(mDoGaC_getPortNo(), sp8)) {
+        u32 var_r0 = BigLittleChange(field_0x118);
+        if (var_r0 == field_0x12c.U32) {
+            if (field_0x128 == 1) {
+                field_0x3 = 1;
+            } else {
+                field_0x128 = 1;
+            }
+
+            mDoGaC_ComOpen();
+        } else {
+            field_0x2 = 0;
+        }
+    } else {
+        field_0x2 = 0;
+    }
 }
 
 /* 8001B334-8001B3A8       .text mDoGaC_ContextSend__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_ContextSend() {
-    /* Nonmatching */
+    u8 sp8[16];
+    if (!JUTGba::getManager()->resultWrite(mDoGaC_getPortNo(), sp8)) {
+        JUTGba::getManager()->doGetStatus(mDoGaC_getPortNo(), ContextRead, NULL);
+    } else {
+        field_0x2 = 0;
+    }
 }
 
 /* 8001B3A8-8001B42C       .text mDoGaC_ContextRead__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_ContextRead() {
-    /* Nonmatching */
+    u8 sp8[16];
+    if (!JUTGba::getManager()->resultGetStatus(mDoGaC_getPortNo(), sp8) && sp8[0] == 0x38) {
+        JUTGba::getManager()->doRead(mDoGaC_getPortNo(), (u8*)&field_0x118, ContextRead, NULL);
+    } else {
+        field_0x2 = 0;
+    }
 }
 
 /* 8001B42C-8001B6CC       .text mDoGaC_GbaWrite__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_GbaWrite() {
-    /* Nonmatching */
+    static int flag = 0;
+
+    if (field_0xa == field_0x9) {
+        if (field_0x5 == 1) {
+            mDoGaC_ComStop();
+            field_0x114 = -0x10101011;
+        } else {
+            field_0x114 = -1;
+        }
+    } else {
+        mDoGaC_unk_data* temp_r31 = &field_0xc[field_0xa];
+        switch (field_0x8) {
+        case 0:
+            field_0x114 = BigLittleChange(-0x01010102);
+            field_0x8 = 1;
+            break;
+        case 1:
+            field_0x114 = BigLittleChange(temp_r31->field_0x8);
+            field_0x8 = 2;
+            break;
+        case 2:
+            u8 temp_r3_2 = field_0x110[temp_r31->field_0x8].field_0x4;
+            if (temp_r3_2 == 2) {
+                field_0x110[temp_r31->field_0x8].field_0x4 = 3;
+                field_0x114 = BigLittleChange(3);
+                field_0x8 = 3;
+            } else {
+                field_0x114 = BigLittleChange(temp_r3_2);
+                if (field_0x110[temp_r31->field_0x8].field_0x4 == 5) {
+                    field_0x110[temp_r31->field_0x8].field_0x4 = 6;
+                }
+
+                field_0xb--;
+                field_0xa++;
+                if (field_0xa >= 16) {
+                    field_0xa = 0;
+                }
+
+                field_0x8 = 0;
+            }
+            break;
+        case 3:
+            field_0x114 = BigLittleChange(temp_r31->field_0x4);
+            temp_r31->field_0xc = 0;
+            field_0x8 = 5;
+            break;
+        case 4:
+            field_0x114 = BigLittleChange(temp_r31->field_0xc);
+            field_0x110[temp_r31->field_0x8].field_0x4 = 4;
+
+            field_0xb--;
+            field_0xa++;
+            if (field_0xa >= 16) {
+                field_0xa = 0;
+            }
+            field_0x8 = 0;
+            break;
+        case 5:
+            field_0x114 = *temp_r31->field_0x0;
+            temp_r31->field_0xc += BigLittleChange(field_0x114);
+            temp_r31->field_0x4 -= 4;
+            if (temp_r31->field_0x4 <= 0) {
+                field_0x8 = 4;
+            } else {
+                temp_r31->field_0x0++;
+            }
+            break;
+        default:
+            field_0x114 = -1;
+            break;
+        }
+    }
+
+    JUTGba::getManager()->doWrite(mDoGaC_getPortNo(), (u8*)&field_0x114, GbaWriteResult, NULL);
 }
 
 /* 8001B6CC-8001B734       .text mDoGaC_WriteResult__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_WriteResult() {
-    /* Nonmatching */
+    u8 sp8[16];
+    if (!JUTGba::getManager()->resultWrite(mDoGaC_getPortNo(), sp8) && field_0x4 == 0) {
+        mDoGaC_GbaRead();
+    } else {
+        field_0x4 = 1;
+    }
 }
 
 /* 8001B734-8001B778       .text mDoGaC_GbaRead__15mDoGaC_agbCom_cFv */
 void mDoGaC_agbCom_c::mDoGaC_GbaRead() {
-    /* Nonmatching */
+    JUTGba::getManager()->doRead(mDoGaC_getPortNo(), (u8*)&field_0x118, GbaReadResult, NULL);
 }
 
 /* 8001B778-8001BA34       .text mDoGaC_ReadResult__15mDoGaC_agbCom_cFv */
+// NONMATCHING - almost
 void mDoGaC_agbCom_c::mDoGaC_ReadResult() {
-    /* Nonmatching */
+    static u8 data_type = 0;
+    static u32 check_sum = 0;
+    static u32 data_sum = 0;
+    static u32* recv_p = NULL;
+    static u32* end_p = NULL;
+
+    u8 sp8[16];
+    if (!JUTGba::getManager()->resultRead(mDoGaC_getPortNo(), sp8) && field_0x4 == 0) {
+        switch (field_0x7) {
+        case 0:
+            u32 temp_r0 = BigLittleChange(field_0x118);
+            if (temp_r0 == -0x1010102) {
+                field_0x7 = 1;
+            }
+            break;
+        case 1:
+            u32 temp_r0_2 = BigLittleChange(field_0x118);
+            data_type = temp_r0_2;
+            if ((temp_r0_2 & 0xFF) < 0x10) {
+                recv_p = &field_0x110[temp_r0_2 & 0xFF].field_0x0;
+            } else {
+                recv_p = NULL;
+            }
+            field_0x7 = 2;
+            break;
+        case 2:
+            u32 temp_r0_3 = BigLittleChange(field_0x118);
+            field_0x110[data_type].field_0x4 = temp_r0_3;
+            if (temp_r0_3 == 7) {
+                field_0x7 = 3;
+            } else {
+                field_0x7 = 0;
+                if (temp_r0_3 == 9) {
+                    field_0x4 = 1;
+                }
+            }
+            break;
+        case 3:
+            u32 temp_r0_4 = BigLittleChange(field_0x118);
+            end_p = &field_0x110[data_type].field_0x0 + temp_r0_4;
+            data_sum = 0;
+            if (recv_p == NULL) {
+                field_0x7 = 6;
+            } else {
+                field_0x7 = 5;
+            }
+            break;
+        case 4:
+            check_sum = BigLittleChange(field_0x118);
+            if (data_sum == check_sum) {
+                field_0x110[data_type].field_0x4 = 8;
+            } else {
+                field_0x110[data_type].field_0x4 = 9;
+                mDoGaC_StatusSendSet(data_type);
+                field_0x4 = 1;
+            }
+            field_0x7 = 0;
+            break;
+        case 5:
+            *recv_p = field_0x118;
+            data_sum += BigLittleChange(field_0x118);
+        case 6:
+            recv_p++;
+            if (recv_p >= end_p) {
+                field_0x7 = 4;
+            }
+            break;
+        }
+
+        mDoGaC_GbaWrite();
+    } else {
+        field_0x4 = 1;
+    }
 }
 
 /* 8001BA34-8001BA68       .text BigLittleChange__FUl */
-void BigLittleChange(unsigned long) {
-    /* Nonmatching */
+// NONMATCHING - not even close
+u32 BigLittleChange(u32 param_0) {
+    u8 b1 = param_0 >> 8;
+    u8 b2 = param_0 >> 0x10;
+    u8 b3 = param_0 >> 0x18;
+    return (param_0 << 0x18) | (b1 << 0x10) | (b2 << 8) | b3;
 }
 
 /* 8001BAA0-8001BADC       .text __dt__15mDoGaC_agbCom_cFv */
-mDoGaC_agbCom_c::~mDoGaC_agbCom_c() {
-    /* Nonmatching */
-}
+mDoGaC_agbCom_c::~mDoGaC_agbCom_c() {}