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