diff --git a/config/SOUE01/splits.txt b/config/SOUE01/splits.txt
index 817dcc7e..73f7cbd5 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
@@ -119,9 +122,17 @@ 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:0x8057540C
+	.bss        start:0x805A9C68 end:0x805A9C88
+
 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
@@ -146,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:
@@ -237,12 +248,12 @@ egg/core/eggDisplay.cpp:
 
 egg/core/eggColorFader.cpp:
 	.text       start:0x80497930 end:0x80497E3C
-	.data       start:0x8056EAE8 end:0x8056EB20
+	.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:0x8057F324
 
diff --git a/config/SOUE01/symbols.txt b/config/SOUE01/symbols.txt
index 5c047dc9..fcbbdeb5 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
@@ -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
@@ -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
@@ -4180,17 +4180,17 @@ 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__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
+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
@@ -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
@@ -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
@@ -17813,17 +17813,17 @@ 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
-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
-fn_802F12B0 = .text:0x802F12B0; // type:function size:0x38
-fn_802F12F0 = .text:0x802F12F0; // type:function size:0x58
+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
 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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:0x24
 lbl_8056EB20 = .data:0x8056EB20; // type:object size:0x40
 __vt__Q23EGG12AsyncDisplay = .data:0x8056EB60; // type:object size:0x20
 lbl_8056EB80 = .data:0x8056EB80; // 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
@@ -39843,13 +39843,13 @@ 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
-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
@@ -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
@@ -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
@@ -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
@@ -48233,11 +48233,11 @@ 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
-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 7eec2a17..87235f4a 100644
--- a/configure.py
+++ b/configure.py
@@ -274,7 +274,9 @@ config.libs = [
             Object(Matching, "toBeSorted/sceneflag_manager.cpp"),
             Object(NonMatching, "toBeSorted/flag_space.cpp"),
             Object(NonMatching, "toBeSorted/misc_flag_managers.cpp"),
+            Object(Matching, "toBeSorted/skipflag_manager.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"),
@@ -287,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)
@@ -335,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(Matching, "egg/core/eggAsyncDisplay.cpp"),
             Object(NonMatching, "egg/core/eggVideo.cpp"),
             Object(NonMatching, "egg/core/eggXfb.cpp"),
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/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/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/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/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/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 38c737e7..6fdd1de7 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"
@@ -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);
-/* 802f10f0 */ EGG::FrmHeap *createFrmHeap(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, 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 */ 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, 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);
 /* 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/c/c_list.cpp b/src/c/c_list.cpp
index 37d1c624..9d39a755 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) {
+/* 0x802E08C0 */
+void cListMg_c::insertAfter(cListNd_c *node, cListNd_c *prevNode) {
     if (prevNode == nullptr) {
         return this->prepend(node);
     }
@@ -18,7 +18,8 @@ bool cListMg_c::insertAfter(cListNd_c *node, cListNd_c *prevNode) {
     }
 }
 
-bool cListMg_c::remove(cListNd_c *node) {
+/* 0x802E0900 */
+void cListMg_c::remove(cListNd_c *node) {
     if (node == nullptr) {
         return;
     }
@@ -46,7 +47,8 @@ bool cListMg_c::remove(cListNd_c *node) {
     }
 }
 
-bool cListMg_c::append(cListNd_c *node) {
+/* 0x802E09B0 */
+void cListMg_c::append(cListNd_c *node) {
     if (node == nullptr) {
         return;
     }
@@ -59,7 +61,8 @@ bool cListMg_c::append(cListNd_c *node) {
     this->mpLast = node;
 }
 
-bool cListMg_c::prepend(cListNd_c *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
new file mode 100644
index 00000000..9ed5eda0
--- /dev/null
+++ b/src/c/c_tree.cpp
@@ -0,0 +1,121 @@
+#include <c/c_tree.h>
+
+/* 0x802E0E70 */
+cTreeNd_c::cTreeNd_c() {
+    this->forcedClear();
+}
+
+/* 0x802E0EA0 */
+void cTreeNd_c::forcedClear() {
+    this->mpParent = 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) {
+            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;
+}
+
+/* 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;
+        } 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;
+}
+
+/* 0x802E1000 */
+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;
+}
+
+/* 0x802E10C0 */
+cTreeNd_c *cTreeNd_c::getTreeNext() const {
+    cTreeNd_c *child = this->mpChild;
+    if (child != nullptr) {
+        return child;
+    } else {
+        return this->getTreeNextNotChild();
+    }
+}
+
+/* 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;
+}
diff --git a/src/egg/core/eggColorFader.cpp b/src/egg/core/eggColorFader.cpp
new file mode 100644
index 00000000..f4207cf5
--- /dev/null
+++ b/src/egg/core/eggColorFader.cpp
@@ -0,0 +1,143 @@
+#include <egg/core/eggColorFader.h>
+#include <rvl/GX/GXHardware.h>
+#include <rvl/GX/GXTexture.h>
+
+
+/* 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();
+}
diff --git a/src/m/m_heap.cpp b/src/m/m_heap.cpp
index 5595136b..2e9fd44c 100644
--- a/src/m/m_heap.cpp
+++ b/src/m/m_heap.cpp
@@ -1,16 +1,13 @@
 #include <egg/core/eggAssertHeap.h>
 #include <egg/core/eggExpHeap.h>
 #include <egg/core/eggFrmHeap.h>
+#include <m/m_heap.h>
 
 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
 
 EGG::ExpHeap *g_gameHeaps[4];
 EGG::ExpHeap *s_SavedCurrentHeap;
@@ -19,23 +16,166 @@ 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::expHeapCost(0, 4);
+        if (ad >= cost) {
+            ret = ad - cost;
+        }
+    }
+    return ret;
+}
+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) {
+    if (parent == nullptr) {
+        parent = EGG::Heap::sCurrentHeap;
+    }
+
+    if (align < MIN_ALIGN) {
+        align = MIN_ALIGN;
+    }
+
+    if (size != 0xFFFFFFFF) {
+        size = frmHeapCost(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, s32 align) {
+    int a = align - 1;
+    long b = (0x7C + a);
+    
+    return size + (~(a) & b);
+}
+
+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();
+    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;
+    }
+    return heap;
+}
 
 int getDefaultGameHeapId() {
     return g_DefaultGameHeapId;
@@ -45,6 +185,13 @@ 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) {
     if (!isValidHeapId(heapId)) {
         return nullptr;
@@ -60,16 +207,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
diff --git a/src/toBeSorted/misc_flag_managers.cpp b/src/toBeSorted/misc_flag_managers.cpp
index 312d105f..a3e8f264 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;
@@ -22,6 +21,7 @@ public:
     }
 };
 
+/* 0x800BE7B0 */
 bool CommittableFlagManager::commitIfNecessary() {
     if (mNeedsCommit) {
         doCommit();
@@ -33,22 +33,21 @@ 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();
     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);
@@ -58,39 +57,50 @@ 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);
 }
 
-TBoxFlagManager::TBoxFlagManager() : CommittableFlagManager(false), mFlagSpace(sFlags, 2) {
+/* 0x800BE8E0 */
+TBoxFlagManager::TBoxFlagManager() : CommittableFlagManager(false), mFlagSpace(sTBoxFlags, ARRAY_LENGTH(sTBoxFlags)) {
     mSceneIndex = 0xFFFF;
 }
 
+/* 0x800BE920 */
 void TBoxFlagManager::init() {}
 
-void TBoxFlagManager::copyFromSave(u16 sceneIndex) {
-    // mr should be a clrlwi
-    mSceneIndex = sceneIndex;
+/* 0x800BE930 */
+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);
 }
 
+/* 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);
@@ -98,13 +108,17 @@ 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;
     BitwiseFlagHelper mFlagHelper;
     u16 mSceneIndex;
 
-    static u16 *sFlags;
+    static u16 sEnemyDefeatFlags[4096];
+
+    static EnemyDefeatManager *sInstance;
 
     void clearSavedFlags();
     bool checkUncommittedFlag(u16 flag);
@@ -123,12 +137,17 @@ public:
     void setFlag(u16 flag);
 };
 
+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);
@@ -137,13 +156,17 @@ bool EnemyDefeatManager::checkUncommittedFlag(u16 flag) {
     }
 }
 
-EnemyDefeatManager::EnemyDefeatManager() : CommittableFlagManager(false), mFlagSpace(sFlags, 12 /* later */) {}
+/* 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;
@@ -151,6 +174,7 @@ void EnemyDefeatManager::copyFromSave(u16 sceneIndex) {
     mFlagSpace.copyFromSaveFile(flags, 0, count);
 }
 
+/* 0x800BEC30 */
 void EnemyDefeatManager::updateFlagIndex(u16 sceneIndex) {
     if (mSceneIndex == sceneIndex) {
         return;
@@ -159,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;
@@ -177,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);
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);
diff --git a/src/toBeSorted/skipflag_manager.cpp b/src/toBeSorted/skipflag_manager.cpp
new file mode 100644
index 00000000..23cfe946
--- /dev/null
+++ b/src/toBeSorted/skipflag_manager.cpp
@@ -0,0 +1,82 @@
+#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(u16 flag);
+    SkipflagManager();
+    void unsetCommitFlag();
+    void thunk_copyFromSave();
+    void setFlag(u16 flag);
+    bool checkFlag(u16 flag);
+    bool commitFlags();
+};
+
+// 0x80575408
+SkipflagManager *SkipflagManager::sInstance = nullptr;
+// 0x805A9C68
+u16 SkipflagManager::sSkipFlags[16] = {};
+
+// 800bfba0
+void SkipflagManager::copyFromSave() {
+    u16* savedSkipflags = FileManager::sInstance->getSkipFlags();
+    mFlagSpace.copyFromSaveFile(savedSkipflags, 0, 0x10);
+}
+
+// 800bfbf0
+void SkipflagManager::setCommitFlag(u16 flag) {
+    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[0x10];
+    checkedMemcpy(savedSkipflags, 0x20, FileManager::sInstance->getSkipFlags(), 0x20);
+
+    mFlagHelper.setFlag(flag / 16, flag % 16, savedSkipflags, 0x10);
+    FileManager::sInstance->setSkipFlagsChecked(savedSkipflags, 0, 0x10);
+    setCommitFlag(flag);
+}
+
+// 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 *instance = FileManager::sInstance;
+        instance->setSkipFlagsChecked(mFlagSpace.getFlagPtrUnchecked(), 0, 0x10);
+        mShouldCommit = false;
+        return true;
+    }
+    return false;
+}