From b7bf72272f27e8c882bd2efdbb11bb70c430454b Mon Sep 17 00:00:00 2001
From: CovenEsme <84377742+CovenEsme@users.noreply.github.com>
Date: Sat, 27 Apr 2024 13:45:07 +0100
Subject: [PATCH 01/16] Misc flag mgr ctors -> 100%

---
 config/SOUE01/splits.txt              |  3 +++
 src/toBeSorted/misc_flag_managers.cpp | 25 +++++++++++++++++--------
 src/toBeSorted/sceneflag_manager.cpp  |  2 +-
 3 files changed, 21 insertions(+), 9 deletions(-)

diff --git a/config/SOUE01/splits.txt b/config/SOUE01/splits.txt
index dc15c545..78cb40ca 100644
--- a/config/SOUE01/splits.txt
+++ b/config/SOUE01/splits.txt
@@ -108,6 +108,9 @@ toBeSorted/sceneflag_manager.cpp:
 
 toBeSorted/misc_flag_managers.cpp:
 	.text       start:0x800BE7B0 end:0x800BEE00
+	.data       start:0x80510CDC end:0x80510D04
+	.sbss       start:0x805753F0 end:0x805753FC
+	.bss        start:0x805A7AD8 end:0x805A9AD8
 
 toBeSorted/flag_space.cpp:
 	.text       start:0x800BEE00 end:0x800BEF90
diff --git a/src/toBeSorted/misc_flag_managers.cpp b/src/toBeSorted/misc_flag_managers.cpp
index 312d105f..e908dd73 100644
--- a/src/toBeSorted/misc_flag_managers.cpp
+++ b/src/toBeSorted/misc_flag_managers.cpp
@@ -33,16 +33,15 @@ bool CommittableFlagManager::commitIfNecessary() {
 }
 
 class TBoxFlagManager : public CommittableFlagManager {
-    // class TBoxFlagManager {
-    // bool mNeedsCommit;
-    // u32 pad;
+public:
     FlagSpace mFlagSpace;
     u16 mSceneIndex;
     BitwiseFlagHelper mFlagHelper;
 
-    static u16 *sFlags;
+    static u16 sTBoxFlags[2];
+
+    static TBoxFlagManager *sInstance;
 
-public:
     virtual void doCommit() override;
     bool checkUncommittedFlag(u16 flag);
     TBoxFlagManager();
@@ -58,6 +57,9 @@ public:
     }
 };
 
+TBoxFlagManager *TBoxFlagManager::sInstance = nullptr;
+u16 TBoxFlagManager::sTBoxFlags[2] = {};
+
 void TBoxFlagManager::doCommit() {
     if (mSceneIndex != 0xFFFF) {
         FileManager::getInstance()->setTBoxFlags(mFlagSpace.getFlagPtrUnchecked(), mSceneIndex * 2, 2);
@@ -68,7 +70,7 @@ bool TBoxFlagManager::checkUncommittedFlag(u16 flag) {
     return mFlagHelper.checkFlag(flag / 16, flag % 16, mFlagSpace.getFlagPtrUnchecked(), mFlagSpace.mCount);
 }
 
-TBoxFlagManager::TBoxFlagManager() : CommittableFlagManager(false), mFlagSpace(sFlags, 2) {
+TBoxFlagManager::TBoxFlagManager() : CommittableFlagManager(false), mFlagSpace(sTBoxFlags, ARRAY_LENGTH(sTBoxFlags)) {
     mSceneIndex = 0xFFFF;
 }
 
@@ -104,7 +106,9 @@ public:
     BitwiseFlagHelper mFlagHelper;
     u16 mSceneIndex;
 
-    static u16 *sFlags;
+    static u16 sEnemyDefeatFlags[4096];
+
+    static EnemyDefeatManager *sInstance;
 
     void clearSavedFlags();
     bool checkUncommittedFlag(u16 flag);
@@ -123,6 +127,9 @@ public:
     void setFlag(u16 flag);
 };
 
+EnemyDefeatManager *EnemyDefeatManager::sInstance = nullptr;
+u16 EnemyDefeatManager::sEnemyDefeatFlags[4096] = {};
+
 void EnemyDefeatManager::clearSavedFlags() {
     u16 empty[0x1000];
     memset(empty, 0, 0x2000);
@@ -137,7 +144,9 @@ bool EnemyDefeatManager::checkUncommittedFlag(u16 flag) {
     }
 }
 
-EnemyDefeatManager::EnemyDefeatManager() : CommittableFlagManager(false), mFlagSpace(sFlags, 12 /* later */) {}
+EnemyDefeatManager::EnemyDefeatManager() : CommittableFlagManager(false), mFlagSpace(sEnemyDefeatFlags, ARRAY_LENGTH(sEnemyDefeatFlags)) {
+
+}
 
 void EnemyDefeatManager::init() {
     mSceneIndex = 0;
diff --git a/src/toBeSorted/sceneflag_manager.cpp b/src/toBeSorted/sceneflag_manager.cpp
index 3443133c..1cef7560 100644
--- a/src/toBeSorted/sceneflag_manager.cpp
+++ b/src/toBeSorted/sceneflag_manager.cpp
@@ -17,7 +17,7 @@ public:
     static u16 sTempFlags[4];
     static u16 sSceneFlags[8];
     static u16 sZoneFlags[0xFC];
-    // public:
+
     static SceneflagManager *sInstance;
     void doNothing();
     void setShouldCommit(u16 flag);

From 705b0b598e5afa99dc93bb12b49ef2a9d7e38d0b Mon Sep 17 00:00:00 2001
From: robojumper <robojumper@gmail.com>
Date: Fri, 26 Apr 2024 11:52:24 +0200
Subject: [PATCH 02/16] c/c_tree.cpp

---
 config/SOUE01/splits.txt  |   3 +
 config/SOUE01/symbols.txt |   2 +-
 configure.py              |   1 +
 src/c/c_tree.cpp          | 114 ++++++++++++++++++++++++++++++++++++++
 4 files changed, 119 insertions(+), 1 deletion(-)
 create mode 100644 src/c/c_tree.cpp

diff --git a/config/SOUE01/splits.txt b/config/SOUE01/splits.txt
index 903c993c..2b80779f 100644
--- a/config/SOUE01/splits.txt
+++ b/config/SOUE01/splits.txt
@@ -122,6 +122,9 @@ toBeSorted/bitwise_flag_helper.cpp:
 c/c_list.cpp:
 	.text       start:0x802E08C0 end:0x802E0A10
 
+c/c_tree.cpp:
+	.text       start:0x802E0E70 end:0x802E1140
+
 f/f_base.cpp:
 	.text       start:0x802E12F0 end:0x802E2680
 	.ctors      start:0x804DB8C0 end:0x804DB8C4
diff --git a/config/SOUE01/symbols.txt b/config/SOUE01/symbols.txt
index 7b943c29..ca84c0a2 100644
--- a/config/SOUE01/symbols.txt
+++ b/config/SOUE01/symbols.txt
@@ -17295,7 +17295,7 @@ fn_802E0DC0 = .text:0x802E0DC0; // type:function size:0x48
 fn_802E0E10 = .text:0x802E0E10; // type:function size:0xC
 fn_802E0E20 = .text:0x802E0E20; // type:function size:0x44
 __ct__9cTreeNd_cFv = .text:0x802E0E70; // type:function size:0x30
-fn_802E0EA0 = .text:0x802E0EA0; // type:function size:0x18
+forcedClear__9cTreeNd_cFv = .text:0x802E0EA0; // type:function size:0x18
 addTreeNode__9cTreeMg_cFP9cTreeNd_cP9cTreeNd_c = .text:0x802E0EC0; // type:function size:0x94
 removeTreeNode__9cTreeMg_cFP9cTreeNd_c = .text:0x802E0F60; // type:function size:0x98
 insertTreeNode__9cTreeMg_cFP9cTreeNd_cP9cTreeNd_c = .text:0x802E1000; // type:function size:0xBC
diff --git a/configure.py b/configure.py
index fc454981..19ee950f 100644
--- a/configure.py
+++ b/configure.py
@@ -275,6 +275,7 @@ config.libs = [
             Object(NonMatching, "toBeSorted/flag_space.cpp"),
             Object(NonMatching, "toBeSorted/misc_flag_managers.cpp"),
             Object(Matching, "c/c_list.cpp"),
+            Object(Matching, "c/c_tree.cpp"),
             Object(Matching, "d/d_base.cpp"),
             Object(NonMatching, "d/d_heap.cpp"),
             Object(NonMatching, "d/d_stage.cpp"),
diff --git a/src/c/c_tree.cpp b/src/c/c_tree.cpp
new file mode 100644
index 00000000..a413761f
--- /dev/null
+++ b/src/c/c_tree.cpp
@@ -0,0 +1,114 @@
+#include <c/c_tree.h>
+
+cTreeNd_c::cTreeNd_c() {
+    this->forcedClear();
+}
+
+void cTreeNd_c::forcedClear() {
+    this->mpParent = nullptr;
+    this->mpChild = nullptr;   
+    this->mpPrev = nullptr;
+    this->mpNext = nullptr;
+}
+
+bool cTreeMg_c::addTreeNode(cTreeNd_c *node, cTreeNd_c *parent) {
+    if (node != nullptr) {
+        if (parent != nullptr) {
+            node->mpParent = parent;
+            if (parent->mpChild == nullptr) {
+                parent->mpChild = node;
+            } else {
+                cTreeNd_c *cursor;
+                for (cursor = parent->mpChild; cursor->mpNext != nullptr; cursor = cursor->mpNext) {}
+                cursor->mpNext = node;
+                node->mpPrev = cursor;
+            }
+        } else {
+            cTreeNd_c *cursor = this->mpRootNode;
+            if (cursor != nullptr) {
+                for (; cursor->mpNext != nullptr; cursor = cursor->mpNext) {}
+                cursor->mpNext = node;
+                node->mpPrev = cursor;
+            } else {
+                this->mpRootNode = node;
+            }
+        }
+    } else {
+        return false;
+    }
+    return true;
+}
+
+bool cTreeMg_c::removeTreeNode(cTreeNd_c *node) {
+    if (node != nullptr) {
+        if (node->mpChild != nullptr) {
+            return false;
+        }
+        if (node->mpPrev != nullptr) {
+            node->mpPrev->mpNext = node->mpNext; 
+        } else if (node->mpParent != nullptr) {
+            node->mpParent->mpChild = node->mpNext;
+        } else if (node == this->mpRootNode) {
+            this->mpRootNode = node->mpNext;
+        }
+
+        if (node->mpNext != nullptr) {
+            node->mpNext->mpPrev = node->mpPrev;
+        }
+
+        node->mpPrev = nullptr;
+        node->mpNext = nullptr;
+        node->mpParent = nullptr;
+    } else {
+        return false;
+    }
+    return true;
+}
+
+bool cTreeMg_c::insertTreeNode(cTreeNd_c *node, cTreeNd_c *parent) {
+    cTreeNd_c *cursor;
+
+    for (cursor = parent; cursor != nullptr; cursor = cursor->mpParent) {
+        if (cursor == node) {
+            return false;
+        }
+    }
+
+    if (node != nullptr) {
+        cTreeNd_c *child = node->mpChild;
+        node->mpChild = nullptr;
+        if (!this->removeTreeNode(node)) {
+            node->mpChild = child;
+            return false;
+        } else {
+            node->mpChild = child;
+            return this->addTreeNode(node, parent);
+        }
+    }
+
+    return false;
+}
+
+cTreeNd_c *cTreeNd_c::getTreeNext() const {
+    cTreeNd_c *child = this->mpChild;
+    if (child != nullptr) {
+        return child;
+    } else {
+        return this->getTreeNextNotChild();
+    }
+}
+
+cTreeNd_c *cTreeNd_c::getTreeNextNotChild() const {
+    if (this->mpNext != nullptr) {
+        return this->mpNext;
+    }
+
+    cTreeNd_c *parent;
+    
+    for (parent = this->mpParent; parent != nullptr; parent = parent->mpParent) {
+        if (parent->mpNext != nullptr) {
+            return parent->mpNext;
+        }   
+    }
+    return nullptr;
+}

From f154b7ccd5e11b6758491f83c89148de6fb312bb Mon Sep 17 00:00:00 2001
From: robojumper <robojumper@gmail.com>
Date: Sat, 27 Apr 2024 16:43:54 +0200
Subject: [PATCH 03/16] Fix compiler warnings

---
 include/c/c_list.h | 8 ++++----
 src/c/c_list.cpp   | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/include/c/c_list.h b/include/c/c_list.h
index 3f958bd2..d4287ade 100644
--- a/include/c/c_list.h
+++ b/include/c/c_list.h
@@ -31,7 +31,7 @@ public:
     /* 802e2be0 */ cListMg_c() : mpFirst(nullptr), mpLast(nullptr) {}
     // /* 802e2880 */ ~cListMg_c();
 
-    bool insertAfter(cListNd_c *node, cListNd_c *prevNode);
+    void insertAfter(cListNd_c *node, cListNd_c *prevNode);
 
     /**
      * @brief Removes a node from the list.
@@ -39,7 +39,7 @@ public:
      * @param node The node to remove.
      * @return If the operation was successful.
      */
-    bool remove(cListNd_c *node);
+    void remove(cListNd_c *node);
 
     /**
      * @brief Adds a node to the end of the list.
@@ -47,7 +47,7 @@ public:
      * @param node The node to append.
      * @return If the operation was successful.
      */
-    bool append(cListNd_c *node);
+    void append(cListNd_c *node);
 
     /**
      * @brief Adds a node to the beginning of the list.
@@ -55,7 +55,7 @@ public:
      * @param node The node to prepend.
      * @return If the operation was successful.
      */
-    bool prepend(cListNd_c *node);
+    void prepend(cListNd_c *node);
 
     cListNd_c *getFirst() const {
         return mpFirst;
diff --git a/src/c/c_list.cpp b/src/c/c_list.cpp
index 37d1c624..5218c87d 100644
--- a/src/c/c_list.cpp
+++ b/src/c/c_list.cpp
@@ -1,7 +1,7 @@
 #include <c/c_list.h>
 
 
-bool cListMg_c::insertAfter(cListNd_c *node, cListNd_c *prevNode) {
+void cListMg_c::insertAfter(cListNd_c *node, cListNd_c *prevNode) {
     if (prevNode == nullptr) {
         return this->prepend(node);
     }
@@ -18,7 +18,7 @@ bool cListMg_c::insertAfter(cListNd_c *node, cListNd_c *prevNode) {
     }
 }
 
-bool cListMg_c::remove(cListNd_c *node) {
+void cListMg_c::remove(cListNd_c *node) {
     if (node == nullptr) {
         return;
     }
@@ -46,7 +46,7 @@ bool cListMg_c::remove(cListNd_c *node) {
     }
 }
 
-bool cListMg_c::append(cListNd_c *node) {
+void cListMg_c::append(cListNd_c *node) {
     if (node == nullptr) {
         return;
     }
@@ -59,7 +59,7 @@ bool cListMg_c::append(cListNd_c *node) {
     this->mpLast = node;
 }
 
-bool cListMg_c::prepend(cListNd_c *node) {
+void cListMg_c::prepend(cListNd_c *node) {
     if (node == nullptr) {
         return;
     }

From 63a858728931d42551f7d3a13a31f8fa7a5d5429 Mon Sep 17 00:00:00 2001
From: robojumper <robojumper@gmail.com>
Date: Sat, 27 Apr 2024 15:43:31 +0200
Subject: [PATCH 04/16] Some m_heap work

---
 config/SOUE01/symbols.txt |  12 +--
 include/m/m_heap.h        |  24 ++---
 src/m/m_heap.cpp          | 180 +++++++++++++++++++++++++++++++++++---
 3 files changed, 184 insertions(+), 32 deletions(-)

diff --git a/config/SOUE01/symbols.txt b/config/SOUE01/symbols.txt
index 7b943c29..48e5a939 100644
--- a/config/SOUE01/symbols.txt
+++ b/config/SOUE01/symbols.txt
@@ -2230,7 +2230,7 @@ fn_80054E20 = .text:0x80054E20; // type:function size:0x88
 fn_80054EB0 = .text:0x80054EB0; // type:function size:0x4
 fn_80054EC0 = .text:0x80054EC0; // type:function size:0xC
 fn_80054ED0 = .text:0x80054ED0; // type:function size:0xC
-fn_80054EE0 = .text:0x80054EE0; // type:function size:0x8
+__dl__FPv = .text:0x80054EE0; // type:function size:0x8
 fn_80054EF0 = .text:0x80054EF0; // type:function size:0x8
 fn_80054F00 = .text:0x80054F00; // type:function size:0x30
 fn_80054F30 = .text:0x80054F30; // type:function size:0x4
@@ -17813,7 +17813,7 @@ fn_802F08E0 = .text:0x802F08E0; // type:function size:0x370
 fn_802F0C50 = .text:0x802F0C50; // type:function size:0x160
 fn_802F0DB0 = .text:0x802F0DB0; // type:function size:0x8
 fn_802F0DC0 = .text:0x802F0DC0; // type:function size:0x13C
-fn_802F0F00 = .text:0x802F0F00; // type:function size:0x34
+copyAttribute__5mHeapFUi = .text:0x802F0F00; // type:function size:0x34
 setCurrentHeap__5mHeapFPQ23EGG4Heap = .text:0x802F0F40; // type:function size:0x4
 createExpHeap__5mHeapFUlPQ23EGG4HeapPCcUlUl = .text:0x802F0F50; // type:function size:0x10C
 adjustExpHeap__5mHeapFPQ23EGG7ExpHeap = .text:0x802F1060; // type:function size:0x68
@@ -17822,8 +17822,8 @@ createFrmHeap__5mHeapFUlPQ23EGG4HeapPCcUlUl = .text:0x802F10F0; // type:function
 destroyFrmHeap__5mHeapFPQ23EGG7FrmHeap = .text:0x802F1200; // type:function size:0x1C
 adjustFrmHeap__5mHeapFPQ23EGG7FrmHeap = .text:0x802F1220; // type:function size:0x68
 frmHeapCost__5mHeapFUlUl = .text:0x802F1290; // type:function size:0x18
-fn_802F12B0 = .text:0x802F12B0; // type:function size:0x38
-fn_802F12F0 = .text:0x802F12F0; // type:function size:0x58
+setTempHeap__5mHeapFPPQ23EGG4HeapPQ23EGG4Heap = .text:0x802F12B0; // type:function size:0x38
+restoreTempHeap__5mHeapFPPQ23EGG4Heapi = .text:0x802F12F0; // type:function size:0x58
 createHeap__5mHeapFUlPQ23EGG4HeapPCc = .text:0x802F1350; // type:function size:0x74
 saveCurrentHeap__5mHeapFv = .text:0x802F13D0; // type:function size:0xC
 restoreCurrentHeap__5mHeapFv = .text:0x802F13E0; // type:function size:0x2C
@@ -17835,7 +17835,7 @@ createArchiveHeap__5mHeapFUlPQ23EGG4Heap = .text:0x802F1560; // type:function si
 createCommandHeap__5mHeapFUlPQ23EGG4Heap = .text:0x802F1590; // type:function size:0x2C
 createDylinkHeap__5mHeapFUlPQ23EGG4Heap = .text:0x802F15C0; // type:function size:0x2C
 createAssertHeap__5mHeapFPQ23EGG4Heap = .text:0x802F15F0; // type:function size:0x50
-fn_802F1640 = .text:0x802F1640; // type:function size:0x20
+makeHeapOnCurrentGameHeap__5mHeapFUlPciUi = .text:0x802F1640; // type:function size:0x20
 fn_802F1660 = .text:0x802F1660; // type:function size:0x44
 fn_802F16B0 = .text:0x802F16B0; // type:function size:0xBC
 fn_802F1770 = .text:0x802F1770; // type:function size:0x4C
@@ -40875,7 +40875,7 @@ lbl_80576720 = .sbss:0x80576720; // type:object size:0x8 data:byte
 lbl_80576728 = .sbss:0x80576728; // type:object size:0x8 data:byte
 lbl_80576730 = .sbss:0x80576730; // type:object size:0x8 data:byte
 lbl_80576738 = .sbss:0x80576738; // type:object size:0x8 data:4byte
-lbl_80576740 = .sbss:0x80576740; // type:object size:0x4 data:4byte
+sCurrentHeap__Q23EGG4Heap = .sbss:0x80576740; // type:object size:0x4 data:4byte
 lbl_80576744 = .sbss:0x80576744; // type:object size:0x4 data:4byte
 lbl_80576748 = .sbss:0x80576748; // type:object size:0x4 data:4byte
 lbl_8057674C = .sbss:0x8057674C; // type:object size:0x4 data:4byte
diff --git a/include/m/m_heap.h b/include/m/m_heap.h
index 38c737e7..c4a8d204 100644
--- a/include/m/m_heap.h
+++ b/include/m/m_heap.h
@@ -15,29 +15,29 @@ class AssertHeap;
 } // namespace EGG
 // TODO: Doc symbols and func locations
 namespace mHeap {
-/* 802f0f00 */ u8 copyAttribute(u32);
+/* 802f0f00 */ u16 copyAttribute(u32);
 /* 802f0f40 */ EGG::Heap *setCurrentHeap(EGG::Heap *);
 /* 802f0f50 */ EGG::ExpHeap *createExpHeap(size_t size, EGG::Heap *parentHeap, char *name, s32 align, u32 unk);
-/* 802f1060 */ void adjustExpHeap(EGG::Heap *heap);
-/* 802f10d0 */ s32 expHeapCost(size_t start, size_t size);
+/* 802f1060 */ size_t adjustExpHeap(EGG::Heap *heap);
+/* 802f10d0 */ size_t expHeapCost(size_t start, size_t size);
 /* 802f10f0 */ EGG::FrmHeap *createFrmHeap(size_t size, EGG::Heap *parentHeap, char *name, s32 align, u32 unk);
 /* 802f1200 */ void destroyFrmHeap(EGG::FrmHeap *heap);
 /* 802f1220 */ size_t adjustFrmHeap(EGG::FrmHeap *heap);
-/* 802f1290 */ s32 frmHeapCost(size_t start, size_t size);
-/* 802f12b0 */ void setTempHeap(EGG::Heap **prevHeap, EGG::Heap *tempNewHeap);
-/* 802f12f0 */ void restoreTempHeap(EGG::Heap **prevHeap);
-/* 802f1350 */ void createHeap(size_t size, EGG::Heap *, char *name);
+/* 802f1290 */ size_t frmHeapCost(size_t start, size_t size);
+/* 802f12b0 */ EGG::Heap **setTempHeap(EGG::Heap **prevHeap, EGG::Heap *tempNewHeap);
+/* 802f12f0 */ EGG::Heap **restoreTempHeap(EGG::Heap **prevHeap, s32 size);
+/* 802f1350 */ EGG::ExpHeap *createHeap(size_t size, EGG::Heap *, char *name);
 /* 802f13d0 */ void saveCurrentHeap();
 /* 802f13e0 */ void restoreCurrentHeap();
 /* 802f1410 */ EGG::FrmHeap *makeFrmHeapAndUpdate(size_t size, EGG::Heap *parentHeap, const char *name, s32 align,
         u32 unk);
 /* 802f1450 */ int getGameHeapNum();
-/* 802f1460 */ EGG::Heap *createGameHeap(s32 heapNum, size_t size, EGG::Heap *parentHeap);
+/* 802f1460 */ EGG::ExpHeap *createGameHeap(s32 heapNum, size_t size, EGG::Heap *parentHeap);
 /* 802f1510 */ EGG::Heap *createGameHeap1(s32 size, EGG::Heap *parentHeap);
-/* 802f1560 */ void createArchiveHeap(size_t size, EGG::Heap *parentHeap);
-/* 802f1590 */ void createCommandHeap(size_t size, EGG::Heap *parentHeap);
-/* 802f15c0 */ void createDylinkHeap(size_t size, EGG::Heap *parentHeap);
-/* 802f15f0 */ void createAssertHeap(EGG::Heap *parentHeap);
+/* 802f1560 */ EGG::ExpHeap *createArchiveHeap(size_t size, EGG::Heap *parentHeap);
+/* 802f1590 */ EGG::ExpHeap *createCommandHeap(size_t size, EGG::Heap *parentHeap);
+/* 802f15c0 */ EGG::ExpHeap *createDylinkHeap(size_t size, EGG::Heap *parentHeap);
+/* 802f15f0 */ EGG::AssertHeap *createAssertHeap(EGG::Heap *parentHeap);
 /* 802f1640 */ EGG::Heap *makeHeapOnCurrentGameHeap(size_t size, char *name, s32 align, u32 unk);
 extern EGG::ExpHeap *g_gameHeaps[4];
 extern EGG::ExpHeap *s_SavedCurrentHeap;
diff --git a/src/m/m_heap.cpp b/src/m/m_heap.cpp
index 5595136b..e2e31385 100644
--- a/src/m/m_heap.cpp
+++ b/src/m/m_heap.cpp
@@ -1,6 +1,7 @@
 #include <egg/core/eggAssertHeap.h>
 #include <egg/core/eggExpHeap.h>
 #include <egg/core/eggFrmHeap.h>
+#include <m/m_heap.h>
 
 namespace mHeap {
 
@@ -12,6 +13,8 @@ static const char *s_GameHeapNames[4] = {
         0,
 };
 
+#define MIN_ALIGN 0x20
+
 EGG::ExpHeap *g_gameHeaps[4];
 EGG::ExpHeap *s_SavedCurrentHeap;
 EGG::ExpHeap *g_archiveHeap;
@@ -19,23 +22,162 @@ EGG::ExpHeap *g_commandHeap;
 EGG::ExpHeap *g_dylinkHeap;
 EGG::AssertHeap *g_assertHeap;
 
-u32 getHeapAttribute(u32) {}
+u16 copyAttribute(u32 arg) {
+    u16 result = 0;
+    
+    if ((arg & 1) != 0) {
+        result = 1;
+    }
+    if ((arg & 2) != 0) {
+        result |= 2;
+    }
+    if ((arg & 4) != 0) {
+        result |= 4;
+    }
+    return result;
+}
 
 EGG::Heap *setCurrentHeap(EGG::Heap *heap) {
     return heap->becomeCurrentHeap();
 }
-EGG::ExpHeap *createExpHeap(size_t, EGG::Heap *parent, const char *name, unsigned long, unsigned long) {}
-void adjustExpHeap(EGG::ExpHeap *) {}
-size_t expHeapCost(unsigned long, unsigned long) {}
+EGG::ExpHeap *createExpHeap(size_t size, EGG::Heap *parent, const char *name, unsigned long align, unsigned long attrs) {
+    if (parent == nullptr) {
+        parent = EGG::Heap::sCurrentHeap;
+    }
 
-EGG::FrmHeap *createFrmHeap(unsigned long, EGG::Heap *, const char *, unsigned long, unsigned long) {}
-void destroyFrmHeap(EGG::FrmHeap *) {}
-size_t adjustFrmHeap(EGG::FrmHeap *) {}
-size_t frmHeapCost(unsigned long, unsigned long) {}
+    if (align < MIN_ALIGN) {
+        align = MIN_ALIGN;
+    }
 
-EGG::ExpHeap *createHeap(unsigned long, EGG::Heap *, const char *) {}
-void saveCurrentHeap() {}
-void restoreCurrentHeap() {}
+    if (size != 0xFFFFFFFF) {
+        size = expHeapCost(size, align);
+    } else {
+        size = parent->getAllocatableSize(align);
+    }
+
+    void *mem = parent->alloc(size, align);
+    EGG::ExpHeap *heap = nullptr;
+    if (mem != nullptr) {
+        heap = EGG::ExpHeap::create(mem, size, copyAttribute(attrs));
+        if (heap == nullptr) {
+            parent->free(mem);
+        } else if (name != nullptr) {
+            heap->mName = name;
+        }
+    }
+    return heap;
+}
+
+size_t adjustExpHeap(EGG::ExpHeap *heap) {
+    int ret = 0;
+    if (heap != nullptr) {
+        size_t ad = heap->adjust();
+        size_t cost = mHeap::frmHeapCost(0, 4);
+        if (ad >= cost) {
+            ret = ad - cost;
+        } 
+    }
+    return ret;
+}
+size_t expHeapCost(size_t size, size_t align) {
+    // TODO this generates an andc where it should be a nor + and
+    size_t r5 = align - 1;
+    return size + (~r5 & (r5 + 0x84));
+}
+
+EGG::FrmHeap *createFrmHeap(size_t size, EGG::Heap *parent, const char *name, unsigned long align, unsigned long attrs) {
+    if (parent == nullptr) {
+        parent = EGG::Heap::sCurrentHeap;
+    }
+
+    if (align < MIN_ALIGN) {
+        align = MIN_ALIGN;
+    }
+
+    if (size != 0xFFFFFFFF) {
+        size = expHeapCost(size, align);
+    } else {
+        size = parent->getAllocatableSize(align);
+    }
+
+    void *mem = parent->alloc(size, align);
+    EGG::FrmHeap *heap = nullptr;
+    if (mem != nullptr) {
+        heap = EGG::FrmHeap::create(mem, size, copyAttribute(attrs));
+        if (heap == nullptr) {
+            parent->free(mem);
+        } else if (name != nullptr) {
+            heap->mName = name;
+        }
+    }
+    return heap;
+}
+void destroyFrmHeap(EGG::FrmHeap *heap) {
+    if (heap != nullptr) {
+        heap->destroy();
+    }
+}
+
+size_t adjustFrmHeap(EGG::FrmHeap *heap) {
+    int ret = 0;
+    if (heap != nullptr) {
+        size_t ad = heap->adjust();
+        size_t cost = mHeap::frmHeapCost(0, 4);
+        if (ad >= cost) {
+            ret = ad - cost;
+        } 
+    }
+    return ret;
+}
+
+size_t frmHeapCost(size_t size, size_t align) {
+    size_t r5 = align - 1;
+    return size + (~r5 & (r5 + 0x7d));
+}
+
+EGG::Heap **setTempHeap(EGG::Heap **prevHeap, EGG::Heap *tempNewHeap) {
+    *prevHeap = tempNewHeap->becomeCurrentHeap();
+    return prevHeap;
+}
+EGG::Heap **restoreTempHeap(EGG::Heap **prevHeap, s32 size) {
+    if (prevHeap != nullptr) {
+        (*prevHeap)->becomeCurrentHeap();
+        if (size > 0) {
+            delete prevHeap;
+        }
+    }
+    return prevHeap;
+}
+
+EGG::ExpHeap *createHeap(size_t size, EGG::Heap *block, const char *name) {
+    EGG::ExpHeap *heap = EGG::ExpHeap::create(size, block, 4);
+    if (heap != nullptr) {
+        heap->setGroupID(0);
+        if (name != nullptr) {
+            heap->mName = name;
+        }
+    } else {
+        block->dump();
+    }
+
+    return heap;
+}
+void saveCurrentHeap() {
+    s_SavedCurrentHeap = (EGG::ExpHeap*) EGG::Heap::sCurrentHeap;
+}
+void restoreCurrentHeap() {
+    s_SavedCurrentHeap->becomeCurrentHeap();
+    EGG::Heap::sCurrentHeap = nullptr;
+}
+
+EGG::FrmHeap *makeFrmHeapAndUpdate(size_t size, EGG::Heap *parentHeap, const char *name, s32 align, u32 unk) {
+    EGG::FrmHeap *heap = createFrmHeap(size, parentHeap, name, align, unk);
+    if (heap != nullptr) {
+        EGG::Heap *heap2 = setCurrentHeap(heap);
+        s_SavedCurrentHeap = (EGG::ExpHeap*)heap2;
+    }
+    return heap;
+}
 
 int getDefaultGameHeapId() {
     return g_DefaultGameHeapId;
@@ -60,16 +202,26 @@ EGG::ExpHeap *createGameHeap1(size_t size, EGG::Heap *parent) {
     return createGameHeap(getDefaultGameHeapId(), size, parent);
 }
 EGG::ExpHeap *createArchiveHeap(size_t size, EGG::Heap *parent) {
-    g_archiveHeap = createHeap(size, parent, "");
+    g_archiveHeap = createHeap(size, parent, "汎用ファイル読み込み用ヒープ(mHeap::archiveHeap)");
+    return g_archiveHeap;
 }
 EGG::ExpHeap *createCommandHeap(size_t size, EGG::Heap *parent) {
     g_commandHeap = createHeap(size, parent, "DVD読み込みコマンド用ヒープ(mHeap::commandHeap)");
+    return g_commandHeap;
 }
 EGG::ExpHeap *createDylinkHeap(size_t size, EGG::Heap *parent) {
     g_dylinkHeap = createHeap(size, parent, "ダイナミックリンク用ヒープ(mHeap::dylinkHeap)");
+    return g_dylinkHeap;
 }
-EGG::ExpHeap *createAssertHeap(EGG::Heap *parent) {
+EGG::AssertHeap *createAssertHeap(EGG::Heap *parent) {
+    const char *name = "アサートヒープ(mHeap::assertHeap)";
     g_assertHeap = EGG::AssertHeap::create(EGG::AssertHeap::getSize(), parent);
-    g_assertHeap->mName = "アサートヒープ(mHeap::assertHeap)";
+    g_assertHeap->mName = name;
+    return g_assertHeap;
 }
+
+EGG::Heap *makeHeapOnCurrentGameHeap(size_t size, char *name, s32 align, u32 flags) {
+    return makeFrmHeapAndUpdate(size, g_gameHeaps[0], name, align, flags);
+}
+
 } // namespace mHeap

From 0ce436a27d94e9e33b73721e3d6087dc369ec540 Mon Sep 17 00:00:00 2001
From: CovenEsme <84377742+CovenEsme@users.noreply.github.com>
Date: Sat, 27 Apr 2024 16:12:27 +0100
Subject: [PATCH 05/16] Start skipflag_manager

---
 config/SOUE01/splits.txt            |  5 ++
 config/SOUE01/symbols.txt           | 16 +++---
 configure.py                        |  1 +
 src/toBeSorted/skipflag_manager.cpp | 80 +++++++++++++++++++++++++++++
 4 files changed, 94 insertions(+), 8 deletions(-)
 create mode 100644 src/toBeSorted/skipflag_manager.cpp

diff --git a/config/SOUE01/splits.txt b/config/SOUE01/splits.txt
index 78cb40ca..eb8e7ea3 100644
--- a/config/SOUE01/splits.txt
+++ b/config/SOUE01/splits.txt
@@ -122,6 +122,11 @@ toBeSorted/unk_flag_stuff.cpp:
 toBeSorted/bitwise_flag_helper.cpp:
 	.text       start:0x800BF200 end:0x800BF264
 
+toBeSorted/skipflag_manager.cpp:
+	.text       start:0x800BFBA0 end:0x800BFE00
+	.sbss       start:0x80575408 end:0x80575410
+	.bss        start:0x805A9C68 end:0x805A9C88
+
 f/f_base.cpp:
 	.text       start:0x802E12F0 end:0x802E2680
 	.ctors      start:0x804DB8C0 end:0x804DB8C4
diff --git a/config/SOUE01/symbols.txt b/config/SOUE01/symbols.txt
index 01d5e532..ad521e21 100644
--- a/config/SOUE01/symbols.txt
+++ b/config/SOUE01/symbols.txt
@@ -4180,14 +4180,14 @@ fn_800BF9F0 = .text:0x800BF9F0; // type:function size:0x6C
 fn_800BFA60 = .text:0x800BFA60; // type:function size:0x60
 fn_800BFAC0 = .text:0x800BFAC0; // type:function size:0x50
 fn_800BFB10 = .text:0x800BFB10; // type:function size:0x8C
-fn_800BFBA0 = .text:0x800BFBA0; // type:function size:0x44
-fn_800BFBF0 = .text:0x800BFBF0; // type:function size:0xC
-fn_800BFC00 = .text:0x800BFC00; // type:function size:0x2C
-fn_800BFC30 = .text:0x800BFC30; // type:function size:0xC
-fn_800BFC40 = .text:0x800BFC40; // type:function size:0x4
-fn_800BFC50 = .text:0x800BFC50; // type:function size:0xD0
-fn_800BFD20 = .text:0x800BFD20; // type:function size:0x68
-fn_800BFD90 = .text:0x800BFD90; // type:function size:0x70
+copyFromSave__15SkipflagManagerFv = .text:0x800BFBA0; // type:function size:0x44
+setCommitFlag__15SkipflagManagerFv = .text:0x800BFBF0; // type:function size:0xC
+__ct__15SkipflagManagerFv = .text:0x800BFC00; // type:function size:0x2C
+unsetCommitFlag__15SkipflagManagerFv = .text:0x800BFC30; // type:function size:0xC
+thunk_copyFromSave__15SkipflagManagerFv = .text:0x800BFC40; // type:function size:0x4
+setFlag__15SkipflagManagerFUs = .text:0x800BFC50; // type:function size:0xD0
+checkFlag__15SkipflagManagerFUs = .text:0x800BFD20; // type:function size:0x68
+commitFlags__15SkipflagManagerFv = .text:0x800BFD90; // type:function size:0x70
 fn_800BFE00 = .text:0x800BFE00; // type:function size:0x294
 fn_800C00A0 = .text:0x800C00A0; // type:function size:0x40
 fn_800C00E0 = .text:0x800C00E0; // type:function size:0x40
diff --git a/configure.py b/configure.py
index 95335230..b727a8c8 100644
--- a/configure.py
+++ b/configure.py
@@ -274,6 +274,7 @@ config.libs = [
             Object(Matching, "toBeSorted/sceneflag_manager.cpp"),
             Object(NonMatching, "toBeSorted/flag_space.cpp"),
             Object(NonMatching, "toBeSorted/misc_flag_managers.cpp"),
+            Object(NonMatching, "toBeSorted/skipflag_manager.cpp"),
             Object(Matching, "d/d_base.cpp"),
             Object(NonMatching, "d/d_heap.cpp"),
             Object(NonMatching, "d/d_stage.cpp"),
diff --git a/src/toBeSorted/skipflag_manager.cpp b/src/toBeSorted/skipflag_manager.cpp
new file mode 100644
index 00000000..d2fea774
--- /dev/null
+++ b/src/toBeSorted/skipflag_manager.cpp
@@ -0,0 +1,80 @@
+#include <libc.h>
+#include "toBeSorted/bitwise_flag_helper.h"
+#include "toBeSorted/file_manager.h"
+#include "toBeSorted/flag_space.h"
+
+class SkipflagManager {
+public:
+    bool mShouldCommit;
+    BitwiseFlagHelper mFlagHelper;
+    FlagSpace mFlagSpace;
+
+    static u16 sSkipFlags[16];
+    static SkipflagManager *sInstance;
+
+    void copyFromSave();
+    void setCommitFlag();
+    SkipflagManager();
+    void unsetCommitFlag();
+    void thunk_copyFromSave();
+    void setFlag(u16 flag);
+    bool checkFlag(u16 flag);
+    bool commitFlags();
+};
+
+SkipflagManager *SkipflagManager::sInstance = nullptr;
+u16 SkipflagManager::sSkipFlags[16] = {};
+
+// 800bfba0
+void SkipflagManager::copyFromSave() {
+    u16* savedSkipflags = FileManager::sInstance->getSkipFlags();
+    mFlagSpace.copyFromSaveFile(savedSkipflags, 0, 0x10);
+}
+
+// 800bfbf0
+void SkipflagManager::setCommitFlag() {
+    mShouldCommit = true;
+}
+
+// 800bfc00
+SkipflagManager::SkipflagManager() : mFlagSpace(sSkipFlags, ARRAY_LENGTH(sSkipFlags)) {
+    mShouldCommit = false;
+}
+
+// 800bfc30
+void SkipflagManager::unsetCommitFlag() {
+    mShouldCommit = false;
+}
+
+// 800bfc40
+void SkipflagManager::thunk_copyFromSave() {
+    SkipflagManager::copyFromSave();
+}
+
+// 800bfc50
+void SkipflagManager::setFlag(u16 flag) {
+    mFlagHelper.setFlag(flag / 16, flag % 16, mFlagSpace.getFlagPtrChecked(), mFlagSpace.mCount);
+
+    u16* savedSkipflags;
+    checkedMemcpy(savedSkipflags, 0x20, FileManager::sInstance->getSkipFlags(), 0x20);
+
+    mFlagHelper.setFlag(flag / 16, flag % 16, savedSkipflags, 0x10);
+    FileManager::sInstance->setSkipFlagsChecked(savedSkipflags, 0, 0x10);
+    setCommitFlag();
+}
+
+// 800bfd20
+bool SkipflagManager::checkFlag(u16 flag) {
+    u16* savedSkipflags = FileManager::sInstance->getSkipFlags();
+    return mFlagHelper.checkFlag(flag / 16, flag % 16, savedSkipflags, 0x10);
+}
+
+// 800bfd90
+bool SkipflagManager::commitFlags() {
+    if (mShouldCommit) {
+        FileManager::sInstance->setSkipFlagsChecked(mFlagSpace.getFlagPtrUnchecked(), 0, 0x10);
+        mShouldCommit = false;
+        return true;
+    }
+    return false;
+}

From 5aa8bd513e7ebc3757ba69516e81bce59b571def Mon Sep 17 00:00:00 2001
From: robojumper <robojumper@gmail.com>
Date: Sat, 27 Apr 2024 17:55:48 +0200
Subject: [PATCH 06/16] skipflag_manager.cpp Matching

---
 config/SOUE01/splits.txt            |  2 +-
 config/SOUE01/symbols.txt           |  6 +++---
 configure.py                        |  2 +-
 src/toBeSorted/skipflag_manager.cpp | 16 +++++++++-------
 4 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/config/SOUE01/splits.txt b/config/SOUE01/splits.txt
index 7aac89f2..036fb830 100644
--- a/config/SOUE01/splits.txt
+++ b/config/SOUE01/splits.txt
@@ -124,7 +124,7 @@ toBeSorted/bitwise_flag_helper.cpp:
 
 toBeSorted/skipflag_manager.cpp:
 	.text       start:0x800BFBA0 end:0x800BFE00
-	.sbss       start:0x80575408 end:0x80575410
+	.sbss       start:0x80575408 end:0x8057540C
 	.bss        start:0x805A9C68 end:0x805A9C88
 
 c/c_list.cpp:
diff --git a/config/SOUE01/symbols.txt b/config/SOUE01/symbols.txt
index e6b05bf0..b0af2c9b 100644
--- a/config/SOUE01/symbols.txt
+++ b/config/SOUE01/symbols.txt
@@ -4181,7 +4181,7 @@ fn_800BFA60 = .text:0x800BFA60; // type:function size:0x60
 fn_800BFAC0 = .text:0x800BFAC0; // type:function size:0x50
 fn_800BFB10 = .text:0x800BFB10; // type:function size:0x8C
 copyFromSave__15SkipflagManagerFv = .text:0x800BFBA0; // type:function size:0x44
-setCommitFlag__15SkipflagManagerFv = .text:0x800BFBF0; // type:function size:0xC
+setCommitFlag__15SkipflagManagerFUs = .text:0x800BFBF0; // type:function size:0xC
 __ct__15SkipflagManagerFv = .text:0x800BFC00; // type:function size:0x2C
 unsetCommitFlag__15SkipflagManagerFv = .text:0x800BFC30; // type:function size:0xC
 thunk_copyFromSave__15SkipflagManagerFv = .text:0x800BFC40; // type:function size:0x4
@@ -39849,7 +39849,7 @@ lbl_805753F8 = .sbss:0x805753F8; // type:object size:0x4 data:4byte
 lbl_805753FC = .sbss:0x805753FC; // type:object size:0x4 data:4byte
 lbl_80575400 = .sbss:0x80575400; // type:object size:0x4 data:4byte
 lbl_80575404 = .sbss:0x80575404; // type:object size:0x4 data:4byte
-lbl_80575408 = .sbss:0x80575408; // type:object size:0x8 data:4byte
+sInstance__15SkipflagManager = .sbss:0x80575408; // type:object size:0x4 data:4byte
 lbl_80575410 = .sbss:0x80575410; // type:object size:0x8 data:4byte
 lbl_80575418 = .sbss:0x80575418; // type:object size:0x8
 lbl_80575420 = .sbss:0x80575420; // type:object size:0x8 data:byte
@@ -48237,7 +48237,7 @@ lbl_805A7AD8 = .bss:0x805A7AD8; // type:object size:0x2000
 lbl_805A9AD8 = .bss:0x805A9AD8; // type:object size:0x100
 lbl_805A9BD8 = .bss:0x805A9BD8; // type:object size:0x80
 lbl_805A9C58 = .bss:0x805A9C58; // type:object size:0x10
-lbl_805A9C68 = .bss:0x805A9C68; // type:object size:0x20
+sSkipFlags__15SkipflagManager = .bss:0x805A9C68; // type:object size:0x20
 lbl_805A9C88 = .bss:0x805A9C88; // type:object size:0x10 data:4byte
 lbl_805A9C98 = .bss:0x805A9C98; // type:object size:0x208
 lbl_805A9EA0 = .bss:0x805A9EA0; // type:object size:0x40 data:4byte
diff --git a/configure.py b/configure.py
index cd1f3140..3cdbb416 100644
--- a/configure.py
+++ b/configure.py
@@ -274,7 +274,7 @@ config.libs = [
             Object(Matching, "toBeSorted/sceneflag_manager.cpp"),
             Object(NonMatching, "toBeSorted/flag_space.cpp"),
             Object(NonMatching, "toBeSorted/misc_flag_managers.cpp"),
-            Object(NonMatching, "toBeSorted/skipflag_manager.cpp"),
+            Object(Matching, "toBeSorted/skipflag_manager.cpp"),
             Object(Matching, "c/c_list.cpp"),
             Object(Matching, "d/d_base.cpp"),
             Object(NonMatching, "d/d_heap.cpp"),
diff --git a/src/toBeSorted/skipflag_manager.cpp b/src/toBeSorted/skipflag_manager.cpp
index d2fea774..23cfe946 100644
--- a/src/toBeSorted/skipflag_manager.cpp
+++ b/src/toBeSorted/skipflag_manager.cpp
@@ -13,7 +13,7 @@ public:
     static SkipflagManager *sInstance;
 
     void copyFromSave();
-    void setCommitFlag();
+    void setCommitFlag(u16 flag);
     SkipflagManager();
     void unsetCommitFlag();
     void thunk_copyFromSave();
@@ -22,7 +22,9 @@ public:
     bool commitFlags();
 };
 
+// 0x80575408
 SkipflagManager *SkipflagManager::sInstance = nullptr;
+// 0x805A9C68
 u16 SkipflagManager::sSkipFlags[16] = {};
 
 // 800bfba0
@@ -32,13 +34,12 @@ void SkipflagManager::copyFromSave() {
 }
 
 // 800bfbf0
-void SkipflagManager::setCommitFlag() {
+void SkipflagManager::setCommitFlag(u16 flag) {
     mShouldCommit = true;
 }
 
 // 800bfc00
-SkipflagManager::SkipflagManager() : mFlagSpace(sSkipFlags, ARRAY_LENGTH(sSkipFlags)) {
-    mShouldCommit = false;
+SkipflagManager::SkipflagManager() : mFlagSpace(sSkipFlags, ARRAY_LENGTH(sSkipFlags)), mShouldCommit(false) {
 }
 
 // 800bfc30
@@ -55,12 +56,12 @@ void SkipflagManager::thunk_copyFromSave() {
 void SkipflagManager::setFlag(u16 flag) {
     mFlagHelper.setFlag(flag / 16, flag % 16, mFlagSpace.getFlagPtrChecked(), mFlagSpace.mCount);
 
-    u16* savedSkipflags;
+    u16 savedSkipflags[0x10];
     checkedMemcpy(savedSkipflags, 0x20, FileManager::sInstance->getSkipFlags(), 0x20);
 
     mFlagHelper.setFlag(flag / 16, flag % 16, savedSkipflags, 0x10);
     FileManager::sInstance->setSkipFlagsChecked(savedSkipflags, 0, 0x10);
-    setCommitFlag();
+    setCommitFlag(flag);
 }
 
 // 800bfd20
@@ -72,7 +73,8 @@ bool SkipflagManager::checkFlag(u16 flag) {
 // 800bfd90
 bool SkipflagManager::commitFlags() {
     if (mShouldCommit) {
-        FileManager::sInstance->setSkipFlagsChecked(mFlagSpace.getFlagPtrUnchecked(), 0, 0x10);
+        FileManager *instance = FileManager::sInstance;
+        instance->setSkipFlagsChecked(mFlagSpace.getFlagPtrUnchecked(), 0, 0x10);
         mShouldCommit = false;
         return true;
     }

From 33f093480fcafb9fa1e935adff29fd708d6c04c5 Mon Sep 17 00:00:00 2001
From: elijah-thomas774 <elijahthomas774@gmail.com>
Date: Sat, 27 Apr 2024 14:10:42 -0400
Subject: [PATCH 07/16] fixed up a couple symbols for egg that mHeap uses.
 Couple fixes

---
 config/SOUE01/symbols.txt        |  2 +-
 include/egg/core/eggAssertHeap.h |  6 +++---
 include/egg/core/eggExpHeap.h    |  2 +-
 include/egg/core/eggFrmHeap.h    |  2 +-
 include/m/m_heap.h               |  4 ++--
 src/m/m_heap.cpp                 | 33 ++++++++++++++++----------------
 6 files changed, 25 insertions(+), 24 deletions(-)

diff --git a/config/SOUE01/symbols.txt b/config/SOUE01/symbols.txt
index 48e5a939..13e295d0 100644
--- a/config/SOUE01/symbols.txt
+++ b/config/SOUE01/symbols.txt
@@ -26249,7 +26249,7 @@ resizeForMBlock__Q23EGG10AssertHeapFPvUl = .text:0x80496760; // type:function si
 getTotalFreeSize__Q23EGG10AssertHeapFv = .text:0x80496770; // type:function size:0x8
 getAllocatableSize__Q23EGG10AssertHeapFl = .text:0x80496780; // type:function size:0x8
 adjust__Q23EGG10AssertHeapFv = .text:0x80496790; // type:function size:0x78
-getAssertHeapSize__Q23EGG10AssertHeapCFv = .text:0x80496810; // type:function size:0x8
+getSize__Q23EGG10AssertHeapFv = .text:0x80496810; // type:function size:0x8
 getHeapKind__Q23EGG10AssertHeapCFv = .text:0x80496820; // type:function size:0x8
 __ct__Q23EGG8DisposerFv = .text:0x80496830; // type:function size:0x54
 __dt__Q23EGG8DisposerFv = .text:0x80496890; // type:function size:0x74
diff --git a/include/egg/core/eggAssertHeap.h b/include/egg/core/eggAssertHeap.h
index 69956cd7..983a94bc 100644
--- a/include/egg/core/eggAssertHeap.h
+++ b/include/egg/core/eggAssertHeap.h
@@ -21,9 +21,9 @@ public:
 
 public:
     /* 804963a0 */ AssertHeap(MEMiHeapHead *heapHead);
-    /* 80496460 */ static AssertHeap *create(void *block, u32 size, u16 attr);
-    /* 80496530 */ static AssertHeap *create(u32 size, Heap *heap);
-    /* 80496810 */ static u32 getSize(); // returns 0x7C
+    /* 80496460 */ static AssertHeap *create(void *block, size_t size, u16 attr);
+    /* 80496530 */ static AssertHeap *create(size_t size, Heap *heap);
+    /* 80496810 */ static size_t getSize(); // returns 0x7C
 };
 
 } // namespace EGG
diff --git a/include/egg/core/eggExpHeap.h b/include/egg/core/eggExpHeap.h
index 41d4f250..2cfc534d 100644
--- a/include/egg/core/eggExpHeap.h
+++ b/include/egg/core/eggExpHeap.h
@@ -21,7 +21,7 @@ public:
 
 public:
     /* 80495ab0 */ ExpHeap(MEMiHeapHead *heapHead);
-    /* 80495b70 */ static ExpHeap *create(void *block, u32 size, u16 attr);
+    /* 80495b70 */ static ExpHeap *create(void *block, size_t size, u16 attr);
     /* 80495c30 */ static ExpHeap *create(size_t size, Heap *heap, u16 attr);
     /* 80495d00 */ void setGroupID(u16 groupId);
     /* 80495f80 */ u32 getSizeForMBlock(const void *block);
diff --git a/include/egg/core/eggFrmHeap.h b/include/egg/core/eggFrmHeap.h
index 57b2f0de..f68e8e4f 100644
--- a/include/egg/core/eggFrmHeap.h
+++ b/include/egg/core/eggFrmHeap.h
@@ -21,7 +21,7 @@ public:
 
 public:
     /* 80495fa0 */ FrmHeap(MEMiHeapHead *heapHead);
-    /* 80496060 */ static FrmHeap *create(void *block, u32 size, u16 attr);
+    /* 80496060 */ static FrmHeap *create(void *block, size_t size, u16 attr);
     /* 804962a0 */ void free(u32 flags);
     /* 80496370 */ void recordState(u32 id); // non official for now
     /* 80496380 */ void freeState(u32 id);   // non official for now
diff --git a/include/m/m_heap.h b/include/m/m_heap.h
index c4a8d204..4ee94d11 100644
--- a/include/m/m_heap.h
+++ b/include/m/m_heap.h
@@ -1,8 +1,8 @@
 #ifndef M_HEAP_H
 #define M_HEAP_H
 
+#include "egg/core/eggExpHeap.h"
 #include "egg/core/eggFrmHeap.h"
-#include "egg/core/eggHeap.h"
 
 // #include "egg/core/eggExpHeap.h"
 // #include "egg/core/eggAssertHeap.h"
@@ -20,7 +20,7 @@ namespace mHeap {
 /* 802f0f50 */ EGG::ExpHeap *createExpHeap(size_t size, EGG::Heap *parentHeap, char *name, s32 align, u32 unk);
 /* 802f1060 */ size_t adjustExpHeap(EGG::Heap *heap);
 /* 802f10d0 */ size_t expHeapCost(size_t start, size_t size);
-/* 802f10f0 */ EGG::FrmHeap *createFrmHeap(size_t size, EGG::Heap *parentHeap, char *name, s32 align, u32 unk);
+/* 802f10f0 */ EGG::FrmHeap *createFrmHeap(size_t size, EGG::Heap *parentHeap, char *name, size_t align, size_t attrs);
 /* 802f1200 */ void destroyFrmHeap(EGG::FrmHeap *heap);
 /* 802f1220 */ size_t adjustFrmHeap(EGG::FrmHeap *heap);
 /* 802f1290 */ size_t frmHeapCost(size_t start, size_t size);
diff --git a/src/m/m_heap.cpp b/src/m/m_heap.cpp
index e2e31385..4e932d30 100644
--- a/src/m/m_heap.cpp
+++ b/src/m/m_heap.cpp
@@ -6,12 +6,6 @@
 namespace mHeap {
 
 u8 g_DefaultGameHeapId = 1;
-static const char *s_GameHeapNames[4] = {
-        0,
-        "ゲーム用汎用ヒープ1(mHeap::gameHeaps[1])",
-        "ゲーム用汎用ヒープ2(mHeap::gameHeaps[2])",
-        0,
-};
 
 #define MIN_ALIGN 0x20
 
@@ -24,7 +18,7 @@ EGG::AssertHeap *g_assertHeap;
 
 u16 copyAttribute(u32 arg) {
     u16 result = 0;
-    
+
     if ((arg & 1) != 0) {
         result = 1;
     }
@@ -40,7 +34,8 @@ u16 copyAttribute(u32 arg) {
 EGG::Heap *setCurrentHeap(EGG::Heap *heap) {
     return heap->becomeCurrentHeap();
 }
-EGG::ExpHeap *createExpHeap(size_t size, EGG::Heap *parent, const char *name, unsigned long align, unsigned long attrs) {
+EGG::ExpHeap *createExpHeap(size_t size, EGG::Heap *parent, const char *name, unsigned long align,
+        unsigned long attrs) {
     if (parent == nullptr) {
         parent = EGG::Heap::sCurrentHeap;
     }
@@ -72,10 +67,10 @@ size_t adjustExpHeap(EGG::ExpHeap *heap) {
     int ret = 0;
     if (heap != nullptr) {
         size_t ad = heap->adjust();
-        size_t cost = mHeap::frmHeapCost(0, 4);
+        size_t cost = mHeap::expHeapCost(0, 4);
         if (ad >= cost) {
             ret = ad - cost;
-        } 
+        }
     }
     return ret;
 }
@@ -85,7 +80,7 @@ size_t expHeapCost(size_t size, size_t align) {
     return size + (~r5 & (r5 + 0x84));
 }
 
-EGG::FrmHeap *createFrmHeap(size_t size, EGG::Heap *parent, const char *name, unsigned long align, unsigned long attrs) {
+EGG::FrmHeap *createFrmHeap(size_t size, EGG::Heap *parent, const char *name, size_t align, size_t attrs) {
     if (parent == nullptr) {
         parent = EGG::Heap::sCurrentHeap;
     }
@@ -95,7 +90,7 @@ EGG::FrmHeap *createFrmHeap(size_t size, EGG::Heap *parent, const char *name, un
     }
 
     if (size != 0xFFFFFFFF) {
-        size = expHeapCost(size, align);
+        size = frmHeapCost(size, align);
     } else {
         size = parent->getAllocatableSize(align);
     }
@@ -125,7 +120,7 @@ size_t adjustFrmHeap(EGG::FrmHeap *heap) {
         size_t cost = mHeap::frmHeapCost(0, 4);
         if (ad >= cost) {
             ret = ad - cost;
-        } 
+        }
     }
     return ret;
 }
@@ -163,18 +158,18 @@ EGG::ExpHeap *createHeap(size_t size, EGG::Heap *block, const char *name) {
     return heap;
 }
 void saveCurrentHeap() {
-    s_SavedCurrentHeap = (EGG::ExpHeap*) EGG::Heap::sCurrentHeap;
+    s_SavedCurrentHeap = (EGG::ExpHeap *)EGG::Heap::sCurrentHeap;
 }
 void restoreCurrentHeap() {
     s_SavedCurrentHeap->becomeCurrentHeap();
-    EGG::Heap::sCurrentHeap = nullptr;
+    s_SavedCurrentHeap = nullptr;
 }
 
 EGG::FrmHeap *makeFrmHeapAndUpdate(size_t size, EGG::Heap *parentHeap, const char *name, s32 align, u32 unk) {
     EGG::FrmHeap *heap = createFrmHeap(size, parentHeap, name, align, unk);
     if (heap != nullptr) {
         EGG::Heap *heap2 = setCurrentHeap(heap);
-        s_SavedCurrentHeap = (EGG::ExpHeap*)heap2;
+        s_SavedCurrentHeap = (EGG::ExpHeap *)heap2;
     }
     return heap;
 }
@@ -188,6 +183,12 @@ inline bool isValidHeapId(u32 id) {
 }
 
 EGG::ExpHeap *createGameHeap(int heapId, size_t size, EGG::Heap *parent) {
+    const char *s_GameHeapNames[4] = {
+            0,
+            "ゲーム用汎用ヒープ1(mHeap::gameHeaps[1])",
+            "ゲーム用汎用ヒープ2(mHeap::gameHeaps[2])",
+            0,
+    };
     if (!isValidHeapId(heapId)) {
         return nullptr;
     }

From fe0b8ac1e80d51c0d62db4e2a0af1617fbbc23c8 Mon Sep 17 00:00:00 2001
From: elijah-thomas774 <elijahthomas774@gmail.com>
Date: Sat, 27 Apr 2024 14:22:52 -0400
Subject: [PATCH 08/16] added address comments

---
 src/c/c_list.cpp |  5 ++++-
 src/c/c_tree.cpp | 15 +++++++++++----
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/src/c/c_list.cpp b/src/c/c_list.cpp
index 5218c87d..9d39a755 100644
--- a/src/c/c_list.cpp
+++ b/src/c/c_list.cpp
@@ -1,6 +1,6 @@
 #include <c/c_list.h>
 
-
+/* 0x802E08C0 */
 void cListMg_c::insertAfter(cListNd_c *node, cListNd_c *prevNode) {
     if (prevNode == nullptr) {
         return this->prepend(node);
@@ -18,6 +18,7 @@ void cListMg_c::insertAfter(cListNd_c *node, cListNd_c *prevNode) {
     }
 }
 
+/* 0x802E0900 */
 void cListMg_c::remove(cListNd_c *node) {
     if (node == nullptr) {
         return;
@@ -46,6 +47,7 @@ void cListMg_c::remove(cListNd_c *node) {
     }
 }
 
+/* 0x802E09B0 */
 void cListMg_c::append(cListNd_c *node) {
     if (node == nullptr) {
         return;
@@ -59,6 +61,7 @@ void cListMg_c::append(cListNd_c *node) {
     this->mpLast = node;
 }
 
+/* 0x802E09E0 */
 void cListMg_c::prepend(cListNd_c *node) {
     if (node == nullptr) {
         return;
diff --git a/src/c/c_tree.cpp b/src/c/c_tree.cpp
index a413761f..9ed5eda0 100644
--- a/src/c/c_tree.cpp
+++ b/src/c/c_tree.cpp
@@ -1,16 +1,19 @@
 #include <c/c_tree.h>
 
+/* 0x802E0E70 */
 cTreeNd_c::cTreeNd_c() {
     this->forcedClear();
 }
 
+/* 0x802E0EA0 */
 void cTreeNd_c::forcedClear() {
     this->mpParent = nullptr;
-    this->mpChild = nullptr;   
+    this->mpChild = nullptr;
     this->mpPrev = nullptr;
     this->mpNext = nullptr;
 }
 
+/* 0x802E0EC0 */
 bool cTreeMg_c::addTreeNode(cTreeNd_c *node, cTreeNd_c *parent) {
     if (node != nullptr) {
         if (parent != nullptr) {
@@ -39,13 +42,14 @@ bool cTreeMg_c::addTreeNode(cTreeNd_c *node, cTreeNd_c *parent) {
     return true;
 }
 
+/* 0x802E0F60*/
 bool cTreeMg_c::removeTreeNode(cTreeNd_c *node) {
     if (node != nullptr) {
         if (node->mpChild != nullptr) {
             return false;
         }
         if (node->mpPrev != nullptr) {
-            node->mpPrev->mpNext = node->mpNext; 
+            node->mpPrev->mpNext = node->mpNext;
         } else if (node->mpParent != nullptr) {
             node->mpParent->mpChild = node->mpNext;
         } else if (node == this->mpRootNode) {
@@ -65,6 +69,7 @@ bool cTreeMg_c::removeTreeNode(cTreeNd_c *node) {
     return true;
 }
 
+/* 0x802E1000 */
 bool cTreeMg_c::insertTreeNode(cTreeNd_c *node, cTreeNd_c *parent) {
     cTreeNd_c *cursor;
 
@@ -89,6 +94,7 @@ bool cTreeMg_c::insertTreeNode(cTreeNd_c *node, cTreeNd_c *parent) {
     return false;
 }
 
+/* 0x802E10C0 */
 cTreeNd_c *cTreeNd_c::getTreeNext() const {
     cTreeNd_c *child = this->mpChild;
     if (child != nullptr) {
@@ -98,17 +104,18 @@ cTreeNd_c *cTreeNd_c::getTreeNext() const {
     }
 }
 
+/* 0x802E1100 */
 cTreeNd_c *cTreeNd_c::getTreeNextNotChild() const {
     if (this->mpNext != nullptr) {
         return this->mpNext;
     }
 
     cTreeNd_c *parent;
-    
+
     for (parent = this->mpParent; parent != nullptr; parent = parent->mpParent) {
         if (parent->mpNext != nullptr) {
             return parent->mpNext;
-        }   
+        }
     }
     return nullptr;
 }

From d8a92706433ab5597c06ac5d5a12c7243135f1ad Mon Sep 17 00:00:00 2001
From: elijah-thomas774 <elijahthomas774@gmail.com>
Date: Sat, 27 Apr 2024 14:54:26 -0400
Subject: [PATCH 09/16] fixed TBoxFlageManager::CopyFromSave - sceneIdx is
 signed

---
 config/SOUE01/symbols.txt             |  2 +-
 src/toBeSorted/misc_flag_managers.cpp | 16 +++++++---------
 2 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/config/SOUE01/symbols.txt b/config/SOUE01/symbols.txt
index b0af2c9b..19eb19be 100644
--- a/config/SOUE01/symbols.txt
+++ b/config/SOUE01/symbols.txt
@@ -4106,7 +4106,7 @@ doCommit__15TBoxFlagManagerFv = .text:0x800BE810; // type:function size:0x58
 checkUncommittedFlag__15TBoxFlagManagerFUs = .text:0x800BE870; // type:function size:0x68
 __ct__15TBoxFlagManagerFv = .text:0x800BE8E0; // type:function size:0x40
 init__15TBoxFlagManagerFv = .text:0x800BE920; // type:function size:0x4
-copyFromSave__15TBoxFlagManagerFUs = .text:0x800BE930; // type:function size:0x5C
+copyFromSave__15TBoxFlagManagerFs = .text:0x800BE930; // type:function size:0x5C
 checkFlag__15TBoxFlagManagerFUsUs = .text:0x800BE990; // type:function size:0x94
 getFlagCount__15TBoxFlagManagerCFv = .text:0x800BEA30; // type:function size:0x8
 setFlag__15TBoxFlagManagerFUs = .text:0x800BEA40; // type:function size:0x80
diff --git a/src/toBeSorted/misc_flag_managers.cpp b/src/toBeSorted/misc_flag_managers.cpp
index e908dd73..4abcd7f4 100644
--- a/src/toBeSorted/misc_flag_managers.cpp
+++ b/src/toBeSorted/misc_flag_managers.cpp
@@ -4,7 +4,6 @@
 #include <toBeSorted/file_manager.h>
 #include <toBeSorted/flag_space.h>
 
-
 class CommittableFlagManager {
 public:
     bool mNeedsCommit;
@@ -47,7 +46,7 @@ public:
     TBoxFlagManager();
     virtual ~TBoxFlagManager() {}
     void init();
-    void copyFromSave(u16 sceneIndex);
+    void copyFromSave(s16 sceneIndex);
     bool checkFlag(u16 sceneIndex, u16 flag);
     virtual u16 getFlagCount() const;
     void setFlag(u16 flag);
@@ -76,11 +75,11 @@ TBoxFlagManager::TBoxFlagManager() : CommittableFlagManager(false), mFlagSpace(s
 
 void TBoxFlagManager::init() {}
 
-void TBoxFlagManager::copyFromSave(u16 sceneIndex) {
-    // mr should be a clrlwi
-    mSceneIndex = sceneIndex;
+void TBoxFlagManager::copyFromSave(s16 sceneIndex) {
+    u16 idx = sceneIndex;
+    mSceneIndex = idx;
     u16 *flags = FileManager::getInstance()->getTBoxFlagsConst();
-    mFlagSpace.copyFromSaveFile2(flags + (sceneIndex * 2), 0, 2);
+    mFlagSpace.copyFromSaveFile2(flags + (idx * 2), 0, 2);
 }
 
 bool TBoxFlagManager::checkFlag(u16 sceneIndex, u16 flag) {
@@ -144,9 +143,8 @@ bool EnemyDefeatManager::checkUncommittedFlag(u16 flag) {
     }
 }
 
-EnemyDefeatManager::EnemyDefeatManager() : CommittableFlagManager(false), mFlagSpace(sEnemyDefeatFlags, ARRAY_LENGTH(sEnemyDefeatFlags)) {
-
-}
+EnemyDefeatManager::EnemyDefeatManager()
+    : CommittableFlagManager(false), mFlagSpace(sEnemyDefeatFlags, ARRAY_LENGTH(sEnemyDefeatFlags)) {}
 
 void EnemyDefeatManager::init() {
     mSceneIndex = 0;

From c71784b42031491463199d65a5920508c5bcaa1d Mon Sep 17 00:00:00 2001
From: elijah-thomas774 <elijahthomas774@gmail.com>
Date: Sat, 27 Apr 2024 15:48:55 -0400
Subject: [PATCH 10/16] added a couple symbols, address comments

---
 config/SOUE01/symbols.txt             | 16 ++++++++--------
 src/toBeSorted/misc_flag_managers.cpp | 22 ++++++++++++++++++++++
 2 files changed, 30 insertions(+), 8 deletions(-)

diff --git a/config/SOUE01/symbols.txt b/config/SOUE01/symbols.txt
index 19eb19be..b6d1720c 100644
--- a/config/SOUE01/symbols.txt
+++ b/config/SOUE01/symbols.txt
@@ -4189,8 +4189,8 @@ setFlag__15SkipflagManagerFUs = .text:0x800BFC50; // type:function size:0xD0
 checkFlag__15SkipflagManagerFUs = .text:0x800BFD20; // type:function size:0x68
 commitFlags__15SkipflagManagerFv = .text:0x800BFD90; // type:function size:0x70
 fn_800BFE00 = .text:0x800BFE00; // type:function size:0x294
-fn_800C00A0 = .text:0x800C00A0; // type:function size:0x40
-fn_800C00E0 = .text:0x800C00E0; // type:function size:0x40
+__dt__15TBoxFlagManagerFv = .text:0x800C00A0; // type:function size:0x40
+__dt__18EnemyDefeatManagerFv = .text:0x800C00E0; // type:function size:0x40
 fn_800C0120 = .text:0x800C0120; // type:function size:0x58
 fn_800C0180 = .text:0x800C0180; // type:function size:0x58
 fn_800C01E0 = .text:0x800C01E0; // type:function size:0x8
@@ -31012,8 +31012,8 @@ lbl_80510C14 = .data:0x80510C14; // type:object size:0x14
 lbl_80510C28 = .data:0x80510C28; // type:object size:0x3C
 lbl_80510C64 = .data:0x80510C64; // type:object size:0x3C
 lbl_80510CA0 = .data:0x80510CA0; // type:object size:0x3C
-lbl_80510CDC = .data:0x80510CDC; // type:object size:0x14
-lbl_80510CF0 = .data:0x80510CF0; // type:object size:0x14
+__vt__18EnemyDefeatManager = .data:0x80510CDC; // type:object size:0x14
+__vt__15TBoxFlagManager = .data:0x80510CF0; // type:object size:0x14
 __vt__9FlagSpace = .data:0x80510D04; // type:object size:0xC
 lbl_80510D10 = .data:0x80510D10; // type:object size:0x38 data:4byte
 lbl_80510D48 = .data:0x80510D48; // type:object size:0x18
@@ -39843,9 +39843,9 @@ lbl_805753D0 = .sbss:0x805753D0; // type:object size:0x8 data:4byte
 lbl_805753D8 = .sbss:0x805753D8; // type:object size:0x8 data:4byte
 sInstance__16SceneflagManager = .sbss:0x805753E0; // type:object size:0x4 data:4byte
 sTempFlags__16SceneflagManager = .sbss:0x805753E8; // type:object size:0x8
-lbl_805753F0 = .sbss:0x805753F0; // type:object size:0x4 data:4byte
-lbl_805753F4 = .sbss:0x805753F4; // type:object size:0x4
-lbl_805753F8 = .sbss:0x805753F8; // type:object size:0x4 data:4byte
+sInstance__15TBoxFlagManager = .sbss:0x805753F0; // type:object size:0x4 data:4byte
+sTBoxFlags__15TBoxFlagManager = .sbss:0x805753F4; // type:object size:0x4
+sInstance__18EnemyDefeatManager = .sbss:0x805753F8; // type:object size:0x4 data:4byte
 lbl_805753FC = .sbss:0x805753FC; // type:object size:0x4 data:4byte
 lbl_80575400 = .sbss:0x80575400; // type:object size:0x4 data:4byte
 lbl_80575404 = .sbss:0x80575404; // type:object size:0x4 data:4byte
@@ -48233,7 +48233,7 @@ lbl_805A78B8 = .bss:0x805A78B8; // type:object size:0xC
 lbl_805A78C4 = .bss:0x805A78C4; // type:object size:0xC data:4byte
 lbl_805A78D0 = .bss:0x805A78D0; // type:object size:0x10
 lbl_805A78E0 = .bss:0x805A78E0; // type:object size:0x1F8
-lbl_805A7AD8 = .bss:0x805A7AD8; // type:object size:0x2000
+sEnemyDefeatFlags__18EnemyDefeatManager = .bss:0x805A7AD8; // type:object size:0x2000
 lbl_805A9AD8 = .bss:0x805A9AD8; // type:object size:0x100
 lbl_805A9BD8 = .bss:0x805A9BD8; // type:object size:0x80
 lbl_805A9C58 = .bss:0x805A9C58; // type:object size:0x10
diff --git a/src/toBeSorted/misc_flag_managers.cpp b/src/toBeSorted/misc_flag_managers.cpp
index 4abcd7f4..a3e8f264 100644
--- a/src/toBeSorted/misc_flag_managers.cpp
+++ b/src/toBeSorted/misc_flag_managers.cpp
@@ -21,6 +21,7 @@ public:
     }
 };
 
+/* 0x800BE7B0 */
 bool CommittableFlagManager::commitIfNecessary() {
     if (mNeedsCommit) {
         doCommit();
@@ -59,22 +60,27 @@ public:
 TBoxFlagManager *TBoxFlagManager::sInstance = nullptr;
 u16 TBoxFlagManager::sTBoxFlags[2] = {};
 
+/* 0x800BE810 */
 void TBoxFlagManager::doCommit() {
     if (mSceneIndex != 0xFFFF) {
         FileManager::getInstance()->setTBoxFlags(mFlagSpace.getFlagPtrUnchecked(), mSceneIndex * 2, 2);
     }
 }
 
+/* 0x800BE870 */
 bool TBoxFlagManager::checkUncommittedFlag(u16 flag) {
     return mFlagHelper.checkFlag(flag / 16, flag % 16, mFlagSpace.getFlagPtrUnchecked(), mFlagSpace.mCount);
 }
 
+/* 0x800BE8E0 */
 TBoxFlagManager::TBoxFlagManager() : CommittableFlagManager(false), mFlagSpace(sTBoxFlags, ARRAY_LENGTH(sTBoxFlags)) {
     mSceneIndex = 0xFFFF;
 }
 
+/* 0x800BE920 */
 void TBoxFlagManager::init() {}
 
+/* 0x800BE930 */
 void TBoxFlagManager::copyFromSave(s16 sceneIndex) {
     u16 idx = sceneIndex;
     mSceneIndex = idx;
@@ -82,16 +88,19 @@ void TBoxFlagManager::copyFromSave(s16 sceneIndex) {
     mFlagSpace.copyFromSaveFile2(flags + (idx * 2), 0, 2);
 }
 
+/* 0x800BE990 */
 bool TBoxFlagManager::checkFlag(u16 sceneIndex, u16 flag) {
     s32 actualFlag = (flag + sceneIndex * 0x20);
     return mFlagHelper.checkFlag(actualFlag / 16, flag % 16, FileManager::getInstance()->getTBoxFlagsConst(),
             getFlagCount());
 }
 
+/* 0x800BEA30 */
 u16 TBoxFlagManager::getFlagCount() const {
     return 0x200;
 }
 
+/* 0x800BEA40 */
 void TBoxFlagManager::setFlag(u16 flag) {
     if (checkUncommittedFlag2(flag) != 1) {
         mFlagHelper.setFlag(flag / 16, flag % 16, mFlagSpace.getFlagPtrChecked(), mFlagSpace.mCount);
@@ -99,6 +108,8 @@ void TBoxFlagManager::setFlag(u16 flag) {
     }
 }
 
+// NOTE: Not actually Enemy Defeat.
+// This is a little more than that, it keeps track of live objects based on their id as a whole
 class EnemyDefeatManager : public CommittableFlagManager {
 public:
     FlagSpace mFlagSpace;
@@ -129,12 +140,14 @@ public:
 EnemyDefeatManager *EnemyDefeatManager::sInstance = nullptr;
 u16 EnemyDefeatManager::sEnemyDefeatFlags[4096] = {};
 
+/* 0x800BEAC0 */
 void EnemyDefeatManager::clearSavedFlags() {
     u16 empty[0x1000];
     memset(empty, 0, 0x2000);
     FileManager::getInstance()->setEnemyDefeatFlags(empty, 0, 0x1000);
 }
 
+/* 0x800BEB00 */
 bool EnemyDefeatManager::checkUncommittedFlag(u16 flag) {
     if (checkIsValidFlag(flag)) {
         return mFlagHelper.checkFlag(flag / 16, flag % 16, mFlagSpace.getFlagPtrUnchecked(), mFlagSpace.mCount);
@@ -143,14 +156,17 @@ bool EnemyDefeatManager::checkUncommittedFlag(u16 flag) {
     }
 }
 
+/* 0x800BEB80 */
 EnemyDefeatManager::EnemyDefeatManager()
     : CommittableFlagManager(false), mFlagSpace(sEnemyDefeatFlags, ARRAY_LENGTH(sEnemyDefeatFlags)) {}
 
+/* 0x800BEBC0 */
 void EnemyDefeatManager::init() {
     mSceneIndex = 0;
     clearAll();
 }
 
+/* 0x800BEBD0 */
 void EnemyDefeatManager::copyFromSave(u16 sceneIndex) {
     mSceneIndex = sceneIndex;
     u16 count = mFlagSpace.mCount;
@@ -158,6 +174,7 @@ void EnemyDefeatManager::copyFromSave(u16 sceneIndex) {
     mFlagSpace.copyFromSaveFile(flags, 0, count);
 }
 
+/* 0x800BEC30 */
 void EnemyDefeatManager::updateFlagIndex(u16 sceneIndex) {
     if (mSceneIndex == sceneIndex) {
         return;
@@ -166,15 +183,18 @@ void EnemyDefeatManager::updateFlagIndex(u16 sceneIndex) {
     clearAll();
 }
 
+/* 0x800BEC50 */
 void EnemyDefeatManager::clearAll() {
     clearSavedFlags();
     mFlagSpace.unsetAll();
 }
 
+/* 0x800BEC90 */
 bool EnemyDefeatManager::checkIsValidFlag(u16 flag) {
     return flag < 0xFFFF;
 }
 
+/* 0x800BECB0 */
 bool EnemyDefeatManager::checkFlag(u16 flag) {
     if (!checkIsValidFlag(flag)) {
         return false;
@@ -184,10 +204,12 @@ bool EnemyDefeatManager::checkFlag(u16 flag) {
     }
 }
 
+/* 0x800BED50 */
 u16 EnemyDefeatManager::getFlagCount() const {
     return 0x1000;
 }
 
+/* 0x800BED60 */
 void EnemyDefeatManager::setFlag(u16 flag) {
     if (checkUncommittedFlag2(flag) != 1 && checkIsValidFlag(flag)) {
         mFlagHelper.setFlag(flag / 16, flag % 16, mFlagSpace.getFlagPtrChecked(), mFlagSpace.mCount);

From d292aecd6e73c221cc6c5d1a2dced05936e69e78 Mon Sep 17 00:00:00 2001
From: robojumper <robojumper@gmail.com>
Date: Mon, 29 Apr 2024 21:18:30 +0200
Subject: [PATCH 11/16] eggColorFader code match

---
 config/SOUE01/splits.txt         |   2 +-
 config/SOUE01/symbols.txt        |  10 +--
 include/egg/core/eggColorFader.h |   8 +-
 include/egg/core/eggFader.h      |   2 +-
 src/egg/core/eggColorFader.cpp   | 144 +++++++++++++++++++++++++++++++
 5 files changed, 156 insertions(+), 10 deletions(-)
 create mode 100644 src/egg/core/eggColorFader.cpp

diff --git a/config/SOUE01/splits.txt b/config/SOUE01/splits.txt
index 232dd3e7..20a560f2 100644
--- a/config/SOUE01/splits.txt
+++ b/config/SOUE01/splits.txt
@@ -247,7 +247,7 @@ egg/core/eggDisplay.cpp:
 	.sdata2     start:0x8057F2F8 end:0x8057F308
 
 egg/core/eggColorFader.cpp:
-	.text       start:0x80497930 end:0x80497E3C
+	.text       start:0x80497930 end:0x80497E40
 	.data       start:0x8056EAE8 end:0x8056EB20
 	.sdata2     start:0x8057F308 end:0x8057F310
 
diff --git a/config/SOUE01/symbols.txt b/config/SOUE01/symbols.txt
index 1254741b..778887e0 100644
--- a/config/SOUE01/symbols.txt
+++ b/config/SOUE01/symbols.txt
@@ -2935,7 +2935,7 @@ fn_80067D40 = .text:0x80067D40; // type:function size:0x70
 fn_80067DB0 = .text:0x80067DB0; // type:function size:0x14
 fn_80067DD0 = .text:0x80067DD0; // type:function size:0x8
 fn_80067DE0 = .text:0x80067DE0; // type:function size:0xD4
-fn_80067EC0 = .text:0x80067EC0; // type:function size:0x8
+getStatus__Q23EGG10ColorFaderCFv = .text:0x80067EC0; // type:function size:0x8
 fn_80067ED0 = .text:0x80067ED0; // type:function size:0x24
 fn_80067F00 = .text:0x80067F00; // type:function size:0x50
 fn_80067F50 = .text:0x80067F50; // type:function size:0x4
@@ -7642,7 +7642,7 @@ fn_80131A90 = .text:0x80131A90; // type:function size:0x4
 fn_80131AA0 = .text:0x80131AA0; // type:function size:0x4
 fn_80131AB0 = .text:0x80131AB0; // type:function size:0x98
 fn_80131B50 = .text:0x80131B50; // type:function size:0x18
-fn_80131B70 = .text:0x80131B70; // type:function size:0x40
+__dt__Q23EGG10ColorFaderFv = .text:0x80131B70; // type:function size:0x40
 fn_80131BB0 = .text:0x80131BB0; // type:function size:0x58
 fn_80131C10 = .text:0x80131C10; // type:function size:0x10
 fn_80131C20 = .text:0x80131C20; // type:function size:0x10
@@ -22324,7 +22324,7 @@ GXLoadLightObjImm = .text:0x803BE790; // type:function size:0x80
 GXSetChanAmbColor = .text:0x803BE810; // type:function size:0xD8
 GXSetChanMatColor = .text:0x803BE8F0; // type:function size:0xD8
 GXSetNumChans = .text:0x803BE9D0; // type:function size:0x24
-GXSetChanCtr1 = .text:0x803BEA00; // type:function size:0xA4
+GXSetChanCtrl = .text:0x803BEA00; // type:function size:0xA4
 GXGetTexBufferSize = .text:0x803BEAB0; // type:function size:0x124
 __GetImageTileCount = .text:0x803BEBE0; // type:function size:0xC0
 GXInitTexObj = .text:0x803BECA0; // type:function size:0x20C
@@ -27393,7 +27393,7 @@ fn_804C6950 = .text:0x804C6950; // type:function size:0x80
 __ptmf_test = .text:0x804C69D0; // type:function size:0x30
 fn_804C6A00 = .text:0x804C6A00; // type:function size:0x3C
 __ptmf_scall = .text:0x804C6A3C; // type:function size:0x28
-fn_804C6A64 = .text:0x804C6A64; // type:function size:0x5C
+__cvt_fp2unsigned = .text:0x804C6A64; // type:function size:0x5C
 fn_804C6AC0 = .text:0x804C6AC0; // type:function size:0x4C
 _savefpr_14 = .text:0x804C6AC0; // type:label scope:global
 _savefpr_15 = .text:0x804C6AC4; // type:label scope:global
@@ -37102,7 +37102,7 @@ lbl_8056EA30 = .data:0x8056EA30; // type:object size:0x10
 lbl_8056EA40 = .data:0x8056EA40; // type:object size:0x18
 lbl_8056EA58 = .data:0x8056EA58; // type:object size:0x70
 __vt__Q23EGG7Display = .data:0x8056EAC8; // type:object size:0x20
-lbl_8056EAE8 = .data:0x8056EAE8; // type:object size:0x38
+__vt__Q23EGG10ColorFader = .data:0x8056EAE8; // type:object size:0x38
 lbl_8056EB20 = .data:0x8056EB20; // type:object size:0x40
 lbl_8056EB60 = .data:0x8056EB60; // type:object size:0x20
 lbl_8056EB80 = .data:0x8056EB80; // type:object size:0x10
diff --git a/include/egg/core/eggColorFader.h b/include/egg/core/eggColorFader.h
index ab2b1b6a..5acc1672 100644
--- a/include/egg/core/eggColorFader.h
+++ b/include/egg/core/eggColorFader.h
@@ -12,12 +12,12 @@ class ColorFader : public Fader {
 public:
     // vtable at 0x00 | 8056eae8
     /* vt 0x08 | 80497a10 */ virtual void setStatus(EStatus);
-    /* vt 0x0C | 00000000 */ virtual EStatus getStatus() const;
+    /* vt 0x0C | 80067ec0 */ virtual EStatus getStatus() const { return mStatus; };
     /* vt 0x10 | 80497a50 */ virtual bool fadeIn();
     /* vt 0x14 | 80497a80 */ virtual bool fadeOut();
     /* vt 0x18 | 80497ab0 */ virtual bool calc();
-    /* vt 0x1C | 80497ba0 */ virtual bool draw();
-    /* vt 0x1C | 80131b70 */ virtual ~ColorFader();
+    /* vt 0x1C | 80497ba0 */ virtual void draw();
+    /* vt 0x1C | 80131b70 */ virtual ~ColorFader() {}
 
 public:
     /* 0x04 */ EStatus mStatus;
@@ -35,6 +35,8 @@ public:
     /* 80497930 */ ColorFader(f32 startX, f32 startY, f32 lengthX, f32 lengthY, nw4r::ut::Color color, EStatus status);
     /* 804979e0 */ void setFrame(u16 frame);
     /* 804979f0 */ void setColor(nw4r::ut::Color);
+    float getWidth() const { return mEndX - mStartX; }
+    float getHeight() const { return mEndY - mStartY; }
 };
 
 } // namespace EGG
diff --git a/include/egg/core/eggFader.h b/include/egg/core/eggFader.h
index 88249afb..e0183dad 100644
--- a/include/egg/core/eggFader.h
+++ b/include/egg/core/eggFader.h
@@ -21,7 +21,7 @@ public:
     /* vt 0x10 | 00000000 */ virtual bool fadeIn() = 0;
     /* vt 0x14 | 00000000 */ virtual bool fadeOut() = 0;
     /* vt 0x18 | 00000000 */ virtual bool calc() = 0;
-    /* vt 0x1C | 00000000 */ virtual bool draw() = 0;
+    /* vt 0x1C | 00000000 */ virtual void draw() = 0;
 };
 
 } // namespace EGG
diff --git a/src/egg/core/eggColorFader.cpp b/src/egg/core/eggColorFader.cpp
new file mode 100644
index 00000000..1ccda0bb
--- /dev/null
+++ b/src/egg/core/eggColorFader.cpp
@@ -0,0 +1,144 @@
+#include <egg/core/eggColorFader.h>
+#include <rvl/GX/GXTexture.h>
+#include <rvl/GX/GXHardware.h>
+
+// This file basically matches, but it pulls in some weak symbols that
+// we still need to identify later.
+
+/** 80497930 */
+EGG::ColorFader::ColorFader(float startX, float startY, float lengthX, float lengthY, nw4r::ut::Color color, Fader::EStatus initialStatus)
+    : mStartX(startX), mStartY(startY), mEndX(startX+lengthX), mEndY(startY+lengthY), mFrame(0x14), mFadeTimer(0) {
+    setColor(color);
+    setStatus(initialStatus);
+    mFlags.setBit(1);
+}
+
+void EGG::ColorFader::setFrame(u16 frames) {
+    mFrame = frames;
+}
+
+void EGG::ColorFader::setColor(nw4r::ut::Color color) {
+    mColor.r = color.r;
+    mColor.g = color.g;
+    mColor.b = color.b;
+    // Don't set alpha
+}
+
+void EGG::ColorFader::setStatus(Fader::EStatus status) {
+    if (status == STATUS_PREPARE_IN) {
+        mStatus = STATUS_PREPARE_IN;
+        mColor.a = 255;
+    } else if (status == STATUS_PREPARE_OUT) {
+        mStatus = STATUS_PREPARE_OUT;
+        mColor.a = 0;
+    }
+}
+
+bool EGG::ColorFader::fadeIn() {
+    bool doFadeIn = mStatus == STATUS_PREPARE_IN;
+    if (doFadeIn) {
+        mStatus = STATUS_FADE_IN;
+        mFadeTimer = 0;
+    }
+
+    return doFadeIn;
+}
+
+bool EGG::ColorFader::fadeOut() {
+    bool doFadeOut = mStatus == STATUS_PREPARE_OUT;
+    if (doFadeOut) {
+        mStatus = STATUS_FADE_OUT;
+        mFadeTimer = 0;
+    }
+
+    return doFadeOut;
+}
+
+bool EGG::ColorFader::calc() {
+    bool result = false;
+
+    if (mStatus == STATUS_PREPARE_OUT) {
+        mColor.a = 0;
+    } else if (mStatus == STATUS_PREPARE_IN) {
+        mColor.a = 255;
+    } else if (mStatus == STATUS_FADE_IN) {
+        u16 endFrame = mFrame;
+        u16 currFrame = mFadeTimer++;
+        if (currFrame > endFrame) {
+            mStatus = STATUS_PREPARE_OUT;
+            result = mFlags.onBit(0);
+            currFrame = mFrame;
+        }
+        mColor.a = 255 - (currFrame * 255 / mFrame);
+    } else if (mStatus == STATUS_FADE_OUT) {
+        u16 endFrame = mFrame;
+        u16 currFrame = mFadeTimer++;
+        if (currFrame > endFrame) {
+            if (currFrame > endFrame + 1) {
+                mStatus = STATUS_PREPARE_IN;
+                result = mFlags.onBit(1);
+            }
+            endFrame = mFrame;
+            currFrame = endFrame;
+        }
+        mColor.a = currFrame * 255 / endFrame;
+    }
+
+    return result;
+}
+
+void EGG::ColorFader::draw() {
+    if (mColor.a == 0) {
+        return;
+    }
+
+    Mtx44 projMtx;
+    C_MTXOrtho(projMtx, mStartY, mEndY, mStartX, mEndX, 0.0f, 1.0f);
+    GXSetProjection(projMtx, GX_ORTHOGRAPHIC);
+
+    GXSetViewport(mStartX, mStartY, getWidth(), getHeight(), 0.0f, 1.0f);
+    GXSetScissor(mStartX, mStartY, getWidth(), getHeight());
+
+    Mtx posMtx;
+    PSMTXIdentity(posMtx);
+    GXLoadPosMtxImm(posMtx, 0);
+    GXSetCurrentMtx(0);
+
+    GXClearVtxDesc();
+    GXInvalidateVtxCache();
+
+    GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
+    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_F32, 0);
+
+    GXSetNumChans(1);
+    GXSetChanMatColor(GX_COLOR0A0, mColor);
+    GXSetChanCtrl(GX_COLOR0A0, 0, GX_SRC_REG, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE);
+
+    GXSetNumTexGens(0);
+    GXSetNumIndStages(0);
+    __GXSetIndirectMask(0);
+
+    GXSetNumTevStages(1);
+    GXSetTevOp(GX_TEVSTAGE0, 4);
+    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
+
+    if (mColor.a == 255) {
+        GXSetBlendMode(GX_BM_NONE, GX_BL_ONE, GX_BL_ZERO, GX_LO_SET);
+    } else {
+        GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
+    }
+
+    GXSetColorUpdate(1);
+    GXSetAlphaUpdate(1);
+    GXSetZMode(0, GX_NEVER, 0);
+    GXSetCullMode(GX_CULL_BACK);
+
+    GXBegin(GX_QUADS, GX_VTXFMT0, 4);
+
+    GXPosition3f32(mStartX, mStartY, 0.0f);
+    GXPosition3f32(mEndX, mStartY, 0.0f);
+    GXPosition3f32(mEndX, mEndY, 0.0f);
+    GXPosition3f32(mStartX, mEndY, 0.0f);
+
+    // GXEnd();
+}

From 152238c9ce735e2683e2a0aaa51188eb6ee857bd Mon Sep 17 00:00:00 2001
From: robojumper <robojumper@gmail.com>
Date: Tue, 30 Apr 2024 22:06:21 +0200
Subject: [PATCH 12/16] m_heap matching

---
 config/SOUE01/splits.txt  |  2 +-
 config/SOUE01/symbols.txt |  6 +++---
 configure.py              |  2 +-
 include/m/m_heap.h        |  4 ++--
 src/m/m_heap.cpp          | 40 ++++++++++++++++++++++-----------------
 5 files changed, 30 insertions(+), 24 deletions(-)

diff --git a/config/SOUE01/splits.txt b/config/SOUE01/splits.txt
index 232dd3e7..e4658c04 100644
--- a/config/SOUE01/splits.txt
+++ b/config/SOUE01/splits.txt
@@ -157,7 +157,7 @@ m/m_heap.cpp:
 	.rodata     start:0x804F0570 end:0x804F0580
 	.data       start:0x80542990 end:0x80542AA8
 	.sdata      start:0x80573FF8 end:0x80574000
-	.sbss       start:0x80575C38 end:0x80575C50
+	.sbss       start:0x80575C38 end:0x80575C4C
 	.bss        start:0x805CB078 end:0x805CB088
 
 m/m_mtx.cpp:
diff --git a/config/SOUE01/symbols.txt b/config/SOUE01/symbols.txt
index 1254741b..ef76ae55 100644
--- a/config/SOUE01/symbols.txt
+++ b/config/SOUE01/symbols.txt
@@ -17817,11 +17817,11 @@ copyAttribute__5mHeapFUi = .text:0x802F0F00; // type:function size:0x34
 setCurrentHeap__5mHeapFPQ23EGG4Heap = .text:0x802F0F40; // type:function size:0x4
 createExpHeap__5mHeapFUlPQ23EGG4HeapPCcUlUl = .text:0x802F0F50; // type:function size:0x10C
 adjustExpHeap__5mHeapFPQ23EGG7ExpHeap = .text:0x802F1060; // type:function size:0x68
-expHeapCost__5mHeapFUlUl = .text:0x802F10D0; // type:function size:0x18
+expHeapCost__5mHeapFUli = .text:0x802F10D0; // type:function size:0x18
 createFrmHeap__5mHeapFUlPQ23EGG4HeapPCcUlUl = .text:0x802F10F0; // type:function size:0x10C
 destroyFrmHeap__5mHeapFPQ23EGG7FrmHeap = .text:0x802F1200; // type:function size:0x1C
 adjustFrmHeap__5mHeapFPQ23EGG7FrmHeap = .text:0x802F1220; // type:function size:0x68
-frmHeapCost__5mHeapFUlUl = .text:0x802F1290; // type:function size:0x18
+frmHeapCost__5mHeapFUli = .text:0x802F1290; // type:function size:0x18
 setTempHeap__5mHeapFPPQ23EGG4HeapPQ23EGG4Heap = .text:0x802F12B0; // type:function size:0x38
 restoreTempHeap__5mHeapFPPQ23EGG4Heapi = .text:0x802F12F0; // type:function size:0x58
 createHeap__5mHeapFUlPQ23EGG4HeapPCc = .text:0x802F1350; // type:function size:0x74
@@ -40263,7 +40263,7 @@ s_SavedCurrentHeap__5mHeap = .sbss:0x80575C38; // type:object size:0x4 data:4byt
 g_archiveHeap__5mHeap = .sbss:0x80575C3C; // type:object size:0x4 data:4byte
 g_commandHeap__5mHeap = .sbss:0x80575C40; // type:object size:0x4 data:4byte
 g_dylinkHeap__5mHeap = .sbss:0x80575C44; // type:object size:0x4 data:4byte
-g_assertHeap__5mHeap = .sbss:0x80575C48; // type:object size:0x8 data:4byte
+g_assertHeap__5mHeap = .sbss:0x80575C48; // type:object size:0x4 data:4byte
 lbl_80575C50 = .sbss:0x80575C50; // type:object size:0x4 data:4byte
 lbl_80575C54 = .sbss:0x80575C54; // type:object size:0x4 data:4byte
 lbl_80575C58 = .sbss:0x80575C58; // type:object size:0x4 data:4byte
diff --git a/configure.py b/configure.py
index 7082ca12..7be624d0 100644
--- a/configure.py
+++ b/configure.py
@@ -289,7 +289,7 @@ config.libs = [
             Object(NonMatching, "f/f_base.cpp"),
             Object(NonMatching, "f/f_list.cpp"),
             Object(NonMatching, "f/f_manager.cpp"),
-            Object(NonMatching, "m/m_heap.cpp"),
+            Object(Matching, "m/m_heap.cpp"),
             Object(NonMatching, "m/m_mtx.cpp"),
             # framework (f_name)
             # d stuff (d_name)
diff --git a/include/m/m_heap.h b/include/m/m_heap.h
index 4ee94d11..6fdd1de7 100644
--- a/include/m/m_heap.h
+++ b/include/m/m_heap.h
@@ -19,11 +19,11 @@ namespace mHeap {
 /* 802f0f40 */ EGG::Heap *setCurrentHeap(EGG::Heap *);
 /* 802f0f50 */ EGG::ExpHeap *createExpHeap(size_t size, EGG::Heap *parentHeap, char *name, s32 align, u32 unk);
 /* 802f1060 */ size_t adjustExpHeap(EGG::Heap *heap);
-/* 802f10d0 */ size_t expHeapCost(size_t start, size_t size);
+/* 802f10d0 */ size_t expHeapCost(size_t start, s32 size);
 /* 802f10f0 */ EGG::FrmHeap *createFrmHeap(size_t size, EGG::Heap *parentHeap, char *name, size_t align, size_t attrs);
 /* 802f1200 */ void destroyFrmHeap(EGG::FrmHeap *heap);
 /* 802f1220 */ size_t adjustFrmHeap(EGG::FrmHeap *heap);
-/* 802f1290 */ size_t frmHeapCost(size_t start, size_t size);
+/* 802f1290 */ size_t frmHeapCost(size_t start, s32 size);
 /* 802f12b0 */ EGG::Heap **setTempHeap(EGG::Heap **prevHeap, EGG::Heap *tempNewHeap);
 /* 802f12f0 */ EGG::Heap **restoreTempHeap(EGG::Heap **prevHeap, s32 size);
 /* 802f1350 */ EGG::ExpHeap *createHeap(size_t size, EGG::Heap *, char *name);
diff --git a/src/m/m_heap.cpp b/src/m/m_heap.cpp
index 4e932d30..782cdec2 100644
--- a/src/m/m_heap.cpp
+++ b/src/m/m_heap.cpp
@@ -5,7 +5,8 @@
 
 namespace mHeap {
 
-u8 g_DefaultGameHeapId = 1;
+// Workaround because dtk won't cooperate with this file
+u8 g_DefaultGameHeapId[8] = {1};
 
 #define MIN_ALIGN 0x20
 
@@ -74,10 +75,11 @@ size_t adjustExpHeap(EGG::ExpHeap *heap) {
     }
     return ret;
 }
-size_t expHeapCost(size_t size, size_t align) {
-    // TODO this generates an andc where it should be a nor + and
-    size_t r5 = align - 1;
-    return size + (~r5 & (r5 + 0x84));
+size_t expHeapCost(size_t size, s32 align) {
+    int a = align - 1;
+    long b = (0x84 + a);
+    
+    return size + (~(a) & b);
 }
 
 EGG::FrmHeap *createFrmHeap(size_t size, EGG::Heap *parent, const char *name, size_t align, size_t attrs) {
@@ -125,9 +127,11 @@ size_t adjustFrmHeap(EGG::FrmHeap *heap) {
     return ret;
 }
 
-size_t frmHeapCost(size_t size, size_t align) {
-    size_t r5 = align - 1;
-    return size + (~r5 & (r5 + 0x7d));
+size_t frmHeapCost(size_t size, s32 align) {
+    int a = align - 1;
+    long b = (0x7C + a);
+    
+    return size + (~(a) & b);
 }
 
 EGG::Heap **setTempHeap(EGG::Heap **prevHeap, EGG::Heap *tempNewHeap) {
@@ -175,26 +179,27 @@ EGG::FrmHeap *makeFrmHeapAndUpdate(size_t size, EGG::Heap *parentHeap, const cha
 }
 
 int getDefaultGameHeapId() {
-    return g_DefaultGameHeapId;
+    return g_DefaultGameHeapId[0];
 }
 
 inline bool isValidHeapId(u32 id) {
     return id >= 1 && id <= 2;
 }
 
+const char *const s_GameHeapNames[4] = {
+        0,
+        "ゲーム用汎用ヒープ1(mHeap::gameHeaps[1])",
+        "ゲーム用汎用ヒープ2(mHeap::gameHeaps[2])",
+        0,
+};
+
 EGG::ExpHeap *createGameHeap(int heapId, size_t size, EGG::Heap *parent) {
-    const char *s_GameHeapNames[4] = {
-            0,
-            "ゲーム用汎用ヒープ1(mHeap::gameHeaps[1])",
-            "ゲーム用汎用ヒープ2(mHeap::gameHeaps[2])",
-            0,
-    };
     if (!isValidHeapId(heapId)) {
         return nullptr;
     }
 
     g_gameHeaps[heapId] = createHeap(size, parent, s_GameHeapNames[heapId]);
-    if (heapId == g_DefaultGameHeapId) {
+    if (heapId == g_DefaultGameHeapId[0]) {
         g_gameHeaps[0] = g_gameHeaps[heapId];
     }
     return g_gameHeaps[heapId];
@@ -215,7 +220,8 @@ EGG::ExpHeap *createDylinkHeap(size_t size, EGG::Heap *parent) {
     return g_dylinkHeap;
 }
 EGG::AssertHeap *createAssertHeap(EGG::Heap *parent) {
-    const char *name = "アサートヒープ(mHeap::assertHeap)";
+    // Help how do I tell dtk about string length?
+    const char *name = "アサートヒープ(mHeap::assertHeap)\0\0\0\0\0\0";
     g_assertHeap = EGG::AssertHeap::create(EGG::AssertHeap::getSize(), parent);
     g_assertHeap->mName = name;
     return g_assertHeap;

From 47baaaf8ee22bcb5011031de73d5eee1e1222476 Mon Sep 17 00:00:00 2001
From: robojumper <robojumper@gmail.com>
Date: Wed, 1 May 2024 15:53:07 +0200
Subject: [PATCH 13/16] Revert workarounds for now

---
 src/m/m_heap.cpp | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/m/m_heap.cpp b/src/m/m_heap.cpp
index 782cdec2..2e9fd44c 100644
--- a/src/m/m_heap.cpp
+++ b/src/m/m_heap.cpp
@@ -5,8 +5,7 @@
 
 namespace mHeap {
 
-// Workaround because dtk won't cooperate with this file
-u8 g_DefaultGameHeapId[8] = {1};
+u8 g_DefaultGameHeapId = 1;
 
 #define MIN_ALIGN 0x20
 
@@ -179,7 +178,7 @@ EGG::FrmHeap *makeFrmHeapAndUpdate(size_t size, EGG::Heap *parentHeap, const cha
 }
 
 int getDefaultGameHeapId() {
-    return g_DefaultGameHeapId[0];
+    return g_DefaultGameHeapId;
 }
 
 inline bool isValidHeapId(u32 id) {
@@ -199,7 +198,7 @@ EGG::ExpHeap *createGameHeap(int heapId, size_t size, EGG::Heap *parent) {
     }
 
     g_gameHeaps[heapId] = createHeap(size, parent, s_GameHeapNames[heapId]);
-    if (heapId == g_DefaultGameHeapId[0]) {
+    if (heapId == g_DefaultGameHeapId) {
         g_gameHeaps[0] = g_gameHeaps[heapId];
     }
     return g_gameHeaps[heapId];
@@ -220,8 +219,7 @@ EGG::ExpHeap *createDylinkHeap(size_t size, EGG::Heap *parent) {
     return g_dylinkHeap;
 }
 EGG::AssertHeap *createAssertHeap(EGG::Heap *parent) {
-    // Help how do I tell dtk about string length?
-    const char *name = "アサートヒープ(mHeap::assertHeap)\0\0\0\0\0\0";
+    const char *name = "アサートヒープ(mHeap::assertHeap)";
     g_assertHeap = EGG::AssertHeap::create(EGG::AssertHeap::getSize(), parent);
     g_assertHeap->mName = name;
     return g_assertHeap;

From 8d0f567848bf41eb94c33dd08a4e944bd53a840b Mon Sep 17 00:00:00 2001
From: robojumper <robojumper@gmail.com>
Date: Thu, 2 May 2024 14:54:39 +0200
Subject: [PATCH 14/16] Fix ninja diff

---
 config/SOUE01/symbols.txt | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/config/SOUE01/symbols.txt b/config/SOUE01/symbols.txt
index ef76ae55..b9a89ba6 100644
--- a/config/SOUE01/symbols.txt
+++ b/config/SOUE01/symbols.txt
@@ -30058,7 +30058,7 @@ lbl_80502E70 = .data:0x80502E70; // type:object size:0x3D8
 lbl_80503248 = .data:0x80503248; // type:object size:0x30
 lbl_80503278 = .data:0x80503278; // type:object size:0x9C
 lbl_80503314 = .data:0x80503314; // type:object size:0x6C
-__vt__7dBase_c = .data:0x80503380; // type:object size:0x50
+__vt__7dBase_c = .data:0x80503380; // type:object size:0x4C
 lbl_805033D0 = .data:0x805033D0; // type:object size:0x10
 lbl_805033E0 = .data:0x805033E0; // type:object size:0x10
 lbl_805033F0 = .data:0x805033F0; // type:object size:0x10
@@ -35726,12 +35726,12 @@ lbl_80542928 = .data:0x80542928; // type:object size:0x14
 lbl_8054293C = .data:0x8054293C; // type:object size:0x14
 lbl_80542950 = .data:0x80542950; // type:object size:0x18
 lbl_80542968 = .data:0x80542968; // type:object size:0x28
-lbl_80542990 = .data:0x80542990; // type:object size:0x2C
-lbl_805429BC = .data:0x805429BC; // type:object size:0x2C
-lbl_805429E8 = .data:0x805429E8; // type:object size:0x38
+lbl_80542990 = .data:0x80542990; // type:object size:0x29
+lbl_805429BC = .data:0x805429BC; // type:object size:0x29
+lbl_805429E8 = .data:0x805429E8; // type:object size:0x31
 lbl_80542A20 = .data:0x80542A20; // type:object size:0x30
-lbl_80542A50 = .data:0x80542A50; // type:object size:0x30
-lbl_80542A80 = .data:0x80542A80; // type:object size:0x28
+lbl_80542A50 = .data:0x80542A50; // type:object size:0x2E
+lbl_80542A80 = .data:0x80542A80; // type:object size:0x22
 lbl_80542AA8 = .data:0x80542AA8; // type:object size:0x20
 lbl_80542AC8 = .data:0x80542AC8; // type:object size:0x8
 lbl_80542AD0 = .data:0x80542AD0; // type:object size:0x10
@@ -39021,7 +39021,7 @@ lbl_80573FE4 = .sdata:0x80573FE4; // type:object size:0x4 data:string
 lbl_80573FE8 = .sdata:0x80573FE8; // type:object size:0x4 data:string
 lbl_80573FEC = .sdata:0x80573FEC; // type:object size:0x8
 lbl_80573FF4 = .sdata:0x80573FF4; // type:object size:0x4 data:string
-g_DefaultGameHeapId__5mHeap = .sdata:0x80573FF8; // type:object size:0x8 data:byte
+g_DefaultGameHeapId__5mHeap = .sdata:0x80573FF8; // type:object size:0x1 data:byte
 lbl_80574000 = .sdata:0x80574000; // type:object size:0x8 data:4byte
 lbl_80574008 = .sdata:0x80574008; // type:object size:0x8
 lbl_80574010 = .sdata:0x80574010; // type:object size:0x8
@@ -47623,7 +47623,7 @@ lbl_8057F3A0 = .sdata2:0x8057F3A0; // type:object size:0x4 data:float
 lbl_8057F3A4 = .sdata2:0x8057F3A4; // type:object size:0x4 data:float
 lbl_8057F3A8 = .sdata2:0x8057F3A8; // type:object size:0x4 data:float
 lbl_8057F3AC = .sdata2:0x8057F3AC; // type:object size:0x4 data:float
-lbl_8057F3B0 = .sdata2:0x8057F3B0; // type:object size:0x8 data:float
+lbl_8057F3B0 = .sdata2:0x8057F3B0; // type:object size:0x4 data:float
 lbl_8057F3B8 = .sdata2:0x8057F3B8; // type:object size:0x4 data:float
 lbl_8057F3BC = .sdata2:0x8057F3BC; // type:object size:0x4 data:float
 lbl_8057F3C0 = .sdata2:0x8057F3C0; // type:object size:0x4 data:float

From 640b5a2085231784f3434aa17afda411ec4dde96 Mon Sep 17 00:00:00 2001
From: elijah-thomas774 <elijahthomas774@gmail.com>
Date: Thu, 2 May 2024 12:36:56 -0400
Subject: [PATCH 15/16] Fix Splits that caused Non Match

---
 config/SOUE01/splits.txt  | 6 +++---
 config/SOUE01/symbols.txt | 2 +-
 configure.py              | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/config/SOUE01/splits.txt b/config/SOUE01/splits.txt
index 20a560f2..34f5e9a9 100644
--- a/config/SOUE01/splits.txt
+++ b/config/SOUE01/splits.txt
@@ -247,13 +247,13 @@ egg/core/eggDisplay.cpp:
 	.sdata2     start:0x8057F2F8 end:0x8057F308
 
 egg/core/eggColorFader.cpp:
-	.text       start:0x80497930 end:0x80497E40
-	.data       start:0x8056EAE8 end:0x8056EB20
+	.text       start:0x80497930 end:0x80497E3C
+	.data       start:0x8056EAE8 end:0x8056EB10
 	.sdata2     start:0x8057F308 end:0x8057F310
 
 egg/core/eggAsyncDisplay.cpp:
 	.text       start:0x80497E40 end:0x80498688
-	.data       start:0x8056EB60 end:0x8056EB80
+	.data       start:0x8056EB10 end:0x8056EB80
 	.sbss       start:0x80576790 end:0x80576798
 	.sdata2     start:0x8057F310 end:0x8057F328
 
diff --git a/config/SOUE01/symbols.txt b/config/SOUE01/symbols.txt
index 778887e0..1a1d2757 100644
--- a/config/SOUE01/symbols.txt
+++ b/config/SOUE01/symbols.txt
@@ -37102,7 +37102,7 @@ lbl_8056EA30 = .data:0x8056EA30; // type:object size:0x10
 lbl_8056EA40 = .data:0x8056EA40; // type:object size:0x18
 lbl_8056EA58 = .data:0x8056EA58; // type:object size:0x70
 __vt__Q23EGG7Display = .data:0x8056EAC8; // type:object size:0x20
-__vt__Q23EGG10ColorFader = .data:0x8056EAE8; // type:object size:0x38
+__vt__Q23EGG10ColorFader = .data:0x8056EAE8; // type:object size:0x24
 lbl_8056EB20 = .data:0x8056EB20; // type:object size:0x40
 lbl_8056EB60 = .data:0x8056EB60; // type:object size:0x20
 lbl_8056EB80 = .data:0x8056EB80; // type:object size:0x10
diff --git a/configure.py b/configure.py
index 7082ca12..ada4be6d 100644
--- a/configure.py
+++ b/configure.py
@@ -337,7 +337,7 @@ config.libs = [
             Object(NonMatching, "egg/core/eggUnk.cpp"),
             Object(NonMatching, "egg/core/eggSystem.cpp"),
             Object(Matching, "egg/core/eggDisplay.cpp"),
-            Object(NonMatching, "egg/core/eggColorFader.cpp"),
+            Object(Matching, "egg/core/eggColorFader.cpp"),
             Object(NonMatching, "egg/core/eggAsyncDisplay.cpp"),
             Object(NonMatching, "egg/core/eggVideo.cpp"),
             Object(NonMatching, "egg/core/eggXfb.cpp"),

From 1b7cdfd5bb8c4fd30f7d1d524d9c86f1e08709ea Mon Sep 17 00:00:00 2001
From: elijah-thomas774 <elijahthomas774@gmail.com>
Date: Thu, 2 May 2024 12:38:35 -0400
Subject: [PATCH 16/16] Remove non match comment

---
 src/egg/core/eggColorFader.cpp | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/egg/core/eggColorFader.cpp b/src/egg/core/eggColorFader.cpp
index 1ccda0bb..f4207cf5 100644
--- a/src/egg/core/eggColorFader.cpp
+++ b/src/egg/core/eggColorFader.cpp
@@ -1,13 +1,12 @@
 #include <egg/core/eggColorFader.h>
-#include <rvl/GX/GXTexture.h>
 #include <rvl/GX/GXHardware.h>
+#include <rvl/GX/GXTexture.h>
 
-// This file basically matches, but it pulls in some weak symbols that
-// we still need to identify later.
 
-/** 80497930 */
-EGG::ColorFader::ColorFader(float startX, float startY, float lengthX, float lengthY, nw4r::ut::Color color, Fader::EStatus initialStatus)
-    : mStartX(startX), mStartY(startY), mEndX(startX+lengthX), mEndY(startY+lengthY), mFrame(0x14), mFadeTimer(0) {
+/* 80497930 */
+EGG::ColorFader::ColorFader(float startX, float startY, float lengthX, float lengthY, nw4r::ut::Color color,
+        Fader::EStatus initialStatus)
+    : mStartX(startX), mStartY(startY), mEndX(startX + lengthX), mEndY(startY + lengthY), mFrame(0x14), mFadeTimer(0) {
     setColor(color);
     setStatus(initialStatus);
     mFlags.setBit(1);