diff --git a/include/functions.h b/include/functions.h
index eec09c7f77..775e48d689 100644
--- a/include/functions.h
+++ b/include/functions.h
@@ -3093,35 +3093,35 @@ void func_80171F4C(s32 param_1);
 // void func_801720C4(void);
 // void func_801720FC(void);
 // void func_80172758(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5, UNK_TYPE1 param_6, UNK_TYPE1 param_7, UNK_TYPE2 param_8, UNK_TYPE2 param_9, UNK_TYPE4 param_10, UNK_TYPE4 param_11, UNK_TYPE4 param_12, UNK_TYPE4 param_13, UNK_TYPE4 param_14);
-void func_801727F0(GameStateHeap* heap, void* memoryBlock, u32 size);
-// void func_80172810(void);
-s32 func_80172830(GameStateHeap* pzParm1);
-// void func_80172850(void);
-// void func_80172870(void);
-// void func_80172890(void);
-// void func_801728B0(void);
-// void func_801728D0(void);
-void func_801728F0(GameStateHeap* heap, s32 iParm2);
-// void func_80172914(void);
-// void func_80172934(void);
-// void func_80172954(void);
-// void func_80172974(void);
-// void func_80172998(void);
-// void func_801729B8(void);
-// void func_801729DC(void);
-void* GameStateHeap_GetStart(GameStateHeap* heap);
-void GameStateHeap_SetStart(GameStateHeap* heap, void* start);
-void* GameStateHeap_GetEnd(GameStateHeap* heap);
-void* GameStateHeap_Alloc(GameStateHeap* heap, s32 iParm2);
-void* GameStateHeap_AllocByte(GameStateHeap* pzParm1);
-void* GameStateHeap_AllocFromEndAlignedTo(GameStateHeap* heap, void* ptr);
-void* GameStateHeap_AllocFromEnd(GameStateHeap* heap, u32 size);
-void* GameStateHeap_AllocFromEndAligned(GameStateHeap* heap, u32 size, u32 allignment);
-s32 GameStateHeap_GetFreeSize(GameStateHeap* iParm1);
-s32 GameStateHeap_GetHasOverflowed(GameStateHeap* pzParm1);
-void GameStateHeap_InitAppend(GameStateHeap* heap);
-void GameStateHeap_Init(GameStateHeap* heap, void* memoryBlock, u32 size);
-void GameStateHeap_Clear(GameStateHeap* pvParm1);
+void THGA_Ct(TwoHeadGfxArena* thga, Gfx* start, u32 size);
+void THGA_Dt(TwoHeadGfxArena* thga);
+u32 THGA_IsCrash(TwoHeadGfxArena* thga);
+void THGA_Init(TwoHeadGfxArena* thga);
+s32 THGA_GetSize(TwoHeadGfxArena* thga);
+Gfx* THGA_GetHead(TwoHeadGfxArena* thga);
+void THGA_SetHead(TwoHeadGfxArena* thga, Gfx* start);
+Gfx* THGA_GetTail(TwoHeadGfxArena* thga);
+Gfx* THGA_AllocStartArray8(TwoHeadGfxArena* thga, u32 count);
+Gfx* THGA_AllocStart8(TwoHeadGfxArena* thga);
+Gfx* THGA_AllocStart8Wrapper(TwoHeadGfxArena* thga);
+Gfx* THGA_AllocEnd(TwoHeadGfxArena* thga, u32 size);
+Gfx* THGA_AllocEndArray64(TwoHeadGfxArena* thga, u32 count);
+Gfx* THGA_AllocEnd64(TwoHeadGfxArena* thga);
+Gfx* THGA_AllocEndArray16(TwoHeadGfxArena* thga, u32 count);
+Gfx* THGA_AllocEnd16(TwoHeadGfxArena* thga);
+void* THA_GetHead(TwoHeadArena* tha);
+void THA_SetHead(TwoHeadArena* tha, void* start);
+void* THA_GetTail(TwoHeadArena* tha);
+void* THA_AllocStart(TwoHeadArena* tha, u32 size);
+void* THA_AllocStart1(TwoHeadArena* tha);
+void* THA_AllocEnd(TwoHeadArena* tha, u32 size);
+void* THA_AllocEndAlign16(TwoHeadArena* tha, u32 size);
+void* THA_AllocEndAlign(TwoHeadArena* tha, u32 size, u32 mask);
+s32 THA_GetSize(TwoHeadArena* tha);
+u32 THA_IsCrash(TwoHeadArena* tha);
+void THA_Init(TwoHeadArena* tha);
+void THA_Ct(TwoHeadArena* tha, void* ptr, u32 size);
+void THA_Dt(TwoHeadArena* tha);
 void func_80172BC0(void);
 void func_80172C30(AudioThreadStruct* audio);
 void func_80172C68(AudioThreadStruct* audio);
@@ -3158,7 +3158,7 @@ void Gamealloc_Free(GameAlloc* heap, void* ptr);
 void Gamealloc_FreeAll(GameAlloc* heap);
 void Gamealloc_Init(GameAlloc* iParm1);
 // void Graph_FaultClient(void);
-void Graph_DlAlloc(DispBuf* dl, void* memoryBlock, u32 size);
+void Graph_DlAlloc(TwoHeadGfxArena* dl, void* memoryBlock, u32 size);
 void Graph_InitTHGA(GraphicsContext* gCtxt);
 GameStateOverlay* Graph_GetNextGameState(GameState* ctxt);
 void* Graph_FaultAddrConvFunc(void* addr);
diff --git a/include/z64.h b/include/z64.h
index ccbd0c5248..ec9d602d72 100644
--- a/include/z64.h
+++ b/include/z64.h
@@ -133,13 +133,6 @@ typedef struct {
     /* 0x8 */ u8* textureDlOffsets;
 } CyclingTextureParams; // size = 0xC
 
-typedef struct {
-    /* 0x0 */ u32 size;
-    /* 0x4 */ Gfx* buf;
-    /* 0x8 */ Gfx* p;
-    /* 0xC */ Gfx* d;
-} DispBuf; // size = 0x10
-
 typedef struct {
     /* 0x0 */ s16 x;
     /* 0x2 */ s16 y;
@@ -212,11 +205,18 @@ typedef struct {
 } GameInfo; // size = 0x15D4
 
 typedef struct {
-    /* 0x0 */ UNK_TYPE4 size;
-    /* 0x4 */ void* heapStart;
-    /* 0x8 */ void* heapAppendStart;
-    /* 0xC */ void* heapAppendEnd;
-} GameStateHeap; // size = 0x10
+    /* 0x0000 */ u32    size;
+    /* 0x0004 */ void*  bufp;
+    /* 0x0008 */ void*  head;
+    /* 0x000C */ void*  tail;
+} TwoHeadArena; // size = 0x10
+
+typedef struct {
+    /* 0x0000 */ u32    size;
+    /* 0x0004 */ Gfx*   bufp;
+    /* 0x0008 */ Gfx*   p;
+    /* 0x000C */ Gfx*   d;
+} TwoHeadGfxArena; // size = 0x10
 
 typedef struct {
     /* 0x00000 */ u16 headMagic; // 1234
@@ -245,16 +245,16 @@ typedef struct {
     /* 0x05C */ OSMesgQueue unk5C;
     /* 0x074 */ UNK_TYPE1 pad74[0x12C];
     /* 0x1A0 */ Gfx* unk1A0;
-    /* 0x1A4 */ DispBuf unk1A4;
+    /* 0x1A4 */ TwoHeadGfxArena unk1A4;
     /* 0x1B4 */ Gfx* unk1B4;
-    /* 0x1B8 */ DispBuf unk1B8;
+    /* 0x1B8 */ TwoHeadGfxArena unk1B8;
     /* 0x1C8 */ UNK_TYPE1 pad1C8[0xAC];
     /* 0x274 */ OSViMode* unk274;
     /* 0x278 */ void* zbuffer;
     /* 0x27C */ UNK_TYPE1 pad27C[0x1C];
-    /* 0x298 */ DispBuf overlay;
-    /* 0x2A8 */ DispBuf polyOpa;
-    /* 0x2B8 */ DispBuf polyXlu;
+    /* 0x298 */ TwoHeadGfxArena overlay;
+    /* 0x2A8 */ TwoHeadGfxArena polyOpa;
+    /* 0x2B8 */ TwoHeadGfxArena polyXlu;
     /* 0x2C8 */ s32 displaylistCounter;
     /* 0x2CC */ void* framebuffer;
     /* 0x2D0 */ int pad2D0;
@@ -1151,7 +1151,7 @@ struct GameState {
     /* 0x0C */ GameStateFunc nextGameStateInit;
     /* 0x10 */ u32 nextGameStateSize;
     /* 0x14 */ Input input[4];
-    /* 0x74 */ GameStateHeap heap;
+    /* 0x74 */ TwoHeadArena heap;
     /* 0x84 */ GameAlloc alloc;
     /* 0x98 */ UNK_TYPE1 pad98[0x3];
     /* 0x9B */ u8 running; // If 0, switch to next game state
diff --git a/linker_scripts/code_script.txt b/linker_scripts/code_script.txt
index 71fa3a5229..953ff956c0 100644
--- a/linker_scripts/code_script.txt
+++ b/linker_scripts/code_script.txt
@@ -415,8 +415,8 @@ SECTIONS
         build/asm/code/z_play.o(.text)
         build/asm/code/z_play_hireso.o(.text)
         build/asm/code/PreRender.o(.text)
-        build/asm/code/code_0x801727F0.o(.text)
-        build/asm/code/code_0x80172A00.o(.text)
+        build/src/code/TwoHeadGfxArena.o(.text)
+        build/src/code/TwoHeadArena.o(.text)
         build/asm/code/code_0x80172BC0.o(.text)
         build/asm/code/code_0x80172C30.o(.text)
         build/src/code/title_setup.o(.text)
diff --git a/src/code/TwoHeadArena.c b/src/code/TwoHeadArena.c
new file mode 100644
index 0000000000..8ca24c67e0
--- /dev/null
+++ b/src/code/TwoHeadArena.c
@@ -0,0 +1,80 @@
+#include <ultra64.h>
+#include <global.h>
+
+void* THA_GetHead(TwoHeadArena* tha) {
+    return tha->head;
+}
+
+void THA_SetHead(TwoHeadArena* tha, void* start) {
+    tha->head = start;
+}
+
+void* THA_GetTail(TwoHeadArena* tha) {
+    return tha->tail;
+}
+
+void* THA_AllocStart(TwoHeadArena* tha, u32 size) {
+    void* start = tha->head;
+
+    tha->head = (u32)tha->head + size;
+    return start;
+}
+
+void* THA_AllocStart1(TwoHeadArena* tha) {
+    return THA_AllocStart(tha, 1);
+}
+
+void* THA_AllocEnd(TwoHeadArena* tha, u32 size) {
+    u32 mask;
+
+    if (size >= 0x10) {
+        mask = ~0xF;
+    } else if (size & 1) {
+        mask = -1;
+    } else if (size & 2) {
+        mask = ~0x1;
+    } else if (size & 4) {
+        mask = ~0x3;
+    } else {
+        mask = (size & 8) ? ~0x7 : -1;
+    }
+
+    tha->tail = (((u32)tha->tail & mask) - size) & mask;
+    return tha->tail;
+}
+
+void* THA_AllocEndAlign16(TwoHeadArena* tha, u32 size) {
+    u32 mask = ~0xF;
+
+    tha->tail = (((u32)tha->tail & mask) - size) & mask;
+    return tha->tail;
+}
+
+void* THA_AllocEndAlign(TwoHeadArena* tha, u32 size, u32 mask) {
+    tha->tail = (((u32)tha->tail & mask) - size) & mask;
+    return tha->tail;
+}
+
+s32 THA_GetSize(TwoHeadArena* tha) {
+    return (u32)tha->tail - (u32)tha->head;
+}
+
+u32 THA_IsCrash(TwoHeadArena* tha) {
+    return THA_GetSize(tha) < 0;
+}
+
+void THA_Init(TwoHeadArena* tha) {
+    tha->head = tha->bufp;
+    tha->tail = (u32)tha->bufp + tha->size;
+}
+
+void THA_Ct(TwoHeadArena* tha, void* ptr, u32 size) {
+    bzero(tha, sizeof(TwoHeadArena));
+    tha->bufp = ptr;
+    tha->size = size;
+    THA_Init(tha);
+}
+
+void THA_Dt(TwoHeadArena* tha) {
+    bzero(tha, sizeof(TwoHeadArena));
+}
diff --git a/src/code/TwoHeadGfxArena.c b/src/code/TwoHeadGfxArena.c
new file mode 100644
index 0000000000..2cf73aa880
--- /dev/null
+++ b/src/code/TwoHeadGfxArena.c
@@ -0,0 +1,66 @@
+#include <ultra64.h>
+#include <global.h>
+
+void THGA_Ct(TwoHeadGfxArena* thga, Gfx* start, u32 size) {
+    THA_Ct((TwoHeadArena*)thga, start, size);
+}
+
+void THGA_Dt(TwoHeadGfxArena* thga) {
+    THA_Dt((TwoHeadArena*)thga);
+}
+
+u32 THGA_IsCrash(TwoHeadGfxArena* thga) {
+    return THA_IsCrash((TwoHeadArena*)thga);
+}
+
+void THGA_Init(TwoHeadGfxArena* thga) {
+    THA_Init((TwoHeadArena*)thga);
+}
+
+s32 THGA_GetSize(TwoHeadGfxArena* thga) {
+    return THA_GetSize((TwoHeadArena*)thga);
+}
+
+Gfx* THGA_GetHead(TwoHeadGfxArena* thga) {
+    return THA_GetHead((TwoHeadArena*)thga);
+}
+
+void THGA_SetHead(TwoHeadGfxArena* thga, Gfx* start) {
+    THA_SetHead((TwoHeadArena*)thga, start);
+}
+
+Gfx* THGA_GetTail(TwoHeadGfxArena* thga) {
+    return THA_GetTail((TwoHeadArena*)thga);
+}
+
+Gfx* THGA_AllocStartArray8(TwoHeadGfxArena* thga, u32 count) {
+    return THA_AllocStart((TwoHeadArena*)thga, count * 8);
+}
+
+Gfx* THGA_AllocStart8(TwoHeadGfxArena* thga) {
+    return THGA_AllocStartArray8(thga, 1);
+}
+
+Gfx* THGA_AllocStart8Wrapper(TwoHeadGfxArena* thga) {
+    return THGA_AllocStart8(thga);
+}
+
+Gfx* THGA_AllocEnd(TwoHeadGfxArena* thga, u32 size) {
+    return THA_AllocEnd((TwoHeadArena*)thga, size);
+}
+
+Gfx* THGA_AllocEndArray64(TwoHeadGfxArena* thga, u32 count) {
+    return THGA_AllocEnd(thga, count * 0x40);
+}
+
+Gfx* THGA_AllocEnd64(TwoHeadGfxArena* thga) {
+    return THGA_AllocEnd(thga, 0x40);
+}
+
+Gfx* THGA_AllocEndArray16(TwoHeadGfxArena* thga, u32 count) {
+    return THGA_AllocEnd(thga, count * 0x10);
+}
+
+Gfx* THGA_AllocEnd16(TwoHeadGfxArena* thga) {
+    return THGA_AllocEnd(thga, 0x10);
+}
diff --git a/src/code/game.c b/src/code/game.c
index 206cd69a4f..bde34635e9 100644
--- a/src/code/game.c
+++ b/src/code/game.c
@@ -151,11 +151,11 @@ void Game_InitHeap(GameState *ctxt, u32 size) {
     buf = Gamealloc_Alloc(&_ctx->alloc, size);
 
     if (buf) {
-        GameStateHeap_Init(&ctxt->heap, buf, size);
+        THA_Ct(&ctxt->heap, buf, size);
         return;
     }
 
-    GameStateHeap_Init(&ctxt->heap, NULL, 0);
+    THA_Ct(&ctxt->heap, NULL, 0);
     assert_fail("../game.c", 0x40B);
 }
 
@@ -168,9 +168,9 @@ void Game_ResizeHeap(GameState *ctxt, u32 size)
     u32 bytesAllocated;
     void *heapStart;
 
-    heapStart = ctxt->heap.heapStart;
+    heapStart = ctxt->heap.bufp;
     alloc = &ctxt->alloc;
-    GameStateHeap_Clear(&ctxt->heap);
+    THA_Dt(&ctxt->heap);
     Gamealloc_Free(alloc, heapStart);
     StartHeap_AnalyzeArena(&systemMaxFree, &bytesFree, &bytesAllocated);
     size = ((systemMaxFree - (sizeof(ArenaNode))) < size) ? (0) : (size);
@@ -181,11 +181,11 @@ void Game_ResizeHeap(GameState *ctxt, u32 size)
 
     if (buf = Gamealloc_Alloc(alloc, size))
     {
-        GameStateHeap_Init(&ctxt->heap, buf, size);
+        THA_Ct(&ctxt->heap, buf, size);
     }
     else
     {
-        GameStateHeap_Init(&ctxt->heap, 0, 0);
+        THA_Ct(&ctxt->heap, 0, 0);
         assert_fail("../game.c", 0x432);
     }
 }
@@ -235,7 +235,7 @@ void Game_StateFini(GameState *ctxt) {
     func_801420F4(&D_801F8020);
     func_80141900(&sMonoColors);
     func_80140900(&D_801F8048);
-    GameStateHeap_Clear(&ctxt->heap);
+    THA_Dt(&ctxt->heap);
     Gamealloc_FreeAll(&ctxt->alloc);
 }
 
@@ -252,7 +252,7 @@ u32 Game_GetShouldContinue(GameState *ctxt) {
 }
 
 s32 Game_GetHeapFreeSize(GameState *ctxt) {
-    return GameStateHeap_GetFreeSize(&ctxt->heap);
+    return THA_GetSize(&ctxt->heap);
 }
 
 s32 func_80173B48(GameState *ctxt) {
diff --git a/src/code/z_bgcheck.c b/src/code/z_bgcheck.c
index 2f839a6d83..ed450a4def 100644
--- a/src/code/z_bgcheck.c
+++ b/src/code/z_bgcheck.c
@@ -32,7 +32,7 @@ void BgCheck_PolygonLinkedListInit(GlobalContext* ctxt, BgPolygonLinkedList* lis
 }
 
 void BgCheck_PolygonLinkedListAlloc(GlobalContext* ctxt, BgPolygonLinkedList* list, u32 numNodes) {
-    list->nodes = (BgPolygonLinkedListNode*)GameStateHeap_AllocFromEndAligned(&ctxt->state.heap, numNodes << 2, 0xfffffffe);
+    list->nodes = (BgPolygonLinkedListNode*)THA_AllocEndAlign(&ctxt->state.heap, numNodes << 2, 0xfffffffe);
     list->maxNodes = numNodes;
     list->nextFreeNode = 0;
 }
diff --git a/src/code/z_effect_soft_sprite.c b/src/code/z_effect_soft_sprite.c
index 19478622f7..be20a2452c 100644
--- a/src/code/z_effect_soft_sprite.c
+++ b/src/code/z_effect_soft_sprite.c
@@ -6,7 +6,7 @@ void EffectSS_Init(GlobalContext* ctxt, s32 numEntries) {
     LoadedParticleEntry* iter;
     ParticleOverlay* iter2;
 
-    EffectSS2Info.data_table = (LoadedParticleEntry*)GameStateHeap_AllocFromEnd(&ctxt->state.heap, numEntries * sizeof(LoadedParticleEntry));
+    EffectSS2Info.data_table = (LoadedParticleEntry*)THA_AllocEndAlign16(&ctxt->state.heap, numEntries * sizeof(LoadedParticleEntry));
     EffectSS2Info.searchIndex = 0;
     EffectSS2Info.size = numEntries;
 
diff --git a/src/code/z_scene.c b/src/code/z_scene.c
index 5dc227d25b..e697bd871b 100644
--- a/src/code/z_scene.c
+++ b/src/code/z_scene.c
@@ -59,7 +59,7 @@ void Scene_Init(GlobalContext* ctxt, SceneContext* sceneCtxt) {
     // TODO: 0x23 is OBJECT_EXCHANGE_BANK_MAX in OOT
     for (i = 0; i < 0x23; i++) sceneCtxt->objects[i].id = 0;
 
-    sceneCtxt->objectVramStart = sceneCtxt->objects[0].vramAddr = GameStateHeap_AllocFromEnd(&ctxt->state.heap, spaceSize);
+    sceneCtxt->objectVramStart = sceneCtxt->objects[0].vramAddr = THA_AllocEndAlign16(&ctxt->state.heap, spaceSize);
     // UB to cast sceneCtxt->objectVramStart to s32
     sceneCtxt->objectVramEnd = (void*)((u32)sceneCtxt->objectVramStart + spaceSize);
     // TODO: Second argument here is an object enum
@@ -342,7 +342,7 @@ s32 func_8012FF10(GlobalContext* ctxt, s32 fileIndex) {
     u32 fileSize = D_801C2660[fileIndex].vromEnd - vromStart;
 
     if (fileSize) {
-        ctxt->roomContext.unk74 = GameStateHeap_AllocFromEnd(&ctxt->state.heap, fileSize);
+        ctxt->roomContext.unk74 = THA_AllocEndAlign16(&ctxt->state.heap, fileSize);
         return DmaMgr_SendRequest0(ctxt->roomContext.unk74, vromStart, fileSize);
     }
 
diff --git a/src/code/z_vr_box.c b/src/code/z_vr_box.c
index 50b28f0420..46fb029357 100644
--- a/src/code/z_vr_box.c
+++ b/src/code/z_vr_box.c
@@ -146,15 +146,15 @@ void func_801434E4(GameState* state, SkyboxContext* skyboxCtx, s16 skyType) {
     func_801431E8(state, skyboxCtx, skyType);
 
     if (skyType != 0) {
-        skyboxCtx->unk17C = GameStateHeap_AllocFromEnd(&state->heap, 0x3840);
+        skyboxCtx->unk17C = THA_AllocEndAlign16(&state->heap, 0x3840);
 
         if (skyType == 5) {
             // Allocate enough space for the vertices for a 6 sided skybox (cube)
-            skyboxCtx->roomVtx = GameStateHeap_AllocFromEnd(&state->heap, sizeof(Vtx) * 32 * 6);
+            skyboxCtx->roomVtx = THA_AllocEndAlign16(&state->heap, sizeof(Vtx) * 32 * 6);
             func_80143148(skyboxCtx, 6);
         } else {
             // Allocate enough space for the vertices for a 5 sided skybox (bottom is missing)
-            skyboxCtx->roomVtx = GameStateHeap_AllocFromEnd(&state->heap, sizeof(Vtx) * 32 * 5);
+            skyboxCtx->roomVtx = THA_AllocEndAlign16(&state->heap, sizeof(Vtx) * 32 * 5);
             func_80143148(skyboxCtx, 5);
         }
     }
diff --git a/tables/functions.txt b/tables/functions.txt
index 21ad22a100..d91af1b8a2 100644
--- a/tables/functions.txt
+++ b/tables/functions.txt
@@ -3090,35 +3090,35 @@
     0x801720C4:("func_801720C4",),
     0x801720FC:("func_801720FC",),
     0x80172758:("func_80172758",),
-    0x801727F0:("func_801727F0",),
-    0x80172810:("func_80172810",),
-    0x80172830:("func_80172830",),
-    0x80172850:("func_80172850",),
-    0x80172870:("func_80172870",),
-    0x80172890:("func_80172890",),
-    0x801728B0:("func_801728B0",),
-    0x801728D0:("func_801728D0",),
-    0x801728F0:("func_801728F0",),
-    0x80172914:("func_80172914",),
-    0x80172934:("func_80172934",),
-    0x80172954:("func_80172954",),
-    0x80172974:("func_80172974",),
-    0x80172998:("func_80172998",),
-    0x801729B8:("func_801729B8",),
-    0x801729DC:("func_801729DC",),
-    0x80172A00:("GameStateHeap_GetStart",),
-    0x80172A0C:("GameStateHeap_SetStart",),
-    0x80172A18:("GameStateHeap_GetEnd",),
-    0x80172A24:("GameStateHeap_Alloc",),
-    0x80172A38:("GameStateHeap_AllocByte",),
-    0x80172A58:("GameStateHeap_AllocFromEndAlignedTo",),
-    0x80172AC8:("GameStateHeap_AllocFromEnd",),
-    0x80172AE8:("GameStateHeap_AllocFromEndAligned",),
-    0x80172B04:("GameStateHeap_GetFreeSize",),
-    0x80172B18:("GameStateHeap_GetHasOverflowed",),
-    0x80172B3C:("GameStateHeap_InitAppend",),
-    0x80172B58:("GameStateHeap_Init",),
-    0x80172B9C:("GameStateHeap_Clear",),
+    0x801727F0:("THGA_Ct",),
+    0x80172810:("THGA_Dt",),
+    0x80172830:("THGA_IsCrash",),
+    0x80172850:("THGA_Init",),
+    0x80172870:("THGA_GetSize",),
+    0x80172890:("THGA_GetHead",),
+    0x801728B0:("THGA_SetHead",),
+    0x801728D0:("THGA_GetTail",),
+    0x801728F0:("THGA_AllocStartArray8",),
+    0x80172914:("THGA_AllocStart8",),
+    0x80172934:("THGA_AllocStart8Wrapper",),
+    0x80172954:("THGA_AllocEnd",),
+    0x80172974:("THGA_AllocEndArray64",),
+    0x80172998:("THGA_AllocEnd64",),
+    0x801729B8:("THGA_AllocEndArray16",),
+    0x801729DC:("THGA_AllocEnd16",),
+    0x80172A00:("THA_GetHead",),
+    0x80172A0C:("THA_SetHead",),
+    0x80172A18:("THA_GetTail",),
+    0x80172A24:("THA_AllocStart",),
+    0x80172A38:("THA_AllocStart1",),
+    0x80172A58:("THA_AllocEnd",),
+    0x80172AC8:("THA_AllocEndAlign16",),
+    0x80172AE8:("THA_AllocEndAlign",),
+    0x80172B04:("THA_GetSize",),
+    0x80172B18:("THA_IsCrash",),
+    0x80172B3C:("THA_Init",),
+    0x80172B58:("THA_Ct",),
+    0x80172B9C:("THA_Dt",),
     0x80172BC0:("func_80172BC0",),
     0x80172C30:("func_80172C30",),
     0x80172C68:("func_80172C68",),
diff --git a/tables/objects.txt b/tables/objects.txt
index 56bfc5aa5b..423120be54 100644
--- a/tables/objects.txt
+++ b/tables/objects.txt
@@ -350,8 +350,8 @@
     0x80165460:"z_play",
     0x8016AC10:"z_play_hireso",
     0x8016FCF0:"PreRender",
-    0x801727F0:"",
-    0x80172A00:"",
+    0x801727F0:"TwoHeadGfxArena",
+    0x80172A00:"TwoHeadArena",
     0x80172BC0:"",
     0x80172C30:"",
     0x80173130:"game",