merge with upstream

109 files changed, 14518 insertions, 13363 deletions

diff --git a/src/code/TwoHeadArena.c b/src/code/TwoHeadArena.c
index b46695442..23cfa00f8 100644
--- a/src/code/TwoHeadArena.c
+++ b/src/code/TwoHeadArena.c
@@ -1,172 +1,141 @@
 #include <global.h>
 
-void THGA_Ct(TwoHeadGfxArena* thga, Gfx* start, u32 size)
-{
+void THGA_Ct(TwoHeadGfxArena* thga, Gfx* start, u32 size) {
     THA_Ct((TwoHeadArena*)thga, start, size);
 }
 
-void THGA_Dt(TwoHeadGfxArena* thga)
-{
+void THGA_Dt(TwoHeadGfxArena* thga) {
     THA_Dt((TwoHeadArena*)thga);
 }
 
-u32 THGA_IsCrash(TwoHeadGfxArena* thga)
-{
+u32 THGA_IsCrash(TwoHeadGfxArena* thga) {
     return THA_IsCrash((TwoHeadArena*)thga);
 }
 
-void THGA_Init(TwoHeadGfxArena* thga)
-{
+void THGA_Init(TwoHeadGfxArena* thga) {
     THA_Init((TwoHeadArena*)thga);
 }
 
-s32 THGA_GetSize(TwoHeadGfxArena* thga)
-{
+s32 THGA_GetSize(TwoHeadGfxArena* thga) {
     return THA_GetSize((TwoHeadArena*)thga);
 }
 
-Gfx* THGA_GetHead(TwoHeadGfxArena* thga)
-{
+Gfx* THGA_GetHead(TwoHeadGfxArena* thga) {
     return THA_GetHead((TwoHeadArena*)thga);
 }
 
-void THGA_SetHead(TwoHeadGfxArena* thga, Gfx* start)
-{
+void THGA_SetHead(TwoHeadGfxArena* thga, Gfx* start) {
     THA_SetHead((TwoHeadArena*)thga, start);
 }
 
-Gfx* THGA_GetTail(TwoHeadGfxArena* thga)
-{
+Gfx* THGA_GetTail(TwoHeadGfxArena* thga) {
     return THA_GetTail((TwoHeadArena*)thga);
 }
 
-Gfx* THGA_AllocStartArray8(TwoHeadGfxArena* thga, u32 count)
-{
+Gfx* THGA_AllocStartArray8(TwoHeadGfxArena* thga, u32 count) {
     return THA_AllocStart((TwoHeadArena*)thga, count * 8);
 }
 
-Gfx* THGA_AllocStart8(TwoHeadGfxArena* thga)
-{
+Gfx* THGA_AllocStart8(TwoHeadGfxArena* thga) {
     return THGA_AllocStartArray8(thga, 1);
 }
 
-Gfx* THGA_AllocStart8Wrapper(TwoHeadGfxArena* thga)
-{
+Gfx* THGA_AllocStart8Wrapper(TwoHeadGfxArena* thga) {
     return THGA_AllocStart8(thga);
 }
 
-Gfx* THGA_AllocEnd(TwoHeadGfxArena* thga, u32 size)
-{
+Gfx* THGA_AllocEnd(TwoHeadGfxArena* thga, u32 size) {
     return THA_AllocEnd((TwoHeadArena*)thga, size);
 }
 
-Gfx* THGA_AllocEndArray64(TwoHeadGfxArena* thga, u32 count)
-{
+Gfx* THGA_AllocEndArray64(TwoHeadGfxArena* thga, u32 count) {
     return THGA_AllocEnd(thga, count * 0x40);
 }
 
-Gfx* THGA_AllocEnd64(TwoHeadGfxArena* thga)
-{
+Gfx* THGA_AllocEnd64(TwoHeadGfxArena* thga) {
     return THGA_AllocEnd(thga, 0x40);
 }
 
-Gfx* THGA_AllocEndArray16(TwoHeadGfxArena* thga, u32 count)
-{
+Gfx* THGA_AllocEndArray16(TwoHeadGfxArena* thga, u32 count) {
     return THGA_AllocEnd(thga, count * 0x10);
 }
 
-Gfx* THGA_AllocEnd16(TwoHeadGfxArena* thga)
-{
+Gfx* THGA_AllocEnd16(TwoHeadGfxArena* thga) {
     return THGA_AllocEnd(thga, 0x10);
 }
 
-
-
-
-
-void* THA_GetHead(TwoHeadArena* tha)
-{
+void* THA_GetHead(TwoHeadArena* tha) {
     return tha->head;
 }
 
-void THA_SetHead(TwoHeadArena* tha, void* start)
-{
+void THA_SetHead(TwoHeadArena* tha, void* start) {
     tha->head = start;
 }
 
-void* THA_GetTail(TwoHeadArena* tha)
-{
+void* THA_GetTail(TwoHeadArena* tha) {
     return tha->tail;
 }
 
-void* THA_AllocStart(TwoHeadArena* tha, u32 size)
-{
+void* THA_AllocStart(TwoHeadArena* tha, u32 size) {
     void* start = tha->head;
     tha->head += size;
     return start;
 }
 
-void* THA_AllocStart1(TwoHeadArena* tha)
-{
+void* THA_AllocStart1(TwoHeadArena* tha) {
     return THA_AllocStart(tha, 1);
 }
 
-void* THA_AllocEnd(TwoHeadArena* tha, u32 size)
-{
+void* THA_AllocEnd(TwoHeadArena* tha, u32 size) {
     u32 mask;
     u32* temp;
 
-    if (size == 8)
+    if (size == 8) {
         mask = ~7;
-    else if (size == 4 || size == 12)
+    } else if (size == 4 || size == 12) {
         mask = ~3;
-    else if (size == 2 || size == 6 || size == 10 || size == 12 || size == 14)
+    } else if (size == 2 || size == 6 || size == 10 || size == 12 || size == 14) {
         mask = ~1;
-    else
+    } else {
         mask = (size >= 0x10) ? ~0xF : 0;
+    }
 
     temp = (u32*)&tha->tail; // required to match
     return tha->tail = (void*)(((*temp & mask) - size) & mask);
 }
 
-void* THA_AllocEndAlign16(TwoHeadArena *tha, u32 size)
-{
-    void* ret = (void*)(u32)((((u32)tha->tail & ~0xF) - size) & ((~(0xF & 0xFFFFFFFFFFFFFFFF)) & 0xFFFFFFFFu)); // required to match
+void* THA_AllocEndAlign16(TwoHeadArena* tha, u32 size) {
+    void* ret = (void*)(u32)((((u32)tha->tail & ~0xF) - size) &
+                             ((~(0xF & 0xFFFFFFFFFFFFFFFF)) & 0xFFFFFFFFu)); // required to match
     tha->tail = ret;
     return ret;
 }
 
-void* THA_AllocEndAlign(TwoHeadArena* tha, u32 size, u32 mask)
-{
+void* THA_AllocEndAlign(TwoHeadArena* tha, u32 size, u32 mask) {
     void* ret = (void*)((((u32)tha->tail & mask) - size) & mask);
     tha->tail = ret;
     return ret;
 }
 
-s32 THA_GetSize(TwoHeadArena* tha)
-{
+s32 THA_GetSize(TwoHeadArena* tha) {
     return tha->tail - tha->head;
 }
 
-u32 THA_IsCrash(TwoHeadArena* tha)
-{
+u32 THA_IsCrash(TwoHeadArena* tha) {
     return THA_GetSize(tha) < 0;
 }
 
-void THA_Init(TwoHeadArena* tha)
-{
+void THA_Init(TwoHeadArena* tha) {
     tha->head = tha->bufp;
     tha->tail = tha->bufp + tha->size;
 }
 
-void THA_Ct(TwoHeadArena* tha, void* ptr, u32 size)
-{
+void THA_Ct(TwoHeadArena* tha, void* ptr, u32 size) {
     tha->bufp = ptr;
     tha->size = size;
     THA_Init(tha);
 }
 
-void THA_Dt(TwoHeadArena* tha)
-{
+void THA_Dt(TwoHeadArena* tha) {
     bzero(tha, sizeof(TwoHeadArena));
 }
diff --git a/src/code/__osMalloc.c b/src/code/__osMalloc.c
index 0d8fec179..d5501c663 100644
--- a/src/code/__osMalloc.c
+++ b/src/code/__osMalloc.c
@@ -1,63 +1,53 @@
 #include <global.h>
 #include <vt.h>
 
-#define FILL_ALLOCBLOCK     (1 << 0)
-#define FILL_FREEBLOCK      (1 << 1)
-#define CHECK_FREE_BLOCK    (1 << 2)
+#define FILL_ALLOCBLOCK (1 << 0)
+#define FILL_FREEBLOCK (1 << 1)
+#define CHECK_FREE_BLOCK (1 << 2)
 
-#define NODE_MAGIC          (0x7373)
+#define NODE_MAGIC (0x7373)
 
-#define BLOCK_UNINIT_MAGIC      (0xAB)
-#define BLOCK_UNINIT_MAGIC_32   (0xABABABAB)
-#define BLOCK_ALLOC_MAGIC       (0xCD)
-#define BLOCK_ALLOC_MAGIC_32    (0xCDCDCDCD)
-#define BLOCK_FREE_MAGIC        (0xEF)
-#define BLOCK_FREE_MAGIC_32     (0xEFEFEFEF)
+#define BLOCK_UNINIT_MAGIC (0xAB)
+#define BLOCK_UNINIT_MAGIC_32 (0xABABABAB)
+#define BLOCK_ALLOC_MAGIC (0xCD)
+#define BLOCK_ALLOC_MAGIC_32 (0xCDCDCDCD)
+#define BLOCK_FREE_MAGIC (0xEF)
+#define BLOCK_FREE_MAGIC_32 (0xEFEFEFEF)
 
 OSMesg sArenaLockMsg;
 u32 __osMalloc_FreeBlockTest_Enable;
 
-bool ArenaImpl_GetFillAllocBlock(Arena* arena)
-{
+bool ArenaImpl_GetFillAllocBlock(Arena* arena) {
     return (arena->flag & FILL_ALLOCBLOCK) != 0;
 }
-bool ArenaImpl_GetFillFreeBlock(Arena* arena)
-{
+bool ArenaImpl_GetFillFreeBlock(Arena* arena) {
     return (arena->flag & FILL_FREEBLOCK) != 0;
 }
-bool ArenaImpl_GetCheckFreeBlock(Arena* arena)
-{
+bool ArenaImpl_GetCheckFreeBlock(Arena* arena) {
     return (arena->flag & CHECK_FREE_BLOCK) != 0;
 }
 
-void ArenaImpl_SetFillAllocBlock(Arena* arena)
-{
+void ArenaImpl_SetFillAllocBlock(Arena* arena) {
     arena->flag |= FILL_ALLOCBLOCK;
 }
-void ArenaImpl_SetFillFreeBlock(Arena* arena)
-{
+void ArenaImpl_SetFillFreeBlock(Arena* arena) {
     arena->flag |= FILL_FREEBLOCK;
 }
-void ArenaImpl_SetCheckFreeBlock(Arena* arena)
-{
+void ArenaImpl_SetCheckFreeBlock(Arena* arena) {
     arena->flag |= CHECK_FREE_BLOCK;
 }
 
-void ArenaImpl_UnsetFillAllocBlock(Arena* arena)
-{
+void ArenaImpl_UnsetFillAllocBlock(Arena* arena) {
     arena->flag &= ~FILL_ALLOCBLOCK;
 }
-void ArenaImpl_UnsetFillFreeBlock(Arena* arena)
-{
+void ArenaImpl_UnsetFillFreeBlock(Arena* arena) {
     arena->flag &= ~FILL_FREEBLOCK;
 }
-void ArenaImpl_UnsetCheckFreeBlock(Arena* arena)
-{
+void ArenaImpl_UnsetCheckFreeBlock(Arena* arena) {
     arena->flag &= ~CHECK_FREE_BLOCK;
 }
 
-void ArenaImpl_SetDebugInfo(ArenaNode* node, const char* file, s32 line, Arena* arena)
-{
+void ArenaImpl_SetDebugInfo(ArenaNode* node, const char* file, s32 line, Arena* arena) {
     node->filename = file;
     node->line = line;
     node->threadId = osGetThreadId(NULL);
@@ -65,28 +55,23 @@ void ArenaImpl_SetDebugInfo(ArenaNode* node, const char* file, s32 line, Arena*
     node->time = osGetTime();
 }
 
-void ArenaImpl_LockInit(Arena* arena)
-{
+void ArenaImpl_LockInit(Arena* arena) {
     osCreateMesgQueue(&arena->lock, &sArenaLockMsg, 1);
 }
 
-void ArenaImpl_Lock(Arena* arena)
-{
+void ArenaImpl_Lock(Arena* arena) {
     osSendMesg(&arena->lock, NULL, OS_MESG_BLOCK);
 }
 
-void ArenaImpl_Unlock(Arena* arena)
-{
+void ArenaImpl_Unlock(Arena* arena) {
     osRecvMesg(&arena->lock, NULL, OS_MESG_BLOCK);
 }
 
-ArenaNode* ArenaImpl_GetNextBlock(ArenaNode* node)
-{
+ArenaNode* ArenaImpl_GetNextBlock(ArenaNode* node) {
     ArenaNode* ret;
 
     ret = node->next;
-    if (ret && (!ret || (ret->magic != NODE_MAGIC)))
-    {
+    if (ret && (!ret || (ret->magic != NODE_MAGIC))) {
         osSyncPrintf(VT_COL(RED, WHITE) "緊急事態！メモリリーク発見！ (block=%08x)\n" VT_RST, ret);
         ret = NULL;
         node->next = NULL;
@@ -95,13 +80,11 @@ ArenaNode* ArenaImpl_GetNextBlock(ArenaNode* node)
     return ret;
 }
 
-ArenaNode* ArenaImpl_GetPrevBlock(ArenaNode* node)
-{
+ArenaNode* ArenaImpl_GetPrevBlock(ArenaNode* node) {
     ArenaNode* ret;
 
     ret = node->prev;
-    if (ret && (!ret || (ret->magic != NODE_MAGIC)))
-    {
+    if (ret && (!ret || (ret->magic != NODE_MAGIC))) {
         osSyncPrintf(VT_COL(RED, WHITE) "緊急事態！メモリリーク発見！ (block=%08x)\n" VT_RST, ret);
         ret = NULL;
         node->prev = NULL;
@@ -110,16 +93,13 @@ ArenaNode* ArenaImpl_GetPrevBlock(ArenaNode* node)
     return ret;
 }
 
-ArenaNode* ArenaImpl_GetLastBlock(Arena* arena)
-{
+ArenaNode* ArenaImpl_GetLastBlock(Arena* arena) {
     ArenaNode* ret = NULL;
     ArenaNode* iter;
 
-    if (arena && arena->head && arena->head->magic == NODE_MAGIC)
-    {
+    if (arena && arena->head && arena->head->magic == NODE_MAGIC) {
         iter = arena->head;
-        while (iter)
-        {
+        while (iter) {
             ret = iter;
             iter = ArenaImpl_GetNextBlock(iter);
         }
@@ -128,29 +108,25 @@ ArenaNode* ArenaImpl_GetLastBlock(Arena* arena)
     return ret;
 }
 
-void __osMallocInit(Arena* arena, void* start, u32 size)
-{
+void __osMallocInit(Arena* arena, void* start, u32 size) {
     bzero(arena, sizeof(Arena));
     ArenaImpl_LockInit(arena);
     __osMallocAddBlock(arena, start, size);
     arena->isInit = true;
 }
 
-void __osMallocAddBlock(Arena* arena, void* start, s32 size)
-{
+void __osMallocAddBlock(Arena* arena, void* start, s32 size) {
     s32 diff;
     s32 size2;
     ArenaNode* firstNode;
     ArenaNode* lastNode;
-    
-    if (start)
-    {
+
+    if (start) {
         firstNode = (ArenaNode*)ALIGN16((u32)start);
         diff = (s32)firstNode - (s32)start;
         size2 = (size - diff) & ~0xF;
-        if (size2 > (s32)sizeof(ArenaNode))
-        {
-            func_80106860(firstNode, BLOCK_UNINIT_MAGIC, size2); //memset
+        if (size2 > (s32)sizeof(ArenaNode)) {
+            func_80106860(firstNode, BLOCK_UNINIT_MAGIC, size2); // memset
             firstNode->next = NULL;
             firstNode->prev = NULL;
             firstNode->size = size2 - sizeof(ArenaNode);
@@ -158,13 +134,10 @@ void __osMallocAddBlock(Arena* arena, void* start, s32 size)
             firstNode->magic = NODE_MAGIC;
             ArenaImpl_Lock(arena);
             lastNode = ArenaImpl_GetLastBlock(arena);
-            if (!lastNode)
-            {
+            if (!lastNode) {
                 arena->head = firstNode;
                 arena->start = start;
-            }
-            else
-            {
+            } else {
                 firstNode->prev = lastNode;
                 lastNode->next = firstNode;
             }
@@ -173,53 +146,47 @@ void __osMallocAddBlock(Arena* arena, void* start, s32 size)
     }
 }
 
-void ArenaImpl_RemoveAllBlocks(Arena* arena)
-{
+void ArenaImpl_RemoveAllBlocks(Arena* arena) {
     ArenaNode* iter;
     ArenaNode* next;
 
     ArenaImpl_Lock(arena);
     iter = arena->head;
-    while (iter)
-    {
+    while (iter) {
         next = ArenaImpl_GetNextBlock(iter);
-        func_80106860(iter, BLOCK_UNINIT_MAGIC, iter->size + sizeof(ArenaNode)); //memset
+        func_80106860(iter, BLOCK_UNINIT_MAGIC, iter->size + sizeof(ArenaNode)); // memset
         iter = next;
     }
 
     ArenaImpl_Unlock(arena);
 }
 
-void __osMallocCleanup(Arena* arena)
-{
+void __osMallocCleanup(Arena* arena) {
     ArenaImpl_RemoveAllBlocks(arena);
     bzero(arena, sizeof(*arena));
 }
 
-u8 __osMallocIsInitalized(Arena* arena)
-{
+u8 __osMallocIsInitalized(Arena* arena) {
     return arena->isInit;
 }
 
-void __osMalloc_FreeBlockTest(Arena *arena, ArenaNode *node)
-{
-    ArenaNode *node2;
+void __osMalloc_FreeBlockTest(Arena* arena, ArenaNode* node) {
+    ArenaNode* node2;
     u32* start;
     u32* end;
     u32* iter;
 
     node2 = node;
 
-    if (__osMalloc_FreeBlockTest_Enable)
-    {
+    if (__osMalloc_FreeBlockTest_Enable) {
         start = (u32*)((u32)node + sizeof(ArenaNode));
-        end = (u32*)((u32) start + node2->size);
+        end = (u32*)((u32)start + node2->size);
         iter = start;
-        while (iter < end)
-        {
-            if (*iter != BLOCK_UNINIT_MAGIC_32 && *iter != BLOCK_FREE_MAGIC_32)
-            {
-                osSyncPrintf(VT_COL(RED, WHITE) "緊急事態！メモリリーク検出！ (block=%08x s=%08x e=%08x p=%08x)\n" VT_RST, node, start, end, iter);
+        while (iter < end) {
+            if (*iter != BLOCK_UNINIT_MAGIC_32 && *iter != BLOCK_FREE_MAGIC_32) {
+                osSyncPrintf(
+                    VT_COL(RED, WHITE) "緊急事態！メモリリーク検出！ (block=%08x s=%08x e=%08x p=%08x)\n" VT_RST, node,
+                    start, end, iter);
                 __osDisplayArena(arena);
                 return;
             }
@@ -228,31 +195,26 @@ void __osMalloc_FreeBlockTest(Arena *arena, ArenaNode *node)
     }
 }
 
-//single instruction not matching, stack problem
-#ifdef NON_MATCHING
-void* __osMalloc_NoLockDebug(Arena *arena, u32 size, const char *file, s32 line)
-{
-    ArenaNode *iter;
+void* __osMalloc_NoLockDebug(Arena* arena, u32 size, const char* file, s32 line) {
+    ArenaNode* iter;
     u32 blockSize;
-    ArenaNode *newNode;
-    void *ret;
-    ArenaNode *next;
-    u32 pad;
+    ArenaNode* newNode;
+    void* ret;
+    ArenaNode* next;
 
     ret = NULL;
     iter = arena->head;
     size = ALIGN16(size);
-    while (iter)
-    {
-        if (iter->isFree && iter->size >= size)
-        {
-            if ((arena->flag & CHECK_FREE_BLOCK) != 0)
+    blockSize = ALIGN16(size) + sizeof(ArenaNode);
+
+    while (iter) {
+        if (iter->isFree && iter->size >= size) {
+            if (arena->flag & CHECK_FREE_BLOCK) {
                 __osMalloc_FreeBlockTest(arena, iter);
+            }
 
-            blockSize = ALIGN16(size) + sizeof(ArenaNode);
-            if (blockSize < iter->size)
-            {
-                newNode = (ArenaNode *)((u32)iter + blockSize);
+            if (blockSize < iter->size) {
+                newNode = (ArenaNode*)((u32)iter + blockSize);
                 newNode->next = ArenaImpl_GetNextBlock(iter);
                 newNode->prev = iter;
                 newNode->size = iter->size - blockSize;
@@ -262,15 +224,17 @@ void* __osMalloc_NoLockDebug(Arena *arena, u32 size, const char *file, s32 line)
                 iter->next = newNode;
                 iter->size = size;
                 next = ArenaImpl_GetNextBlock(newNode);
-                if (next)
+                if (next) {
                     next->prev = newNode;
+                }
             }
 
             iter->isFree = false;
             ArenaImpl_SetDebugInfo(iter, file, line, arena);
-            ret = (void *)((u32)iter + sizeof(ArenaNode));
-            if ((arena->flag & FILL_ALLOCBLOCK) != 0)
+            ret = (void*)((u32)iter + sizeof(ArenaNode));
+            if (arena->flag & FILL_ALLOCBLOCK) {
                 func_80106860(ret, BLOCK_ALLOC_MAGIC, size);
+            }
 
             break;
         }
@@ -280,12 +244,8 @@ void* __osMalloc_NoLockDebug(Arena *arena, u32 size, const char *file, s32 line)
 
     return ret;
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/__osMalloc/__osMalloc_NoLockDebug.s")
-#endif
 
-void* __osMallocDebug(Arena* arena, u32 size, const char* file, s32 line)
-{
+void* __osMallocDebug(Arena* arena, u32 size, const char* file, s32 line) {
     void* ret;
     ArenaImpl_Lock(arena);
     ret = __osMalloc_NoLockDebug(arena, size, file, line);
@@ -293,31 +253,27 @@ void* __osMallocDebug(Arena* arena, u32 size, const char* file, s32 line)
     return ret;
 }
 
-//stack + missing a move
-#ifdef NON_MATCHING
-void* __osMallocRDebug(Arena *arena, u32 size, const char *file, s32 line)
-{
-    ArenaNode *iter;
+void* __osMallocRDebug(Arena* arena, u32 size, const char* file, s32 line) {
+    ArenaNode* iter;
+    ArenaNode* newNode;
     u32 blockSize;
-    ArenaNode *newNode;
-    ArenaNode *next;
-    void *ret;
+    ArenaNode* next;
+    void* ret;
 
     ret = NULL;
     size = ALIGN16(size);
     ArenaImpl_Lock(arena);
-    iter = ArenaImpl_GetLastBlock(arena);;
-    while (iter)
-    {
-        if (iter->isFree && iter->size >= size)
-        {
-            if ((arena->flag & CHECK_FREE_BLOCK) != 0)
+    iter = ArenaImpl_GetLastBlock(arena);
+
+    while (iter) {
+        if (iter->isFree && iter->size >= size) {
+            if (arena->flag & CHECK_FREE_BLOCK) {
                 __osMalloc_FreeBlockTest(arena, iter);
+            }
 
             blockSize = ALIGN16(size) + sizeof(ArenaNode);
-            if (blockSize < iter->size)
-            {
-                newNode = (ArenaNode *)((u32)iter + (iter->size - size));
+            if (blockSize < iter->size) {
+                newNode = (ArenaNode*)((u32)iter + (iter->size - size));
                 newNode->next = ArenaImpl_GetNextBlock(iter);
                 newNode->prev = iter;
                 newNode->size = size;
@@ -326,15 +282,19 @@ void* __osMallocRDebug(Arena *arena, u32 size, const char *file, s32 line)
                 iter->next = newNode;
                 iter->size -= blockSize;
                 next = ArenaImpl_GetNextBlock(newNode);
-                if (next)
+                if (next) {
                     next->prev = newNode;
+                }
+
+                iter = newNode;
             }
 
             iter->isFree = false;
             ArenaImpl_SetDebugInfo(iter, file, line, arena);
-            ret = (void *)((u32)iter + sizeof(ArenaNode));
-            if ((arena->flag & FILL_ALLOCBLOCK) != 0)
+            ret = (void*)((u32)iter + sizeof(ArenaNode));
+            if (arena->flag & FILL_ALLOCBLOCK) {
                 func_80106860(ret, BLOCK_ALLOC_MAGIC, size);
+            }
 
             break;
         }
@@ -345,36 +305,28 @@ void* __osMallocRDebug(Arena *arena, u32 size, const char *file, s32 line)
     ArenaImpl_Unlock(arena);
     return ret;
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/__osMalloc/__osMallocRDebug.s")
-#endif
-
 
-//same diff as __osMalloc_NoLockDebug
-#ifdef NON_MATCHING
-void* __osMalloc_NoLock(Arena *arena, u32 size)
-{
-    ArenaNode *iter;
+void* __osMalloc_NoLock(Arena* arena, u32 size) {
+    ArenaNode* iter;
     u32 blockSize;
-    ArenaNode *newNode;
-    void *ret;
-    ArenaNode *next;
-    u32 pad;
+    ArenaNode* newNode;
+    void* ret;
+    ArenaNode* next;
 
     ret = NULL;
     iter = arena->head;
     size = ALIGN16(size);
-    while (iter)
-    {
-        if (iter->isFree && iter->size >= size)
-        {
-            if ((arena->flag & CHECK_FREE_BLOCK) != 0)
+    blockSize = ALIGN16(size) + sizeof(ArenaNode);
+
+    while (iter) {
+
+        if (iter->isFree && iter->size >= size) {
+            if (arena->flag & CHECK_FREE_BLOCK) {
                 __osMalloc_FreeBlockTest(arena, iter);
+            }
 
-            blockSize = ALIGN16(size) + sizeof(ArenaNode);
-            if (blockSize < iter->size)
-            {
-                newNode = (ArenaNode *)((u32)iter + blockSize);
+            if (blockSize < iter->size) {
+                newNode = (ArenaNode*)((u32)iter + blockSize);
                 newNode->next = ArenaImpl_GetNextBlock(iter);
                 newNode->prev = iter;
                 newNode->size = iter->size - blockSize;
@@ -384,15 +336,17 @@ void* __osMalloc_NoLock(Arena *arena, u32 size)
                 iter->next = newNode;
                 iter->size = size;
                 next = ArenaImpl_GetNextBlock(newNode);
-                if (next)
+                if (next) {
                     next->prev = newNode;
+                }
             }
 
             iter->isFree = false;
             ArenaImpl_SetDebugInfo(iter, NULL, 0, arena);
-            ret = (void *)((u32)iter + sizeof(ArenaNode));
-            if ((arena->flag & FILL_ALLOCBLOCK) != 0)
+            ret = (void*)((u32)iter + sizeof(ArenaNode));
+            if (arena->flag & FILL_ALLOCBLOCK) {
                 func_80106860(ret, BLOCK_ALLOC_MAGIC, size);
+            }
 
             break;
         }
@@ -402,12 +356,8 @@ void* __osMalloc_NoLock(Arena *arena, u32 size)
 
     return ret;
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/__osMalloc/__osMalloc_NoLock.s")
-#endif
 
-void* __osMalloc(Arena* arena, u32 size)
-{
+void* __osMalloc(Arena* arena, u32 size) {
     void* ret;
     ArenaImpl_Lock(arena);
     ret = __osMalloc_NoLock(arena, size);
@@ -415,31 +365,27 @@ void* __osMalloc(Arena* arena, u32 size)
     return ret;
 }
 
-//same diff as __osMallocRDebug
-#ifdef NON_MATCHING
-void* __osMallocR(Arena *arena, u32 size)
-{
-    ArenaNode *iter;
+void* __osMallocR(Arena* arena, u32 size) {
+    ArenaNode* iter;
+    ArenaNode* newNode;
     u32 blockSize;
-    ArenaNode *newNode;
-    ArenaNode *next;
-    void *ret;
+    ArenaNode* next;
+    void* ret;
 
     ret = NULL;
     size = ALIGN16(size);
     ArenaImpl_Lock(arena);
-    iter = ArenaImpl_GetLastBlock(arena);;
-    while (iter)
-    {
-        if (iter->isFree && iter->size >= size)
-        {
-            if ((arena->flag & CHECK_FREE_BLOCK) != 0)
+    iter = ArenaImpl_GetLastBlock(arena);
+
+    while (iter) {
+        if (iter->isFree && iter->size >= size) {
+            if (arena->flag & CHECK_FREE_BLOCK) {
                 __osMalloc_FreeBlockTest(arena, iter);
+            }
 
             blockSize = ALIGN16(size) + sizeof(ArenaNode);
-            if (blockSize < iter->size)
-            {
-                newNode = (ArenaNode *)((u32)iter + (iter->size - size));
+            if (blockSize < iter->size) {
+                newNode = (ArenaNode*)((u32)iter + (iter->size - size));
                 newNode->next = ArenaImpl_GetNextBlock(iter);
                 newNode->prev = iter;
                 newNode->size = size;
@@ -448,15 +394,19 @@ void* __osMallocR(Arena *arena, u32 size)
                 iter->next = newNode;
                 iter->size -= blockSize;
                 next = ArenaImpl_GetNextBlock(newNode);
-                if (next)
+                if (next) {
                     next->prev = newNode;
+                }
+
+                iter = newNode;
             }
 
             iter->isFree = false;
             ArenaImpl_SetDebugInfo(iter, NULL, 0, arena);
-            ret = (void *)((u32)iter + sizeof(ArenaNode));
-            if ((arena->flag & FILL_ALLOCBLOCK) != 0)
+            ret = (void*)((u32)iter + sizeof(ArenaNode));
+            if (arena->flag & FILL_ALLOCBLOCK) {
                 func_80106860(ret, BLOCK_ALLOC_MAGIC, size);
+            }
 
             break;
         }
@@ -467,37 +417,28 @@ void* __osMallocR(Arena *arena, u32 size)
     ArenaImpl_Unlock(arena);
     return ret;
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/__osMalloc/__osMallocR.s")
-#endif
-
 
-//small reordering
-#ifdef NON_MATCHING
-void __osFree_NoLock(Arena* arena, void* ptr)
-{
+void __osFree_NoLock(Arena* arena, void* ptr) {
     ArenaNode* node;
     ArenaNode* next;
     ArenaNode* prev;
     ArenaNode* newNext;
 
-    if (ptr)
-    {
+    if (ptr) {
         node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
-        if (node == NULL || node->magic != NODE_MAGIC)
-        {
-            osSyncPrintf(VT_COL(RED, WHITE) "__osFree:不正解放(%08x)\n" VT_RST, arena); //__osFree: Unauthorized release (%08x)
+        if (node == NULL || node->magic != NODE_MAGIC) {
+            osSyncPrintf(VT_COL(RED, WHITE) "__osFree:不正解放(%08x)\n" VT_RST,
+                         ptr); // __osFree: Unauthorized release (%08x)
             return;
         }
-        if (node->isFree)
-        {
-            osSyncPrintf(VT_COL(RED, WHITE) "__osFree:二重解放(%08x)\n" VT_RST, arena); //__osFree: Double release (%08x)
+        if (node->isFree) {
+            osSyncPrintf(VT_COL(RED, WHITE) "__osFree:二重解放(%08x)\n" VT_RST, ptr); // __osFree: Double release (%08x)
             return;
         }
-        if (arena != node->arena && arena != NULL)
-        {
-            //__osFree:Tried to release in a different way than when it was secured (%08x:%08x)
-            osSyncPrintf(VT_COL(RED, WHITE) "__osFree:確保時と違う方法で解放しようとした (%08x:%08x)\n" VT_RST, arena, node->arena);
+        if (arena != node->arena && arena != NULL) {
+            // __osFree:Tried to release in a different way than when it was secured (%08x:%08x)
+            osSyncPrintf(VT_COL(RED, WHITE) "__osFree:確保時と違う方法で解放しようとした (%08x:%08x)\n" VT_RST, arena,
+                         node->arena);
             return;
         }
 
@@ -505,73 +446,66 @@ void __osFree_NoLock(Arena* arena, void* ptr)
         prev = ArenaImpl_GetPrevBlock(node);
         node->isFree = true;
         ArenaImpl_SetDebugInfo(node, NULL, 0, arena);
-        if ((arena->flag & FILL_FREEBLOCK) != 0)
-        {
+        if (arena->flag & FILL_FREEBLOCK) {
             func_80106860((u32)node + sizeof(ArenaNode), BLOCK_FREE_MAGIC, node->size);
         }
 
-        newNext = node->next;
-        if ((u32)next == (u32)node + sizeof(ArenaNode) + node->size && next->isFree)
-        {
+        newNext = next;
+        if ((u32)next == (u32)node + sizeof(ArenaNode) + node->size && next->isFree) {
             newNext = ArenaImpl_GetNextBlock(next);
-            if (newNext)
+            if (newNext) {
                 newNext->prev = node;
-            
+            }
+
             node->size += next->size + sizeof(ArenaNode);
-            if ((arena->flag & FILL_FREEBLOCK) != 0)
+            if (arena->flag & FILL_FREEBLOCK) {
                 func_80106860(next, BLOCK_FREE_MAGIC, sizeof(ArenaNode));
+            }
             node->next = newNext;
+            next = newNext;
         }
-        if (prev && prev->isFree && (u32)node == (u32)prev + sizeof(ArenaNode) + prev->size)
-        {
-            if (newNext)
-                newNext->prev = prev;
-            prev->next = newNext;
+
+        if (prev && prev->isFree && (u32)node == (u32)prev + sizeof(ArenaNode) + prev->size) {
+            if (next) {
+                next->prev = prev;
+            }
+            prev->next = next;
             prev->size += node->size + sizeof(ArenaNode);
-            if ((arena->flag & FILL_FREEBLOCK) != 0)
+            if (arena->flag & FILL_FREEBLOCK) {
                 func_80106860(node, BLOCK_FREE_MAGIC, sizeof(ArenaNode));
+            }
         }
-
     }
-
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/__osMalloc/__osFree_NoLock.s")
-#endif
 
-void __osFree(Arena* arena, void* ptr)
-{
+void __osFree(Arena* arena, void* ptr) {
     ArenaImpl_Lock(arena);
     __osFree_NoLock(arena, ptr);
     ArenaImpl_Unlock(arena);
 }
 
-//small reordering
-#ifdef NON_MATCHING
-void __osFree_NoLockDebug(Arena* arena, void* ptr, const char* file, s32 line)
-{
+void __osFree_NoLockDebug(Arena* arena, void* ptr, const char* file, s32 line) {
     ArenaNode* node;
     ArenaNode* next;
     ArenaNode* prev;
     ArenaNode* newNext;
 
-    if (ptr)
-    {
+    if (ptr) {
         node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
-        if (node == NULL || node->magic != NODE_MAGIC)
-        {
-            osSyncPrintf(VT_COL(RED, WHITE) "__osFree:不正解放(%08x) [%s:%d ]\n" VT_RST, arena, file, line); //__osFree: Unauthorized release (%08x)
+        if (node == NULL || node->magic != NODE_MAGIC) {
+            osSyncPrintf(VT_COL(RED, WHITE) "__osFree:不正解放(%08x) [%s:%d ]\n" VT_RST, ptr, file,
+                         line); // __osFree: Unauthorized release (%08x)
             return;
         }
-        if (node->isFree)
-        {
-            osSyncPrintf(VT_COL(RED, WHITE) "__osFree:二重解放(%08x)\n" VT_RST, arena); //__osFree: Double release (%08x)
+        if (node->isFree) {
+            osSyncPrintf(VT_COL(RED, WHITE) "__osFree:二重解放(%08x) [%s:%d ]\n" VT_RST, ptr, file,
+                         line); // __osFree: Double release (%08x)
             return;
         }
-        if (arena != node->arena && arena != NULL)
-        {
-            //__osFree:Tried to release in a different way than when it was secured (%08x:%08x)
-            osSyncPrintf(VT_COL(RED, WHITE) "__osFree:確保時と違う方法で解放しようとした (%08x:%08x)\n" VT_RST, arena, node->arena);
+        if (arena != node->arena && arena != NULL) {
+            // __osFree:Tried to release in a different way than when it was secured (%08x:%08x)
+            osSyncPrintf(VT_COL(RED, WHITE) "__osFree:確保時と違う方法で解放しようとした (%08x:%08x)\n" VT_RST, arena,
+                         node->arena);
             return;
         }
 
@@ -579,175 +513,145 @@ void __osFree_NoLockDebug(Arena* arena, void* ptr, const char* file, s32 line)
         prev = ArenaImpl_GetPrevBlock(node);
         node->isFree = true;
         ArenaImpl_SetDebugInfo(node, file, line, arena);
-        if ((arena->flag & FILL_FREEBLOCK) != 0)
-        {
+        if (arena->flag & FILL_FREEBLOCK) {
             func_80106860((u32)node + sizeof(ArenaNode), BLOCK_FREE_MAGIC, node->size);
         }
 
         newNext = node->next;
-        if ((u32)next == (u32)node + sizeof(ArenaNode) + node->size && next->isFree)
-        {
+        if ((u32)next == (u32)node + sizeof(ArenaNode) + node->size && next->isFree) {
             newNext = ArenaImpl_GetNextBlock(next);
-            if (newNext)
+            if (newNext) {
                 newNext->prev = node;
-            
+            }
+
             node->size += next->size + sizeof(ArenaNode);
-            if ((arena->flag & FILL_FREEBLOCK) != 0)
+            if (arena->flag & FILL_FREEBLOCK) {
                 func_80106860(next, BLOCK_FREE_MAGIC, sizeof(ArenaNode));
+            }
             node->next = newNext;
+            next = newNext;
         }
-        if (prev && prev->isFree && (u32)node == (u32)prev + sizeof(ArenaNode) + prev->size)
-        {
-            if (newNext)
-                newNext->prev = prev;
-            prev->next = newNext;
+
+        if (prev && prev->isFree && (u32)node == (u32)prev + sizeof(ArenaNode) + prev->size) {
+            if (next) {
+                next->prev = prev;
+            }
+            prev->next = next;
             prev->size += node->size + sizeof(ArenaNode);
-            if ((arena->flag & FILL_FREEBLOCK) != 0)
+            if (arena->flag & FILL_FREEBLOCK) {
                 func_80106860(node, BLOCK_FREE_MAGIC, sizeof(ArenaNode));
+            }
         }
-
     }
-
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/__osMalloc/__osFree_NoLockDebug.s")
-#endif
 
-void __osFreeDebug(Arena* arena, void* ptr, const char* file, s32 line)
-{
+void __osFreeDebug(Arena* arena, void* ptr, const char* file, s32 line) {
     ArenaImpl_Lock(arena);
     __osFree_NoLockDebug(arena, ptr, file, line);
     ArenaImpl_Unlock(arena);
 }
 
-//small reordering, stack usage
-#ifdef NON_MATCHING
-void* __osRealloc(Arena* arena, void* ptr, u32 newSize)
-{
+void* __osRealloc(Arena* arena, void* ptr, u32 newSize) {
+    void* newAlloc;
     ArenaNode* node;
     ArenaNode* next;
-    u32 sizeDiff;
-    ArenaNode* overNext;
     ArenaNode* newNext;
-    void* newAlloc;
-    //-----------
-    ArenaNode* next2;
-    ArenaNode unk;
+    ArenaNode* overNext;
     ArenaNode* newNext2;
+    ArenaNode* next2;
+    u32 sizeDiff;
     ArenaNode* overNext2;
-    //----------
-    u32 newSize2;
-    ArenaNode* newNext3;
-    ArenaNode* overNext3;
-
+    ArenaNode localCopy;
+    u32 blockSize;
+    s32 pad;
 
     newSize = ALIGN16(newSize);
     osSyncPrintf("__osRealloc(%08x, %d)\n", ptr, newSize);
     ArenaImpl_Lock(arena);
-    if (!ptr)
-    {
-        ptr = __osMalloc(arena, newSize);
-    }
-    else if (!newSize)
-    {
+    if (!ptr) {
+        ptr = __osMalloc_NoLock(arena, newSize);
+    } else if (!newSize) {
         __osFree_NoLock(arena, ptr);
         ptr = NULL;
-    }
-    else
-    {
+    } else {
         node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
-        if (newSize == node->size)
-        {
-            //Does nothing because the memory block size does not change
+        if (newSize == node->size) {
+            // Does nothing because the memory block size does not change
             osSyncPrintf("メモリブロックサイズが変わらないためなにもしません\n");
-        }
-        else if (node->size < newSize)
-        {
+        } else if (node->size < newSize) {
             next = ArenaImpl_GetNextBlock(node);
             sizeDiff = newSize - node->size;
-            if ((u32)next == ((u32)node + node->size + sizeof(ArenaNode)) && next->isFree && next->size >= sizeDiff)
-            {
-                //Merge because there is a free block after the current memory block
+            if ((u32)next == ((u32)node + node->size + sizeof(ArenaNode)) && next->isFree && next->size >= sizeDiff) {
+                // Merge because there is a free block after the current memory block
                 osSyncPrintf("現メモリブロックの後ろにフリーブロックがあるので結合します\n");
                 next->size -= sizeDiff;
                 overNext = ArenaImpl_GetNextBlock(next);
                 newNext = (ArenaNode*)((u32)next + sizeDiff);
-                if (overNext)
+                if (overNext) {
                     overNext->prev = newNext;
+                }
                 node->next = newNext;
                 node->size = newSize;
-                func_801068B0(newNext, next, sizeof(ArenaNode)); //memcpy
-            }
-            else
-            {
-                //Allocate a new memory block and move the contents
+                func_801068B0(newNext, next, sizeof(ArenaNode)); // memcpy
+            } else {
+                // Allocate a new memory block and move the contents
                 osSyncPrintf("新たにメモリブロックを確保して内容を移動します\n");
                 newAlloc = __osMalloc_NoLock(arena, newSize);
-                if (newAlloc)
-                {
+                if (newAlloc) {
                     bcopy(ptr, newAlloc, node->size);
                     __osFree_NoLock(arena, ptr);
                 }
                 ptr = newAlloc;
             }
-        }
-        else if (newSize < node->size)
-        {
+        } else if (newSize < node->size) {
             next2 = ArenaImpl_GetNextBlock(node);
-            if (next && next->isFree)
-            {   
-                //Increased free block behind current memory block
+            if (next2 && next2->isFree) {
+                blockSize = ALIGN16(newSize) + sizeof(ArenaNode);
+                // Increased free block behind current memory block
                 osSyncPrintf("現メモリブロックの後ろのフリーブロックを大きくしました\n");
-                unk = *next2;
-                newNext2 = (u32)node + ALIGN16(newSize) + sizeof(ArenaNode);
-                *newNext2 = unk;
+                newNext2 = (ArenaNode*)((u32)node + blockSize);
+                localCopy = *next2;
+                *newNext2 = localCopy;
                 newNext2->size += node->size - newSize;
                 node->next = newNext2;
                 node->size = newSize;
                 overNext2 = ArenaImpl_GetNextBlock(newNext2);
-                if (overNext2)
+                if (overNext2) {
                     overNext2->prev = newNext2;
-            }
-            else if (newSize + sizeof(ArenaNode) < node->size)
-            {
-                //Generated because there is no free block after the current memory block
+                }
+            } else if (newSize + sizeof(ArenaNode) < node->size) {
+                blockSize = ALIGN16(newSize) + sizeof(ArenaNode);
+                // Generated because there is no free block after the current memory block
                 osSyncPrintf("現メモリブロックの後ろにフリーブロックがないので生成します\n");
-                newSize2 = ALIGN16(newSize) + sizeof(ArenaNode);
-                newNext3 = (ArenaNode*)((u32)node + newSize2);
-                newNext3->next = ArenaImpl_GetNextBlock(node);
-                newNext3->prev = node;
-                newNext3->size = node->size - newSize2;
-                newNext3->isFree = true;
-                newNext3->magic = NODE_MAGIC;
-                node->next = newNext3;
+                newNext2 = (ArenaNode*)((u32)node + blockSize);
+                newNext2->next = ArenaImpl_GetNextBlock(node);
+                newNext2->prev = node;
+                newNext2->size = node->size - blockSize;
+                newNext2->isFree = true;
+                newNext2->magic = NODE_MAGIC;
+                node->next = newNext2;
                 node->size = newSize;
-                overNext3 = ArenaImpl_GetNextBlock(newNext3);
-                if (overNext3)
-                    overNext3->prev = newNext3;
-            }
-            else
-            {
-                //There is no room to generate free blocks
+                overNext2 = ArenaImpl_GetNextBlock(newNext2);
+                if (overNext2) {
+                    overNext2->prev = newNext2;
+                }
+            } else {
+                // There is no room to generate free blocks
                 osSyncPrintf("フリーブロック生成するだけの空きがありません\n");
                 ptr = NULL;
             }
         }
-
     }
+
     ArenaImpl_Unlock(arena);
     return ptr;
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/__osMalloc/__osRealloc.s")
-#endif
 
-void* __osReallocDebug(Arena* arena, void* ptr, u32 newSize, const char* file, s32 line)
-{
+void* __osReallocDebug(Arena* arena, void* ptr, u32 newSize, const char* file, s32 line) {
     return __osRealloc(arena, ptr, newSize);
 }
 
-void ArenaImpl_GetSizes(Arena* arena, u32* outMaxFree, u32* outFree, u32* outAlloc)
-{
+void ArenaImpl_GetSizes(Arena* arena, u32* outMaxFree, u32* outFree, u32* outAlloc) {
     ArenaNode* iter;
 
     ArenaImpl_Lock(arena);
@@ -757,16 +661,15 @@ void ArenaImpl_GetSizes(Arena* arena, u32* outMaxFree, u32* outFree, u32* outAll
     *outAlloc = 0;
 
     iter = arena->head;
-    while(iter)
-    {
-        if (iter->isFree)
-        {
+    while (iter) {
+        if (iter->isFree) {
             *outFree += iter->size;
-            if (*outMaxFree < iter->size)
+            if (*outMaxFree < iter->size) {
                 *outMaxFree = iter->size;
-        }
-        else
+            }
+        } else {
             *outAlloc += iter->size;
+        }
 
         iter = ArenaImpl_GetNextBlock(iter);
     }
@@ -774,19 +677,15 @@ void ArenaImpl_GetSizes(Arena* arena, u32* outMaxFree, u32* outFree, u32* outAll
     ArenaImpl_Unlock(arena);
 }
 
-//small reordering at the end
-#ifdef NON_MATCHING
-void __osDisplayArena(Arena* arena)
-{
+void __osDisplayArena(Arena* arena) {
     u32 freeSize;
     u32 allocatedSize;
     u32 maxFree;
     ArenaNode* iter;
     ArenaNode* next;
 
-    if (!__osMallocIsInitalized(arena))
-    {
-        //Arena is not initalized
+    if (!__osMallocIsInitalized(arena)) {
+        // Arena is not initalized
         osSyncPrintf("アリーナは初期化されていません\n");
         return;
     }
@@ -797,61 +696,51 @@ void __osDisplayArena(Arena* arena)
     freeSize = 0;
     allocatedSize = 0;
 
-    //Arena contents (0x%08x)
+    // Arena contents (0x%08x)
     osSyncPrintf("アリーナの内容 (0x%08x)\n", arena);
-    //Memory node range status size [time s ms us ns: TID: src: line]
+    // Memory node range status size [time s ms us ns: TID: src: line]
     osSyncPrintf("メモリブロック範囲 status サイズ  [時刻  s ms us ns: TID:src:行]\n");
 
     iter = arena->head;
-    while(iter)
-    {
-        if (iter && iter->magic == NODE_MAGIC)
-        {
+    while (iter) {
+        if (iter && iter->magic == NODE_MAGIC) {
             next = iter->next;
             osSyncPrintf("%08x-%08x%c %s %08x", iter, ((u32)iter + sizeof(ArenaNode) + iter->size),
-                (!next) ? '$' : (iter != next->prev ? '!' : ' '),
-                iter->isFree ? "空き" : "確保", //? "Free" : "Secure"
-                iter->size);
-            
-            if (!iter->isFree)
-                osSyncPrintf(" [%016llu:%2d:%s:%d]", (iter->time*64ll)/3ull, iter->threadId, iter->filename ? iter->filename : "**NULL**", iter->line);
+                         (!next) ? '$' : (iter != next->prev ? '!' : ' '),
+                         iter->isFree ? "空き" : "確保", //? "Free" : "Secure"
+                         iter->size);
+
+            if (!iter->isFree) {
+                osSyncPrintf(" [%016llu:%2d:%s:%d]", (iter->time * 64ll) / 3ull, iter->threadId,
+                             iter->filename ? iter->filename : "**NULL**", iter->line);
+            }
 
             osSyncPrintf("\n");
 
-            if (iter->isFree)
-            {
+            if (iter->isFree) {
                 freeSize += iter->size;
-                if (maxFree < iter->size)
+                if (maxFree < iter->size) {
                     maxFree = iter->size;
-            }
-            else
-            {
+                }
+            } else {
                 allocatedSize += iter->size;
             }
-
-            iter = next;
-        }
-        else
-        {
+        } else {
             osSyncPrintf("%08x Block Invalid\n", iter);
-            iter = NULL;
+            next = NULL;
         }
+
+        iter = next;
     }
 
-    osSyncPrintf("確保ブロックサイズの合計 0x%08x バイト\n", allocatedSize); //Total reserved node size 0x%08x bytes
-    osSyncPrintf("空きブロックサイズの合計 0x%08x バイト\n", freeSize); //Total free node size 0x%08x bytes
-    osSyncPrintf("最大空きブロックサイズ   0x%08x バイト\n", maxFree); //Maximum free node size 0x%08x bytes
+    osSyncPrintf("確保ブロックサイズの合計 0x%08x バイト\n", allocatedSize); // Total reserved node size 0x%08x bytes
+    osSyncPrintf("空きブロックサイズの合計 0x%08x バイト\n", freeSize);      // Total free node size 0x%08x bytes
+    osSyncPrintf("最大空きブロックサイズ   0x%08x バイト\n", maxFree);       // Maximum free node size 0x%08x bytes
 
     ArenaImpl_Unlock(arena);
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/__osMalloc/__osDisplayArena.s")
-#endif
 
-//small reordering
-#ifdef NON_MATCHING
-void ArenaImpl_FaultClient(Arena* arena)
-{
+void ArenaImpl_FaultClient(Arena* arena) {
     u32 freeSize;
     u32 allocatedSize;
     u32 maxFree;
@@ -859,8 +748,7 @@ void ArenaImpl_FaultClient(Arena* arena)
     ArenaNode* next;
 
     FaultDrawer_Printf("ARENA INFO (0x%08x)\n", arena);
-    if (!__osMallocIsInitalized(arena))
-    {
+    if (!__osMallocIsInitalized(arena)) {
         FaultDrawer_Printf("Arena is uninitalized\n", arena);
         return;
     }
@@ -872,37 +760,29 @@ void ArenaImpl_FaultClient(Arena* arena)
     FaultDrawer_Printf("Memory Block Region status size\n");
 
     iter = arena->head;
-    while(iter)
-    {
-        if (iter && iter->magic == NODE_MAGIC)
-        {
+    while (iter) {
+        if (iter && iter->magic == NODE_MAGIC) {
             next = iter->next;
             FaultDrawer_Printf("%08x-%08x%c %s %08x", iter, ((u32)iter + sizeof(ArenaNode) + iter->size),
-                (!next) ? '$' : (iter != next->prev ? '!' : ' '),
-                iter->isFree ? "F" : "A",
-                iter->size);
-            
+                               (!next) ? '$' : (iter != next->prev ? '!' : ' '), iter->isFree ? "F" : "A", iter->size);
+
             FaultDrawer_Printf("\n");
 
-            if (iter->isFree)
-            {
+            if (iter->isFree) {
                 freeSize += iter->size;
-                if (maxFree < iter->size)
+                if (maxFree < iter->size) {
                     maxFree = iter->size;
-            }
-            else
-            {
+                }
+            } else {
                 allocatedSize += iter->size;
             }
-
-            iter = next;
-        }
-        else
-        {
+        } else {
             FaultDrawer_SetFontColor(0xF801);
             FaultDrawer_Printf("%08x Block Invalid\n", iter);
-            iter = NULL;
+            next = NULL;
         }
+
+        iter = next;
     }
 
     FaultDrawer_SetFontColor(0x7F1);
@@ -910,41 +790,33 @@ void ArenaImpl_FaultClient(Arena* arena)
     FaultDrawer_Printf("Total Free Block Size   %08x\n", freeSize);
     FaultDrawer_Printf("Largest Free Block Size %08x\n", maxFree);
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/__osMalloc/ArenaImpl_FaultClient.s")
-#endif
 
-u32 __osCheckArena(Arena* arena)
-{
-    ArenaNode *iter;
+u32 __osCheckArena(Arena* arena) {
+    ArenaNode* iter;
     u32 error;
 
     error = 0;
     ArenaImpl_Lock(arena);
-    //Checking the contents of the arena. . ． (%08x)
+    // Checking the contents of the arena. . ． (%08x)
     osSyncPrintf("アリーナの内容をチェックしています．．． (%08x)\n", arena);
     iter = arena->head;
-    while(iter)
-    {
-        if (iter && iter->magic == NODE_MAGIC)
-        {
-            //Oops!! (%08x %08x)
+    while (iter) {
+        if (iter && iter->magic == NODE_MAGIC) {
+            // Oops!! (%08x %08x)
             osSyncPrintf(VT_COL(RED, WHITE) "おおっと！！ (%08x %08x)\n" VT_RST, iter, iter->magic);
             error = 1;
             break;
         }
         iter = ArenaImpl_GetNextBlock(iter);
     }
-    if (!error)
-    {
-        //The arena is still going well
+    if (!error) {
+        // The arena is still going well
         osSyncPrintf("アリーナはまだ、いけそうです\n");
     }
     ArenaImpl_Unlock(arena);
     return error;
 }
 
-u8 func_800FF334(Arena* arena)
-{
+u8 func_800FF334(Arena* arena) {
     return arena->unk_20;
 }
diff --git a/src/code/audioMgr.c b/src/code/audioMgr.c
index a834c746e..2372355de 100644
--- a/src/code/audioMgr.c
+++ b/src/code/audioMgr.c
@@ -14,4 +14,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/audioMgr/func_800C3FC4.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/audioMgr/func_800C3FEC.s")
-
diff --git a/src/code/code_80026B00.c b/src/code/code_80026B00.c
deleted file mode 100644
index 3cd8d4772..000000000
--- a/src/code/code_80026B00.c
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <ultra64.h>
-#include <global.h>
-
-GlobalContext* func_80026B00(void)
-{
-    return D_80157DA0;
-}
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_80026B00/func_80026B0C.s")
-
-void func_80026C1C(u8* arg0)
-{
-    arg0[0] = 0;
-    arg0[1] = 0;
-    arg0[2] = 0;
-}
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_80026B00/func_80026C2C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_80026B00/Effect_Add.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_80026B00/func_80026E74.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_80026B00/func_80026F70.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_80026B00/func_8002709C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_80026B00/func_800271A8.s")
diff --git a/src/code/code_800430A0.c b/src/code/code_800430A0.c
index c03b84f3e..344c4ddb5 100644
--- a/src/code/code_800430A0.c
+++ b/src/code/code_800430A0.c
@@ -3,59 +3,56 @@
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/code_800430A0/func_800430A0.s")
 
-void func_800432A0(CollisionContext* colCtx, u32 floorPolySource, Actor* actor)
-{
-    if (func_8003E934(floorPolySource) != 0)
-    {
+void func_800432A0(CollisionContext* colCtx, u32 floorPolySource, Actor* actor) {
+    if (func_8003E934(floorPolySource) != 0) {
         s16 v1 = colCtx->dyna.actorMeshArr[floorPolySource].rot2.y - colCtx->dyna.actorMeshArr[floorPolySource].rot1.y;
 
-        if (actor->id == 0)
+        if (actor->id == 0) {
             ((Player*)actor)->unk_83C += v1;
+        }
 
         actor->shape.rot.y += v1;
         actor->posRot.rot.y += v1;
     }
 }
 
-void func_80043334(CollisionContext* colCtx, Actor* actor, u32 floorPolySource)
-{
-    if (func_8003E934(floorPolySource) != 0)
-    {
+void func_80043334(CollisionContext* colCtx, Actor* actor, u32 floorPolySource) {
+    if (func_8003E934(floorPolySource) != 0) {
         DynaPolyActor* dynaActor = DynaPolyInfo_GetActor(colCtx, floorPolySource);
-        if (dynaActor != NULL)
-        {
+        if (dynaActor != NULL) {
             func_800434A8(dynaActor);
 
-            if ((actor->flags & 0x4000000) == 0x4000000)
+            if ((actor->flags & 0x4000000) == 0x4000000) {
                 func_80043538(dynaActor);
+            }
         }
     }
 }
 
-s32 func_800433A4(CollisionContext* colCtx, u32 floorPolySource, Actor* actor)
-{
+s32 func_800433A4(CollisionContext* colCtx, u32 floorPolySource, Actor* actor) {
     s32 sp24 = 0;
     DynaPolyActor* dynaActor;
 
-    if (func_8003E934(floorPolySource) == 0)
+    if (func_8003E934(floorPolySource) == 0) {
         return 0;
+    }
 
-    if ((colCtx->dyna.flags[floorPolySource] & 2) || !(colCtx->dyna.flags[floorPolySource] & 1))
+    if ((colCtx->dyna.flags[floorPolySource] & 2) || !(colCtx->dyna.flags[floorPolySource] & 1)) {
         return 0;
+    }
 
     dynaActor = DynaPolyInfo_GetActor(colCtx, floorPolySource);
 
-    if (dynaActor == NULL)
+    if (dynaActor == NULL) {
         return 0;
+    }
 
-    if (dynaActor->unk_15C & 1)
-    {
+    if (dynaActor->unk_15C & 1) {
         func_800430A0(colCtx, floorPolySource, actor);
         sp24 = 1;
     }
 
-    if (dynaActor->unk_15C & 2)
-    {
+    if (dynaActor->unk_15C & 2) {
         func_800432A0(colCtx, floorPolySource, actor);
         sp24 = 1;
     }
diff --git a/src/code/code_80043480.c b/src/code/code_80043480.c
index 7a040602f..ddd8d0e99 100644
--- a/src/code/code_80043480.c
+++ b/src/code/code_80043480.c
@@ -1,8 +1,7 @@
 #include <ultra64.h>
 #include <global.h>
 
-void DynaPolyInfo_SetActorMove(DynaPolyActor* dynaActor, DynaPolyMoveFlag flags)
-{
+void DynaPolyInfo_SetActorMove(DynaPolyActor* dynaActor, DynaPolyMoveFlag flags) {
     dynaActor->dynaPolyId = -1;
     dynaActor->unk_15C = flags;
     dynaActor->unk_160 = 0;
@@ -10,77 +9,72 @@ void DynaPolyInfo_SetActorMove(DynaPolyActor* dynaActor, DynaPolyMoveFlag flags)
     dynaActor->unk_154 = 0.0f;
 }
 
-void func_800434A0(DynaPolyActor *dynaActor)
-{
+void func_800434A0(DynaPolyActor* dynaActor) {
     dynaActor->unk_160 = 0;
 }
 
-void func_800434A8(DynaPolyActor *dynaActor)
-{
+void func_800434A8(DynaPolyActor* dynaActor) {
     dynaActor->unk_160 |= 1;
 }
 
-void func_800434B8(DynaPolyActor *dynaActor)
-{
+void func_800434B8(DynaPolyActor* dynaActor) {
     dynaActor->unk_160 |= 2;
 }
 
-void func_800434C8(CollisionContext* colCtx, u32 floorPolySource)
-{
-    DynaPolyActor *dynaActor = DynaPolyInfo_GetActor(colCtx, floorPolySource);
+void func_800434C8(CollisionContext* colCtx, u32 floorPolySource) {
+    DynaPolyActor* dynaActor = DynaPolyInfo_GetActor(colCtx, floorPolySource);
 
-    if (dynaActor != NULL)
+    if (dynaActor != NULL) {
         func_800434B8(dynaActor);
+    }
 }
 
-void func_800434F8(DynaPolyActor* dynaActor)
-{
+void func_800434F8(DynaPolyActor* dynaActor) {
     dynaActor->unk_160 |= 4;
 }
 
-void func_80043508(CollisionContext* colCtx, u32 floorPolySource)
-{
-    DynaPolyActor *dynaActor = DynaPolyInfo_GetActor(colCtx, floorPolySource);
+void func_80043508(CollisionContext* colCtx, u32 floorPolySource) {
+    DynaPolyActor* dynaActor = DynaPolyInfo_GetActor(colCtx, floorPolySource);
 
-    if (dynaActor != NULL)
+    if (dynaActor != NULL) {
         func_800434F8(dynaActor);
+    }
 }
 
-void func_80043538(DynaPolyActor* dynaActor)
-{
+void func_80043538(DynaPolyActor* dynaActor) {
     dynaActor->unk_160 |= 8;
 }
 
-s32 func_80043548(DynaPolyActor* dynaActor)
-{
-    if (dynaActor->unk_160 & 1)
+s32 func_80043548(DynaPolyActor* dynaActor) {
+    if (dynaActor->unk_160 & 1) {
         return 1;
-    else
+    } else {
         return 0;
+    }
 }
 
-s32 func_8004356C(DynaPolyActor* dynaActor)
-{
-    if (dynaActor->unk_160 & 2)
+s32 func_8004356C(DynaPolyActor* dynaActor) {
+    if (dynaActor->unk_160 & 2) {
         return 1;
-    else
+    } else {
         return 0;
+    }
 }
 
-s32 func_80043590(DynaPolyActor* dynaActor)
-{
-    if (dynaActor->unk_160 & 4)
+s32 func_80043590(DynaPolyActor* dynaActor) {
+    if (dynaActor->unk_160 & 4) {
         return 1;
-    else
+    } else {
         return 0;
+    }
 }
 
-s32 func_800435B4(DynaPolyActor* dynaActor)
-{
-    if (dynaActor->unk_160 & 8)
+s32 func_800435B4(DynaPolyActor* dynaActor) {
+    if (dynaActor->unk_160 & 8) {
         return 1;
-    else
+    } else {
         return 0;
+    }
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/code_80043480/func_800435D8.s")
diff --git a/src/code/code_80069420.c b/src/code/code_80069420.c
index f0be5b4c3..ee9a179d7 100644
--- a/src/code/code_80069420.c
+++ b/src/code/code_80069420.c
@@ -1,13 +1,11 @@
 #include <ultra64.h>
 #include <global.h>
 
-void* MemCopy(void* dest, void* src, s32 size)
-{
+void* MemCopy(void* dest, void* src, s32 size) {
     u8* destu = (u8*)dest;
     u8* srcu = (u8*)src;
 
-    while (size > 0)
-    {
+    while (size > 0) {
         *destu++ = *srcu++;
         size--;
     }
@@ -15,13 +13,11 @@ void* MemCopy(void* dest, void* src, s32 size)
     return dest;
 }
 
-void* MemSet(void* dest, s32 val, s32 size)
-{
+void* MemSet(void* dest, s32 val, s32 size) {
     u8* destu = (u8*)dest;
     s32 s = size;
 
-    while (s > 0)
-    {
+    while (s > 0) {
         *destu++ = val;
         s--;
     }
diff --git a/src/code/code_8006C360.c b/src/code/code_8006C360.c
deleted file mode 100644
index 3180bab89..000000000
--- a/src/code/code_8006C360.c
+++ /dev/null
@@ -1,5 +0,0 @@
-#include <ultra64.h>
-#include <global.h>
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_8006C360/func_8006C360.s")
-
diff --git a/src/code/code_8006C3A0.c b/src/code/code_8006C3A0.c
index 88889621b..1b7c77c4c 100644
--- a/src/code/code_8006C3A0.c
+++ b/src/code/code_8006C3A0.c
@@ -8,4 +8,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/code_8006C3A0/func_8006C438.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/code_8006C3A0/func_8006C4A4.s")
-
diff --git a/src/code/code_8006C510.c b/src/code/code_8006C510.c
index 5568b32e9..20fa80747 100644
--- a/src/code/code_8006C510.c
+++ b/src/code/code_8006C510.c
@@ -4,4 +4,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/code_8006C510/func_8006C510.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/code_8006C510/func_8006C5A8.s")
-
diff --git a/src/code/code_8006EA30.c b/src/code/code_8006EA30.c
index f433ed6b0..41104fea7 100644
--- a/src/code/code_8006EA30.c
+++ b/src/code/code_8006EA30.c
@@ -5,10 +5,7 @@
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/code_8006EA30/func_8006ECF4.s")
 
-void func_8006EE48(UNK_TYPE arg0)
-{
-
+void func_8006EE48(UNK_TYPE arg0) {
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/code_8006EA30/func_8006EE50.s")
-
diff --git a/src/code/code_8007BE60.c b/src/code/code_8007BE60.c
deleted file mode 100644
index 59ef949c5..000000000
--- a/src/code/code_8007BE60.c
+++ /dev/null
@@ -1,50 +0,0 @@
-#include <ultra64.h>
-#include <global.h>
-
-extern u32 osResetType;
-
-/*
-void func_8007BE60(u32* a0)
-{
-    u32 var1;
-
-    //*a0 = 0;
-
-    if (osResetType == 0)
-    {
-        a0[1] = 0;
-        a0[2] = 0;
-        a0[3] = 0;
-    }
-    else
-    {
-        var1 = a0[3] + a0[5];
-        a0[1]++;
-        a0[2] = (var1 < a0[5]) + a0[2] + a0[4];
-        a0[3] = var1;
-    }
-
-    a0[5] = 0;
-    a0[4] = 0;
-}
-*/
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_8007BE60/func_8007BE60.s")
-
-typedef struct
-{
-    /* 0x00 */ u32    unk_00;
-    /* 0x04 */ char   unk_04[0x0C];
-    /* 0x10 */ OSTime unk_10;
-} struct_8007BED4;
-
-void func_8007BED4(struct_8007BED4* arg0)
-{
-    arg0->unk_00 = 1;
-    arg0->unk_10 = osGetTime();
-}
-
-u32 func_8007BF08(struct_8007BED4* arg0)
-{
-    return arg0->unk_00;
-}
diff --git a/src/code/code_8007BF10.c b/src/code/code_8007BF10.c
deleted file mode 100644
index 46771a303..000000000
--- a/src/code/code_8007BF10.c
+++ /dev/null
@@ -1,5 +0,0 @@
-#include <ultra64.h>
-#include <global.h>
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_8007BF10/func_8007BF10.s")
-
diff --git a/src/code/code_8007BF90.c b/src/code/code_8007BF90.c
index 8c5347971..c51b222f9 100644
--- a/src/code/code_8007BF90.c
+++ b/src/code/code_8007BF90.c
@@ -1,10 +1,9 @@
 #include <ultra64.h>
 #include <global.h>
 
-void func_8007C1AC(Vec3f* dest, struct_80045714* arg1);
+Vec3f* func_8007C1AC(Vec3f* dest, struct_80045714* arg1);
 
-f32 func_8007BF90(Vec3f* a, Vec3f* b)
-{
+f32 func_8007BF90(Vec3f* a, Vec3f* b) {
     f32 dx = a->x - b->x;
     f32 dy = a->y - b->y;
     f32 dz = a->z - b->z;
@@ -12,8 +11,7 @@ f32 func_8007BF90(Vec3f* a, Vec3f* b)
     return sqrtf(SQ(dx) + SQ(dy) + SQ(dz));
 }
 
-f32 func_8007BFD0(Vec3f* a, Vec3f* b, Vec3f* dest)
-{
+f32 func_8007BFD0(Vec3f* a, Vec3f* b, Vec3f* dest) {
     dest->x = a->x - b->x;
     dest->y = a->y - b->y;
     dest->z = a->z - b->z;
@@ -21,66 +19,60 @@ f32 func_8007BFD0(Vec3f* a, Vec3f* b, Vec3f* dest)
     return sqrtf(SQ(dest->x) + SQ(dest->y) + SQ(dest->z));
 }
 
-f32 func_8007C028(Vec3f* a, Vec3f* b)
-{
+f32 func_8007C028(Vec3f* a, Vec3f* b) {
     return sqrtf(SQ(a->x - b->x) + SQ(a->z - b->z));
 }
 
-f32 func_8007C058(f32 arg0, f32 arg1)
-{
+f32 func_8007C058(f32 arg0, f32 arg1) {
     return (arg1 <= fabsf(arg0)) ? arg0 : ((arg0 >= 0) ? arg1 : -arg1);
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/code_8007BF90/func_8007C0A8.s")
 
-#ifdef NON_MATCHING
-void func_8007C0F8(Vec3f* dest, Vec3f* a, Vec3f* b)
-{
-    f32 fVar1;
-    Vec3f v;
+Vec3f* func_8007C0F8(Vec3f* dest, Vec3f* a, Vec3f* b) {
+    Vec3f v1;
+    Vec3f v2;
+    f32 temp;
+
+    v1.x = b->x - a->x;
+    v1.y = b->y - a->y;
+    v1.z = b->z - a->z;
+
+    temp = func_8007C058(sqrtf(SQ(v1.x) + SQ(v1.y) + SQ(v1.z)), 0.01f);
 
-    v.x = b->x - a->x;
-    v.y = b->y - a->y;
-    v.z = b->z - a->z;
+    v2.x = v1.x / temp;
+    v2.y = v1.y / temp;
+    v2.z = v1.z / temp;
 
-    fVar1 = func_8007C058(sqrtf(v.x * v.x + v.y * v.y + v.z * v.z), D_8013CB80);
+    *dest = v2;
 
-    dest->x = v.x / fVar1;
-    dest->y = v.y / fVar1;
-    dest->z = v.z / fVar1;
+    return dest;
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_8007BF90/func_8007C0F8.s")
-#endif
-
-#ifdef NON_MATCHING
-void func_8007C1AC(Vec3f* dest, struct_80045714* arg1)
-{
-    f32 fVar1;
-    f32 fVar2;
-    f32 fVar3;
-    f32 fVar4;
-    f32 fVar5;
-    f32 fVar6;
-
-    fVar1 = Math_Coss(arg1->unk_04);
-    fVar2 = Math_Coss(arg1->unk_06);
-    fVar3 = Math_Coss(arg1->unk_04);
-    fVar4 = Math_Coss(arg1->unk_06);
-    fVar6 = arg1->unk_00;
-    fVar5 = arg1->unk_00;
-    dest->x = arg1->unk_00 * fVar3 * fVar4;
-    dest->y = fVar6 * fVar1;
-    dest->z = fVar5 * fVar3 * fVar2;
+
+Vec3f* func_8007C1AC(Vec3f* dest, struct_80045714* arg1) {
+    Vec3f v;
+    f32 sin4;
+    f32 cos4;
+    f32 sin6;
+    f32 cos6;
+
+    cos4 = Math_Coss(arg1->unk_04);
+    cos6 = Math_Coss(arg1->unk_06);
+    sin4 = Math_Sins(arg1->unk_04);
+    sin6 = Math_Sins(arg1->unk_06);
+
+    v.x = arg1->unk_00 * sin4 * sin6;
+    v.y = arg1->unk_00 * cos4;
+    v.z = arg1->unk_00 * sin4 * cos6;
+
+    *dest = v;
+
+    return dest;
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_8007BF90/func_8007C1AC.s")
-#endif
 
 void func_8007C3F4(struct_80045714* arg0, Vec3f* arg1);
 
-void func_8007C25C(Vec3f* dest, struct_80045714* arg1)
-{
+void func_8007C25C(Vec3f* dest, struct_80045714* arg1) {
     struct_80045714 var;
 
     var.unk_00 = arg1->unk_00;
@@ -96,8 +88,7 @@ void func_8007C25C(Vec3f* dest, struct_80045714* arg1)
 
 void func_8007C29C(struct_80045714* arg0, Vec3f* arg1);
 
-void func_8007C440(struct_80045714* arg0, Vec3f* a, Vec3f* b)
-{
+void func_8007C440(struct_80045714* arg0, Vec3f* a, Vec3f* b) {
     Vec3f var;
 
     var.x = b->x - a->x;
@@ -107,8 +98,7 @@ void func_8007C440(struct_80045714* arg0, Vec3f* a, Vec3f* b)
     func_8007C29C(arg0, &var);
 }
 
-void func_8007C490(struct_80045714* arg0, Vec3f* a, Vec3f* b)
-{
+void func_8007C490(struct_80045714* arg0, Vec3f* a, Vec3f* b) {
     Vec3f var;
 
     var.x = b->x - a->x;
@@ -118,12 +108,11 @@ void func_8007C490(struct_80045714* arg0, Vec3f* a, Vec3f* b)
     func_8007C3F4(arg0, &var);
 }
 
-Vec3f* func_8007C4E0(Vec3f* dest, Vec3f* a, Vec3f* b)
-{
+Vec3f* func_8007C4E0(Vec3f* dest, Vec3f* a, Vec3f* b) {
     Vec3f var;
 
-    var.x = func_800FD250(b->z - a->z, b->y - a->y);
-    var.y = func_800FD250(b->x - a->x, b->z - a->z);
+    var.x = Math_atan2f(b->z - a->z, b->y - a->y);
+    var.y = Math_atan2f(b->x - a->x, b->z - a->z);
     var.z = 0;
 
     *dest = var;
@@ -134,4 +123,3 @@ Vec3f* func_8007C4E0(Vec3f* dest, Vec3f* a, Vec3f* b)
 #pragma GLOBAL_ASM("asm/non_matchings/code/code_8007BF90/func_8007C574.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/code_8007BF90/func_8007C5E0.s")
-
diff --git a/src/code/code_80097A00.c b/src/code/code_80097A00.c
index f30e01f1a..d709fd8c9 100644
--- a/src/code/code_80097A00.c
+++ b/src/code/code_80097A00.c
@@ -2,244 +2,77 @@
 #include <global.h>
 
 // Bit Flag array in which gBitFlags[n] is literally (1 << n)
-u32 gBitFlags[] =
-{
-    (1 <<  0),  (1 <<  1),  (1 <<  2),  (1 <<  3),
-    (1 <<  4),  (1 <<  5),  (1 <<  6),  (1 <<  7),
-    (1 <<  8),  (1 <<  9),  (1 << 10),  (1 << 11),
-    (1 << 12),  (1 << 13),  (1 << 14),  (1 << 15),
-    (1 << 16),  (1 << 17),  (1 << 18),  (1 << 19),
-    (1 << 20),  (1 << 21),  (1 << 22),  (1 << 23),
-    (1 << 24),  (1 << 25),  (1 << 26),  (1 << 27),
-    (1 << 28),  (1 << 29),  (1 << 30),  (1 << 31),
+u32 gBitFlags[] = {
+    (1 << 0),  (1 << 1),  (1 << 2),  (1 << 3),  (1 << 4),  (1 << 5),  (1 << 6),  (1 << 7),
+    (1 << 8),  (1 << 9),  (1 << 10), (1 << 11), (1 << 12), (1 << 13), (1 << 14), (1 << 15),
+    (1 << 16), (1 << 17), (1 << 18), (1 << 19), (1 << 20), (1 << 21), (1 << 22), (1 << 23),
+    (1 << 24), (1 << 25), (1 << 26), (1 << 27), (1 << 28), (1 << 29), (1 << 30), (1 << 31),
 };
 
 u16 gEquipMasks[] = { 0x000F, 0x00F0, 0x0F00, 0xF000 };
 u16 gEquipNegMasks[] = { 0xFFF0, 0xFF0F, 0xF0FF, 0x0FFF };
-u32 gUpgradeMasks[] = { 0x00000007, 0x00000038, 0x000001C0, 0x00000E00, 0x00003000, 0x0001C000, 0x000E0000, 0x00700000 };
-u32 gUpgradeNegMasks[] = { 0xFFFFFFF8, 0xFFFFFFC7, 0xFFFFFE3F, 0xFFFFF1FF, 0xFFFFCFFF, 0xFFFE3FFF, 0xFFF1FFFF, 0xFF8FFFFF };
+u32 gUpgradeMasks[] = {
+    0x00000007, 0x00000038, 0x000001C0, 0x00000E00, 0x00003000, 0x0001C000, 0x000E0000, 0x00700000,
+};
+u32 gUpgradeNegMasks[] = {
+    0xFFFFFFF8, 0xFFFFFFC7, 0xFFFFFE3F, 0xFFFFF1FF, 0xFFFFCFFF, 0xFFFE3FFF, 0xFFF1FFFF, 0xFF8FFFFF,
+};
 u8 gEquipShifts[] = { 0, 4, 8, 12 };
 u8 gUpgradeShifts[] = { 0, 3, 6, 9, 12, 14, 17, 20 };
 
-u16 gUpgradeCapacities[][4] =
-{
-    {   0,  30,  40,  50 }, // Quivers
-    {   0,  20,  30,  40 }, // Bomb Bags
-    {   0,   0,   0,   0 }, // Unused (Scale)
-    {   0,   0,   0,   0 }, // Unused (Strength)
-    {  99, 200, 500, 500 }, // Wallets
-    {   0,  30,  40,  50 }, // Deku Seed Bullet Bags
-    {   0,  10,  20,  30 }, // Deku Stick Upgrades
-    {   0,  20,  30,  40 }, // Deku Nut Upgrades
+u16 gUpgradeCapacities[][4] = {
+    { 0, 30, 40, 50 },     // Quivers
+    { 0, 20, 30, 40 },     // Bomb Bags
+    { 0, 0, 0, 0 },        // Unused (Scale)
+    { 0, 0, 0, 0 },        // Unused (Strength)
+    { 99, 200, 500, 500 }, // Wallets
+    { 0, 30, 40, 50 },     // Deku Seed Bullet Bags
+    { 0, 10, 20, 30 },     // Deku Stick Upgrades
+    { 0, 20, 30, 40 },     // Deku Nut Upgrades
 };
 
 u32 D_8012723C[] = { 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000 }; // Unused
-u32 D_8012724C[] = { 0, 8, 16, 24 }; // Unused
+u32 D_8012724C[] = { 0, 8, 16, 24 };                                   // Unused
 
 // TODO: use symbols for these icon textures once textures are properly in C
-u32 gItemIcons[] =
-{
-    0x08000000,
-    0x08001000,
-    0x08002000,
-    0x08003000,
-    0x08004000,
-    0x08005000,
-    0x08006000,
-    0x08007000,
-    0x08008000,
-    0x08009000,
-    0x0800A000,
-    0x0800B000,
-    0x0800C000,
-    0x0800D000,
-    0x0800E000,
-    0x0800F000,
-    0x08010000,
-    0x08011000,
-    0x08012000,
-    0x08013000,
-    0x08014000,
-    0x08015000,
-    0x08016000,
-    0x08017000,
-    0x08018000,
-    0x08019000,
-    0x0801A000,
-    0x0801B000,
-    0x0801C000,
-    0x0801D000,
-    0x0801E000,
-    0x0801F000,
-    0x08020000,
-    0x08021000,
-    0x08022000,
-    0x08023000,
-    0x08024000,
-    0x08025000,
-    0x08026000,
-    0x08027000,
-    0x08028000,
-    0x08029000,
-    0x0802A000,
-    0x0802B000,
-    0x0802C000,
-    0x0802D000,
-    0x0802E000,
-    0x0802F000,
-    0x08030000,
-    0x08031000,
-    0x08032000,
-    0x08033000,
-    0x08034000,
-    0x08035000,
-    0x08036000,
-    0x08037000,
-    0x08038000,
-    0x08039000,
-    0x0803A000,
-    0x0803B000,
-    0x0803C000,
-    0x0803D000,
-    0x0803E000,
-    0x0803F000,
-    0x08040000,
-    0x08041000,
-    0x08042000,
-    0x08043000,
-    0x08044000,
-    0x08045000,
-    0x08046000,
-    0x08047000,
-    0x08048000,
-    0x08049000,
-    0x0804A000,
-    0x0804B000,
-    0x0804C000,
-    0x0804D000,
-    0x0804E000,
-    0x0804F000,
-    0x08050000,
-    0x08051000,
-    0x08052000,
-    0x08053000,
-    0x08054000,
-    0x08055000,
-    0x08056000,
-    0x08057000,
-    0x08058000,
-    0x08059000,
-    0x08089440,
-    0x08089440,
-    0x08089440,
-    0x08089440,
-    0x08089440,
-    0x08089440,
-    0x08089440,
-    0x08089440,
-    0x08089440,
-    0x08089440,
-    0x08089440,
-    0x08089440,
-    0x09000000,
-    0x09000900,
-    0x09001200,
-    0x09001B00,
-    0x09002400,
-    0x09002D00,
-    0x09003600,
-    0x09003F00,
-    0x09004800,
-    0x09005100,
-    0x09005A00,
-    0x09006300,
-    0x09006C00,
-    0x09007500,
-    0x09007E00,
-    0x09009000,
-    0x09008700,
-    0x09007E00,
-    0x0900A200,
-    0x0900AB00,
-    0x0805A000,
-    0x0805A900,
-    0x0805B200,
-    0x02002D40,
-    0x02002A40,
-    0x02002C40,
-    0x02002B40,
-    0x02002940,
+u32 gItemIcons[] = {
+    0x08000000, 0x08001000, 0x08002000, 0x08003000, 0x08004000, 0x08005000, 0x08006000, 0x08007000, 0x08008000,
+    0x08009000, 0x0800A000, 0x0800B000, 0x0800C000, 0x0800D000, 0x0800E000, 0x0800F000, 0x08010000, 0x08011000,
+    0x08012000, 0x08013000, 0x08014000, 0x08015000, 0x08016000, 0x08017000, 0x08018000, 0x08019000, 0x0801A000,
+    0x0801B000, 0x0801C000, 0x0801D000, 0x0801E000, 0x0801F000, 0x08020000, 0x08021000, 0x08022000, 0x08023000,
+    0x08024000, 0x08025000, 0x08026000, 0x08027000, 0x08028000, 0x08029000, 0x0802A000, 0x0802B000, 0x0802C000,
+    0x0802D000, 0x0802E000, 0x0802F000, 0x08030000, 0x08031000, 0x08032000, 0x08033000, 0x08034000, 0x08035000,
+    0x08036000, 0x08037000, 0x08038000, 0x08039000, 0x0803A000, 0x0803B000, 0x0803C000, 0x0803D000, 0x0803E000,
+    0x0803F000, 0x08040000, 0x08041000, 0x08042000, 0x08043000, 0x08044000, 0x08045000, 0x08046000, 0x08047000,
+    0x08048000, 0x08049000, 0x0804A000, 0x0804B000, 0x0804C000, 0x0804D000, 0x0804E000, 0x0804F000, 0x08050000,
+    0x08051000, 0x08052000, 0x08053000, 0x08054000, 0x08055000, 0x08056000, 0x08057000, 0x08058000, 0x08059000,
+    0x08089440, 0x08089440, 0x08089440, 0x08089440, 0x08089440, 0x08089440, 0x08089440, 0x08089440, 0x08089440,
+    0x08089440, 0x08089440, 0x08089440, 0x09000000, 0x09000900, 0x09001200, 0x09001B00, 0x09002400, 0x09002D00,
+    0x09003600, 0x09003F00, 0x09004800, 0x09005100, 0x09005A00, 0x09006300, 0x09006C00, 0x09007500, 0x09007E00,
+    0x09009000, 0x09008700, 0x09007E00, 0x0900A200, 0x0900AB00, 0x0805A000, 0x0805A900, 0x0805B200, 0x02002D40,
+    0x02002A40, 0x02002C40, 0x02002B40, 0x02002940,
 };
 
 // Used to map item IDs to inventory slots
-u8 gItemSlots[] =
-{
-    SLOT_STICK,
-    SLOT_NUT,
-    SLOT_BOMB,
-    SLOT_BOW,
-    SLOT_ARROW_FIRE,
-    SLOT_DINS_FIRE,
-    SLOT_SLINGSHOT,
-    SLOT_OCARINA,
-    SLOT_OCARINA,
-    SLOT_BOMBCHU,
-    SLOT_HOOKSHOT,
-    SLOT_HOOKSHOT,
-    SLOT_ARROW_ICE,
-    SLOT_FARORES_WIND,
-    SLOT_BOOMERANG,
-    SLOT_LENS,
-    SLOT_BEAN,
-    SLOT_HAMMER,
-    SLOT_ARROW_LIGHT,
-    SLOT_NAYRUS_LOVE,
-    SLOT_BOTTLE_1,
-    SLOT_BOTTLE_1,
-    SLOT_BOTTLE_1,
-    SLOT_BOTTLE_1,
-    SLOT_BOTTLE_1,
-    SLOT_BOTTLE_1,
-    SLOT_BOTTLE_1,
-    SLOT_BOTTLE_1,
-    SLOT_BOTTLE_1,
-    SLOT_BOTTLE_1,
-    SLOT_BOTTLE_1,
-    SLOT_BOTTLE_1,
-    SLOT_BOTTLE_1,
-    SLOT_TRADE_CHILD,
-    SLOT_TRADE_CHILD,
-    SLOT_TRADE_CHILD,
-    SLOT_TRADE_CHILD,
-    SLOT_TRADE_CHILD,
-    SLOT_TRADE_CHILD,
-    SLOT_TRADE_CHILD,
-    SLOT_TRADE_CHILD,
-    SLOT_TRADE_CHILD,
-    SLOT_TRADE_CHILD,
-    SLOT_TRADE_CHILD,
-    SLOT_TRADE_CHILD,
-    SLOT_TRADE_ADULT,
-    SLOT_TRADE_ADULT,
-    SLOT_TRADE_ADULT,
-    SLOT_TRADE_ADULT,
-    SLOT_TRADE_ADULT,
-    SLOT_TRADE_ADULT,
-    SLOT_TRADE_ADULT,
-    SLOT_TRADE_ADULT,
-    SLOT_TRADE_ADULT,
-    SLOT_TRADE_ADULT,
-    SLOT_TRADE_ADULT
+u8 gItemSlots[] = {
+    SLOT_STICK,       SLOT_NUT,          SLOT_BOMB,        SLOT_BOW,         SLOT_ARROW_FIRE,  SLOT_DINS_FIRE,
+    SLOT_SLINGSHOT,   SLOT_OCARINA,      SLOT_OCARINA,     SLOT_BOMBCHU,     SLOT_HOOKSHOT,    SLOT_HOOKSHOT,
+    SLOT_ARROW_ICE,   SLOT_FARORES_WIND, SLOT_BOOMERANG,   SLOT_LENS,        SLOT_BEAN,        SLOT_HAMMER,
+    SLOT_ARROW_LIGHT, SLOT_NAYRUS_LOVE,  SLOT_BOTTLE_1,    SLOT_BOTTLE_1,    SLOT_BOTTLE_1,    SLOT_BOTTLE_1,
+    SLOT_BOTTLE_1,    SLOT_BOTTLE_1,     SLOT_BOTTLE_1,    SLOT_BOTTLE_1,    SLOT_BOTTLE_1,    SLOT_BOTTLE_1,
+    SLOT_BOTTLE_1,    SLOT_BOTTLE_1,     SLOT_BOTTLE_1,    SLOT_TRADE_CHILD, SLOT_TRADE_CHILD, SLOT_TRADE_CHILD,
+    SLOT_TRADE_CHILD, SLOT_TRADE_CHILD,  SLOT_TRADE_CHILD, SLOT_TRADE_CHILD, SLOT_TRADE_CHILD, SLOT_TRADE_CHILD,
+    SLOT_TRADE_CHILD, SLOT_TRADE_CHILD,  SLOT_TRADE_CHILD, SLOT_TRADE_ADULT, SLOT_TRADE_ADULT, SLOT_TRADE_ADULT,
+    SLOT_TRADE_ADULT, SLOT_TRADE_ADULT,  SLOT_TRADE_ADULT, SLOT_TRADE_ADULT, SLOT_TRADE_ADULT, SLOT_TRADE_ADULT,
+    SLOT_TRADE_ADULT, SLOT_TRADE_ADULT,
 };
 
-void Inventory_ChangeEquipment(s16 equipment, u16 value)
-{
+void Inventory_ChangeEquipment(s16 equipment, u16 value) {
     gSaveContext.equips.equipment &= gEquipNegMasks[equipment];
     gSaveContext.equips.equipment |= value << gEquipShifts[equipment];
 }
 
-u8 Inventory_DeleteEquipment(GlobalContext* globalCtx, s16 equipment)
-{
+u8 Inventory_DeleteEquipment(GlobalContext* globalCtx, s16 equipment) {
     Player* player = PLAYER;
     s32 pad;
     u16 sp26;
@@ -249,18 +82,17 @@ u8 Inventory_DeleteEquipment(GlobalContext* globalCtx, s16 equipment)
     // Translates to: "Erasing equipment item = %d  zzz=%d"
     osSyncPrintf("装備アイテム抹消 = %d  zzz=%d\n", equipment, sp26);
 
-    if (sp26)
-    {
+    if (sp26) {
         sp26 >>= gEquipShifts[equipment];
 
         gSaveContext.equips.equipment &= gEquipNegMasks[equipment];
         gSaveContext.equipment ^= gBitFlags[sp26 - 1] << gEquipShifts[equipment];
 
-        if (equipment == EQUIP_TUNIC)
+        if (equipment == EQUIP_TUNIC) {
             gSaveContext.equips.equipment |= 0x0100;
+        }
 
-        if (equipment == EQUIP_SWORD)
-        {
+        if (equipment == EQUIP_SWORD) {
             gSaveContext.equips.button_items[0] = ITEM_NONE;
             gSaveContext.inf_table[29] = 1;
         }
@@ -272,8 +104,7 @@ u8 Inventory_DeleteEquipment(GlobalContext* globalCtx, s16 equipment)
     return sp26;
 }
 
-void Inventory_ChangeUpgrade(s16 upgrade, s16 value)
-{
+void Inventory_ChangeUpgrade(s16 upgrade, s16 value) {
     gSaveContext.upgrades &= gUpgradeNegMasks[upgrade];
     gSaveContext.upgrades |= value << gUpgradeShifts[upgrade];
 }
diff --git a/src/code/code_800A9D40.c b/src/code/code_800A9D40.c
index 960994614..c32d31d4e 100644
--- a/src/code/code_800A9D40.c
+++ b/src/code/code_800A9D40.c
@@ -1,23 +1,20 @@
 #include <ultra64.h>
 #include <global.h>
 
-typedef struct
-{
+typedef struct {
     /* 0x00 */ OSPiHandle piHandle;
     /* 0x74 */ OSIoMesg ioMesg;
     /* 0x8C */ OSMesgQueue mesgQ;
 } struct_800A9D40;
 
-struct_800A9D40 D_8012A690 = {0};
+struct_800A9D40 D_8012A690 = { 0 };
 
 void func_800A9D40(u32 addr, u8 handleType, u8 handleDomain, u8 handleLatency, u8 handlePageSize, u8 handleRelDuration,
-                   u8 handlePulse, u32 handleSpeed)
-{
+                   u8 handlePulse, u32 handleSpeed) {
     u32 int_disabled;
 
-    OSPiHandle *handle = &D_8012A690.piHandle;
-    if ((u32) OS_PHYSICAL_TO_K1(addr) != (*handle).baseAddress)
-    {
+    OSPiHandle* handle = &D_8012A690.piHandle;
+    if ((u32)OS_PHYSICAL_TO_K1(addr) != (*handle).baseAddress) {
         D_8012A690.piHandle.type = handleType;
         (*handle).baseAddress = OS_PHYSICAL_TO_K1(addr);
         D_8012A690.piHandle.latency = handleLatency;
@@ -37,8 +34,7 @@ void func_800A9D40(u32 addr, u8 handleType, u8 handleDomain, u8 handleLatency, u
     }
 }
 
-void func_800A9E14(UNK_PTR dramAddr, size_t size, UNK_TYPE arg2)
-{
+void func_800A9E14(UNK_PTR dramAddr, size_t size, UNK_TYPE arg2) {
     OSMesg mesg;
 
     osCreateMesgQueue(&D_8012A690.mesgQ, &mesg, 1);
@@ -50,8 +46,7 @@ void func_800A9E14(UNK_PTR dramAddr, size_t size, UNK_TYPE arg2)
     osInvalDCache(dramAddr, size);
 }
 
-void Sram_ReadWrite(UNK_TYPE arg0, UNK_PTR dramAddr, size_t size, UNK_TYPE arg3)
-{
+void Sram_ReadWrite(UNK_TYPE arg0, UNK_PTR dramAddr, size_t size, UNK_TYPE arg3) {
     osSyncPrintf("ssSRAMReadWrite:%08x %08x %08x %d\n", arg0, dramAddr, size, arg3);
     func_800A9D40(arg0, 3, 1, 5, 0xd, 2, 0xc, 0);
     func_800A9E14(dramAddr, size, arg3);
diff --git a/src/code/code_800A9F30.c b/src/code/code_800A9F30.c
index c5248faca..ddc8c0223 100644
--- a/src/code/code_800A9F30.c
+++ b/src/code/code_800A9F30.c
@@ -5,26 +5,23 @@
 extern u8 D_80160FD0[];
 extern PadMgr gPadMgr;
 
-void func_800A9F30(s32 a, s32 b)
-{
+void func_800A9F30(s32 a, s32 b) {
     func_800D2E30(&D_80160FD0);
     func_800C7948(a, &D_80160FD0);
 }
 
-void func_800A9F6C(f32 a, u8 b, u8 c, u8 d)
-{
+void func_800A9F6C(f32 a, u8 b, u8 c, u8 d) {
     s32 temp1, temp2;
 
-    if (1000000.0f < a)
+    if (1000000.0f < a) {
         temp1 = 1000;
-    else
+    } else {
         temp1 = sqrtf(a);
+    }
 
-    if ((temp1 < 1000) && (b != 0) && (d != 0))
-    {
+    if ((temp1 < 1000) && (b != 0) && (d != 0)) {
         temp2 = b - (temp1 * 255) / 1000;
-        if (temp2 > 0)
-        {
+        if (temp2 > 0) {
             D_801610DA = temp2;
             D_80160FD0[0x10B] = c;
             D_80160FD0[0x10C] = d;
@@ -35,49 +32,38 @@ void func_800A9F6C(f32 a, u8 b, u8 c, u8 d)
 #pragma GLOBAL_ASM("asm/non_matchings/code/code_800A9F30/func_800AA000.s")
 // this function is very similar to the one above but has a loop in it I can't figure out
 
-void func_800AA0B4(void)
-{
+void func_800AA0B4(void) {
     func_800D3140(&D_80160FD0);
 
     gPadMgr.unk_460 = func_800A9F30;
     gPadMgr.unk_464 = 0;
 
-    if (0) ; // Necessary to match
+    if (0) {} // Necessary to match
 }
 
-#ifdef NON_MATCHING
-void func_800AA0F0(void)
-{
-    if ((gPadMgr.unk_460 == func_800A9F30) && (gPadMgr.unk_464 == 0))
-    {
-        // asm loads/writes directly to 0x80166D20 and 0x80166D24
-        // but the compiler wants to reuse offsets from 0x801668C0
-        gPadMgr.unk_460 = NULL;
-        gPadMgr.unk_464 = 0;
+void func_800AA0F0(void) {
+    PadMgr* padmgr = &gPadMgr;
+
+    if ((padmgr->unk_460 == func_800A9F30) && (padmgr->unk_464 == 0)) {
+        padmgr->unk_460 = NULL;
+        padmgr->unk_464 = 0;
     }
 
     func_800D3178(&D_80160FD0);
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_800A9F30/func_800AA0F0.s")
-#endif
 
-u32 func_800AA148(void)
-{
+u32 func_800AA148(void) {
     return ((gPadMgr.unk_2AE[0] ^ 1) == 0);
 }
 
-void func_800AA15C(void)
-{
+void func_800AA15C(void) {
     D_801610D4 = 2;
 }
 
-void func_800AA16C(void)
-{
+void func_800AA16C(void) {
     D_801610D4 = 0;
 }
 
-void func_800AA178(u32 a)
-{
+void func_800AA178(u32 a) {
     D_801610D5 = !!a;
 }
diff --git a/src/code/code_800ACE70.c b/src/code/code_800ACE70.c
new file mode 100644
index 000000000..31e93ad63
--- /dev/null
+++ b/src/code/code_800ACE70.c
@@ -0,0 +1,106 @@
+#include <global.h>
+
+typedef struct {
+    /* 0x00 */ u32 type;
+    /* 0x04 */ u32 setScissor;
+    /* 0x08 */ union {
+        Color_RGBA8 c;
+        u32 rgba;
+    } color;
+    /* 0x0C */ u32 unk_0C;
+} struct_801664F0;
+
+Gfx D_8012AC00[] = {
+    gsDPSetOtherMode(G_AD_PATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_CONV | G_TF_POINT | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PRIM | G_RM_VISCVG | G_RM_VISCVG2),
+    gsDPFillRectangle(0, 0, SCREEN_WIDTH - 1, SCREEN_HEIGHT - 1),
+    gsDPPipeSync(),
+    gsDPSetBlendColor(0, 0, 0, 8),
+    gsSPEndDisplayList(),
+};
+
+Gfx D_8012AC28[] = {
+    gsDPSetOtherMode(G_AD_PATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_CONV | G_TF_POINT | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PRIM | IM_RD | CVG_DST_CLAMP | ZMODE_OPA | FORCE_BL |
+                         GBL_c1(G_BL_CLR_FOG, G_BL_A_FOG, G_BL_CLR_MEM, G_BL_A_MEM) |
+                         GBL_c2(G_BL_CLR_FOG, G_BL_A_FOG, G_BL_CLR_MEM, G_BL_A_MEM)),
+    gsDPFillRectangle(0, 0, SCREEN_WIDTH - 1, SCREEN_HEIGHT - 1),
+    gsSPEndDisplayList(),
+};
+
+Gfx D_8012AC40[] = {
+    gsDPSetOtherMode(G_AD_PATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_CONV | G_TF_POINT | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PRIM | IM_RD | CVG_DST_CLAMP | ZMODE_OPA | FORCE_BL |
+                         GBL_c1(G_BL_CLR_IN, G_BL_0, G_BL_CLR_MEM, G_BL_A_MEM) |
+                         GBL_c2(G_BL_CLR_IN, G_BL_0, G_BL_CLR_MEM, G_BL_A_MEM)),
+
+    gsDPFillRectangle(0, 0, SCREEN_WIDTH - 1, SCREEN_HEIGHT - 1),
+    gsSPEndDisplayList(),
+};
+
+Gfx D_8012AC58[] = {
+    gsDPSetCombineMode(G_CC_PRIMITIVE, G_CC_PRIMITIVE),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_DISABLE | G_CK_NONE | G_TC_CONV | G_TF_POINT | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PRIM | G_RM_CLD_SURF | G_RM_CLD_SURF2),
+    gsDPFillRectangle(0, 0, SCREEN_WIDTH - 1, SCREEN_HEIGHT - 1),
+    gsDPSetOtherMode(G_AD_PATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_CONV | G_TF_POINT | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PRIM | IM_RD | CVG_DST_CLAMP | ZMODE_OPA | FORCE_BL |
+                         GBL_c1(G_BL_CLR_IN, G_BL_0, G_BL_CLR_MEM, G_BL_A_MEM) |
+                         GBL_c2(G_BL_CLR_IN, G_BL_0, G_BL_CLR_MEM, G_BL_A_MEM)),
+    gsDPFillRectangle(0, 0, SCREEN_WIDTH - 1, SCREEN_HEIGHT - 1),
+    gsSPEndDisplayList(),
+};
+
+// Init func
+void func_800ACE70(struct_801664F0* this) {
+    this->type = 0;
+    this->setScissor = false;
+    this->color.c.r = 0xFF;
+    this->color.c.g = 0xFF;
+    this->color.c.b = 0xFF;
+    this->color.c.a = 0xFF;
+}
+
+// Destroy func
+void func_800ACE90(struct_801664F0* this) {
+}
+
+// Update func
+void func_800ACE98(struct_801664F0* this, Gfx** gfxp) {
+    Gfx* gfx;
+
+    gfx = *gfxp;
+
+    gDPPipeSync(gfx++);
+    gDPSetPrimDepth(gfx++, -1, -1);
+
+    if (this->setScissor == true) {
+        gDPSetScissor(gfx++, G_SC_NON_INTERLACE, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
+    }
+
+    switch (this->type) {
+        case 1:
+            gSPDisplayList(gfx++, D_8012AC40);
+            break;
+        case 2:
+            gDPSetColor(gfx++, G_SETPRIMCOLOR, this->color.rgba);
+            gSPDisplayList(gfx++, D_8012AC58);
+            break;
+        case 3:
+            gDPSetColor(gfx++, G_SETBLENDCOLOR, this->color.rgba);
+            gSPDisplayList(gfx++, D_8012AC00);
+            break;
+        case 4:
+            gDPSetColor(gfx++, G_SETFOGCOLOR, this->color.rgba);
+            gSPDisplayList(gfx++, D_8012AC28);
+            break;
+    }
+
+    gDPPipeSync(gfx++);
+    *gfxp = gfx;
+}
diff --git a/src/code/code_800D31A0.c b/src/code/code_800D31A0.c
new file mode 100644
index 000000000..3f7382440
--- /dev/null
+++ b/src/code/code_800D31A0.c
@@ -0,0 +1,24 @@
+#include <global.h>
+#include <padmgr.h>
+#include <vt.h>
+
+extern PadMgr gPadMgr;
+
+u32 D_8012DBC0 = false;
+
+void func_800D31A0() {
+    osSyncPrintf(VT_FGCOL(RED) "\n**** Freeze!! ****\n" VT_RST);
+    while (true) {
+        func_800FF4AC(1000); // msleep
+    }
+}
+
+void func_800D31F0() {
+    PadMgr* padMgr = (PadMgr*)(u32)&gPadMgr; // cast required to match
+
+    D_8012DBC0 = (padMgr->unk_2A8 & 2) != 0;
+}
+
+void func_800D3210() {
+    D_8012DBC0 = false;
+}
diff --git a/src/code/code_800FBCE0.c b/src/code/code_800FBCE0.c
index 251638883..2c17e6fa2 100644
--- a/src/code/code_800FBCE0.c
+++ b/src/code/code_800FBCE0.c
@@ -1,10 +1,13 @@
 #include <z64.h>
 
-#define printSpStatus(x, name) if (x & SP_STATUS_##name) osSyncPrintf(#name " ")
-#define printDpStatus(x, name) if (x & DPC_STATUS_##name) osSyncPrintf(#name " ")
+#define printSpStatus(x, name) \
+    if (x & SP_STATUS_##name)  \
+    osSyncPrintf(#name " ")
+#define printDpStatus(x, name) \
+    if (x & DPC_STATUS_##name) \
+    osSyncPrintf(#name " ")
 
-void func_800FBCE0()
-{
+void func_800FBCE0() {
     u32 spStatus = __osSpGetStatus();
     u32 dpStatus = osDpGetStatus();
 
@@ -41,10 +44,9 @@ void func_800FBCE0()
     osSyncPrintf("\n");
 }
 
-void func_800FBFD8()
-{
+void func_800FBFD8() {
     func_800FBCE0();
     osDpSetStatus(DPC_SET_FREEZE | DPC_SET_FLUSH);
     __osSpSetStatus(SP_SET_HALT | SP_SET_SIG2 | SP_CLR_INTR_BREAK);
     func_800FBCE0();
-}
\ No newline at end of file
+}
diff --git a/src/code/code_800FC620.c b/src/code/code_800FC620.c
index 81f0f53e7..b0b16b8b7 100644
--- a/src/code/code_800FC620.c
+++ b/src/code/code_800FC620.c
@@ -1,52 +1,44 @@
 #include <global.h>
 
 typedef void (*arg3_800FC868)(void*);
-typedef void (*arg3_800FC8D8)(void*,u32);
-typedef void (*arg3_800FC948)(void*,u32,u32,u32,u32,u32,u32,u32,u32);
-typedef void (*arg3_800FCA18)(void*,u32);
+typedef void (*arg3_800FC8D8)(void*, u32);
+typedef void (*arg3_800FC948)(void*, u32, u32, u32, u32, u32, u32, u32, u32);
+typedef void (*arg3_800FCA18)(void*, u32);
 
-typedef struct InitFunc
-{
+typedef struct InitFunc {
     s32 nextOffset;
     void (*func)(void);
 } InitFunc;
 
-//.data
-void *sInitFuncs = NULL;
+// .data
+void* sInitFuncs = NULL;
 
-char sNew[4] =
-{
-    'n', 'e', 'w',
-};
+char sNew[4] = { 'n', 'e', 'w' };
 
-char D_80134488[0x18] =
-{
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x7F, 0x80, 0x00, 0x00, 0xFF, 0x80, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
+char D_80134488[0x18] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x80, 0x00, 0x00,
+    0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
 };
 
-s32 Overlay_Load(u32 vRomStart, u32 vRomEnd, void *vRamStart, void *vRamEnd, void *allocatedVRamAddr)
-{
+s32 Overlay_Load(u32 vRomStart, u32 vRomEnd, void* vRamStart, void* vRamEnd, void* allocatedVRamAddr) {
     u32 pad;
     u32 end;
     u32 bssSize;
-    OverlayRelocationSection *ovl;
+    OverlayRelocationSection* ovl;
     u32 relocCnt;
     u32 ovlOffset;
     u32 size;
 
-    if(gOverlayLogSeverity >= 3)
-    {
+    if (gOverlayLogSeverity >= 3) {
         // Start loading dynamic link function
         osSyncPrintf("\nダイナミックリンクファンクションのロードを開始します\n");
     }
 
-    if(gOverlayLogSeverity >= 3)
-    {
+    if (gOverlayLogSeverity >= 3) {
         size = vRomEnd - vRomStart;
-        //DMA transfer of TEXT, DATA, RODATA + rel (%08x-%08x)
-        osSyncPrintf("TEXT,DATA,RODATA+relをＤＭＡ転送します(%08x-%08x)\n", allocatedVRamAddr, (u32)allocatedVRamAddr + size);
+        // DMA transfer of TEXT, DATA, RODATA + rel (%08x-%08x)
+        osSyncPrintf("TEXT,DATA,RODATA+relをＤＭＡ転送します(%08x-%08x)\n", allocatedVRamAddr,
+                     (u32)allocatedVRamAddr + size);
     }
 
     size = vRomEnd - vRomStart;
@@ -56,13 +48,12 @@ s32 Overlay_Load(u32 vRomStart, u32 vRomEnd, void *vRamStart, void *vRamEnd, voi
     ovlOffset = ((s32*)end)[-1];
 
     ovl = (OverlayRelocationSection*)((u32)end - ovlOffset);
-    if(gOverlayLogSeverity >= 3)
-    {
-        osSyncPrintf("TEXT(%08x), DATA(%08x), RODATA(%08x), BSS(%08x)\n", ovl->textSize, ovl->dataSize, ovl->rodataSize, ovl->bssSize);
+    if (gOverlayLogSeverity >= 3) {
+        osSyncPrintf("TEXT(%08x), DATA(%08x), RODATA(%08x), BSS(%08x)\n", ovl->textSize, ovl->dataSize, ovl->rodataSize,
+                     ovl->bssSize);
     }
 
-    if(gOverlayLogSeverity >= 3)
-    {
+    if (gOverlayLogSeverity >= 3) {
         // Relocate
         osSyncPrintf("リロケーションします\n");
     }
@@ -70,10 +61,8 @@ s32 Overlay_Load(u32 vRomStart, u32 vRomEnd, void *vRamStart, void *vRamEnd, voi
     Overlay_DoRelocation(allocatedVRamAddr, ovl, vRamStart);
 
     bssSize = ovl->bssSize;
-    if(bssSize != 0)
-    {
-        if(gOverlayLogSeverity >= 3)
-        {
+    if (bssSize != 0) {
+        if (gOverlayLogSeverity >= 3) {
             // Clear BSS area (% 08x-% 08x)
             osSyncPrintf("BSS領域をクリアします(%08x-%08x)\n", end, end + ovl->bssSize);
         }
@@ -85,8 +74,7 @@ s32 Overlay_Load(u32 vRomStart, u32 vRomEnd, void *vRamStart, void *vRamEnd, voi
     }
 
     size = (u32)&ovl->relocations[ovl->nRelocations] - (u32)ovl;
-    if(gOverlayLogSeverity >= 3)
-    {
+    if (gOverlayLogSeverity >= 3) {
         // Clear REL area (%08x-%08x)
         osSyncPrintf("REL領域をクリアします(%08x-%08x)\n", ovl, (u32)ovl + size);
     }
@@ -97,8 +85,7 @@ s32 Overlay_Load(u32 vRomStart, u32 vRomEnd, void *vRamStart, void *vRamEnd, voi
     osWritebackDCache(allocatedVRamAddr, size);
     osInvalICache(allocatedVRamAddr, size);
 
-    if(gOverlayLogSeverity >= 3)
-    {
+    if (gOverlayLogSeverity >= 3) {
         // Finish loading dynamic link function
         osSyncPrintf("ダイナミックリンクファンクションのロードを終了します\n\n");
     }
@@ -106,10 +93,8 @@ s32 Overlay_Load(u32 vRomStart, u32 vRomEnd, void *vRamStart, void *vRamEnd, voi
 }
 
 // possibly some kind of new() function
-void *func_800FC800(u32 size)
-{
-    if (size == 0)
-    {
+void* func_800FC800(u32 size) {
+    if (size == 0) {
         size = 1;
     }
 
@@ -117,106 +102,87 @@ void *func_800FC800(u32 size)
 }
 
 // possible some kind of delete() function
-void func_800FC83C(void *ptr)
-{
-    if (ptr != NULL)
-    {
+void func_800FC83C(void* ptr) {
+    if (ptr != NULL) {
         __osFree(&gSystemArena, ptr);
     }
 }
 
-void func_800FC868(void *blk, u32 nBlk, u32 blkSize, arg3_800FC868 arg3)
-{
+void func_800FC868(void* blk, u32 nBlk, u32 blkSize, arg3_800FC868 arg3) {
     u32 pos;
 
-    for (pos = (u32)blk; pos < (u32)blk + (nBlk * blkSize); pos = (u32)pos + (blkSize & ~0))
-    {
+    for (pos = (u32)blk; pos < (u32)blk + (nBlk * blkSize); pos = (u32)pos + (blkSize & ~0)) {
         arg3((void*)pos);
     }
 }
 
-void func_800FC8D8(void *blk, u32 nBlk, s32 blkSize, arg3_800FC8D8 arg3)
-{
+void func_800FC8D8(void* blk, u32 nBlk, s32 blkSize, arg3_800FC8D8 arg3) {
     u32 pos;
 
-    for (pos = (u32)blk; pos < (u32)blk + (nBlk * blkSize); pos = (u32)pos + (blkSize & ~0))
-    {
+    for (pos = (u32)blk; pos < (u32)blk + (nBlk * blkSize); pos = (u32)pos + (blkSize & ~0)) {
         arg3((void*)pos, 2);
     }
 }
 
-void *func_800FC948(void *blk, u32 nBlk, u32 blkSize, arg3_800FC948 arg3)
-{
+void* func_800FC948(void* blk, u32 nBlk, u32 blkSize, arg3_800FC948 arg3) {
     u32 pos;
-    if (blk == NULL)
-    {
+    if (blk == NULL) {
         blk = func_800FC800(nBlk * blkSize);
     }
 
-    if (blk != NULL && arg3 != NULL)
-    {
+    if (blk != NULL && arg3 != NULL) {
         pos = (u32)blk;
-        while(pos < (u32)blk + (nBlk * blkSize))
-        {
+        while (pos < (u32)blk + (nBlk * blkSize)) {
             arg3((void*)pos, 0, 0, 0, 0, 0, 0, 0, 0);
             pos = (u32)pos + (blkSize & ~0);
         }
-
     }
     return blk;
 }
 
-void func_800FCA18(void *blk, u32 nBlk, u32 blkSize, arg3_800FCA18 arg3, s32 arg4)
-{
+void func_800FCA18(void* blk, u32 nBlk, u32 blkSize, arg3_800FCA18 arg3, s32 arg4) {
     u32 pos;
-    u32 end ;
+    u32 end;
     s32 masked_arg2;
 
-    if (blk == 0)
-    {
+    if (blk == 0) {
         return;
     }
-    if (arg3 != 0)
-    {
+    if (arg3 != 0) {
         end = (u32)blk;
         masked_arg2 = (s32)(blkSize & ~0);
         pos = (u32)end + (nBlk * blkSize);
 
-        if (masked_arg2) { }
+        if (masked_arg2) {}
 
-        while (pos > end)
-        {
+        while (pos > end) {
             do {
                 pos -= masked_arg2;
                 arg3((void*)pos, 2);
             } while (0);
         }
 
-        if (!masked_arg2){ }
+        if (!masked_arg2) {}
     }
 
-    if (arg4 != 0)
-    {
+    if (arg4 != 0) {
         func_800FC83C(blk);
     }
 }
 
-void func_800FCB34(void)
-{
-    InitFunc *initFunc;
+void func_800FCB34(void) {
+    InitFunc* initFunc;
     u32 nextOffset;
-    InitFunc *prev;
+    InitFunc* prev;
 
     initFunc = (InitFunc*)&sInitFuncs;
     nextOffset = initFunc->nextOffset;
     prev = NULL;
 
-    while(nextOffset != 0)
-    {
+    while (nextOffset != 0) {
         initFunc = (InitFunc*)((s32)initFunc + nextOffset);
 
-        if(initFunc->func != NULL)
-        {
+        if (initFunc->func != NULL) {
             (*initFunc->func)();
         }
 
@@ -228,8 +194,7 @@ void func_800FCB34(void)
     sInitFuncs = prev;
 }
 
-void SystemHeap_Init(void *start, u32 size)
-{
+void SystemHeap_Init(void* start, u32 size) {
     SystemArena_Init(start, size);
     func_800FCB34();
-}
\ No newline at end of file
+}
diff --git a/src/code/code_800FCE80.c b/src/code/code_800FCE80.c
new file mode 100644
index 000000000..5180c2444
--- /dev/null
+++ b/src/code/code_800FCE80.c
@@ -0,0 +1,161 @@
+#include <ultra64.h>
+#include <global.h>
+#include <fp.h>
+
+s32 use_cfrac;
+
+f32 Math_tanf(f32 x) {
+    f32 sin = sinf(x);
+    f32 cos = cosf(x);
+    return sin / cos;
+}
+
+f32 Math_floorf(f32 x) {
+    return floorf(x);
+}
+
+f32 Math_ceilf(f32 x) {
+    return ceilf(x);
+}
+
+f32 Math_roundf(f32 x) {
+    return roundf(x);
+}
+
+f32 Math_truncf(f32 x) {
+    return truncf(x);
+}
+
+f32 Math_nearbyintf(f32 x) {
+    return nearbyintf(x);
+}
+
+/* Arctangent approximation using a Taylor series (one quadrant) */
+f32 Math_atanf_taylor_q(f32 x) {
+    static const f32 coeffs[] = {
+        -1.f / 3, +1.f / 5, -1.f / 7, +1.f / 9, -1.f / 11, +1.f / 13, -1.f / 15, +1.f / 17, 0.f,
+    };
+
+    f32 poly = x;
+    f32 sq = SQ(x);
+    f32 exp = x * sq;
+    const f32* c = coeffs;
+    f32 term;
+
+    while (1) {
+        term = *c++ * exp;
+        if (poly + term == poly) {
+            break;
+        }
+        poly = poly + term;
+        exp = exp * sq;
+    }
+
+    return poly;
+}
+
+/* Ditto for two quadrants */
+f32 Math_atanf_taylor(f32 x) {
+    f32 t;
+    f32 q;
+
+    if (x > 0.f) {
+        t = x;
+    } else if (x < 0.f) {
+        t = -x;
+    } else if (x == 0.f) {
+        return 0.f;
+    } else {
+        return qNaN0x10000;
+    }
+
+    if (t <= M_SQRT2 - 1.f) {
+        return Math_atanf_taylor_q(x);
+    }
+
+    if (t >= M_SQRT2 + 1.f) {
+        q = M_PI / 2 - Math_atanf_taylor_q(1.f / t);
+    } else {
+        q = M_PI / 4 - Math_atanf_taylor_q((1.f - t) / (1.f + t));
+    }
+
+    if (x > 0.f) {
+        return q;
+    } else {
+        return -q;
+    }
+}
+
+/* Arctangent approximation using a continued fraction */
+f32 Math_atanf_cfrac(f32 x) {
+    s32 sector;
+    f32 z;
+    f32 conv;
+    f32 sq;
+    s32 i;
+
+    if (x >= -1.f && x <= 1.f) {
+        sector = 0;
+    } else if (x > 1.f) {
+        sector = 1;
+        x = 1.f / x;
+    } else if (x < -1.f) {
+        sector = -1;
+        x = 1.f / x;
+    } else {
+        return qNaN0x10000;
+    }
+
+    sq = SQ(x);
+    conv = 0.f;
+    z = 8.f;
+    for (i = 8; i != 0; i--) {
+        conv = SQ(z) * sq / (2.f * z + 1.f + conv);
+        z -= 1.f;
+    }
+    conv = x / (1.f + conv);
+
+    if (sector == 0) {
+        return conv;
+    } else if (sector > 0) {
+        return M_PI / 2 - conv;
+    } else {
+        return -M_PI / 2 - conv;
+    }
+}
+
+f32 Math_atanf(f32 x) {
+    if (use_cfrac == 0) {
+        return Math_atanf_taylor(x);
+    } else {
+        return Math_atanf_cfrac(x);
+    }
+}
+
+f32 Math_atan2f(f32 y, f32 x) {
+    if (x == 0.f) {
+        if (y == 0.f) {
+            return 0.f;
+        } else if (y > 0.f) {
+            return M_PI / 2;
+        } else if (y < 0.f) {
+            return -M_PI / 2;
+        } else {
+            return qNaN0x10000;
+        }
+    } else if (x >= 0.f) {
+        return Math_atanf(y / x);
+    } else if (y < 0.f) {
+        return Math_atanf(y / x) - M_PI;
+    } else {
+        return M_PI - Math_atanf(-(y / x));
+    }
+}
+
+f32 Math_asinf(f32 x) {
+    return Math_atan2f(x, sqrtf(1.f - SQ(x)));
+}
+
+f32 Math_acosf(f32 x) {
+    return M_PI / 2 - Math_asinf(x);
+}
diff --git a/src/code/db_camera.c b/src/code/db_camera.c
index e0580f6b7..b1e858e63 100644
--- a/src/code/db_camera.c
+++ b/src/code/db_camera.c
@@ -80,4 +80,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/db_camera/func_800B958C.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/db_camera/func_800B9638.s")
-
diff --git a/src/code/debug_malloc.c b/src/code/debug_malloc.c
index 6e63e1c4a..789e382af 100644
--- a/src/code/debug_malloc.c
+++ b/src/code/debug_malloc.c
@@ -1,131 +1,112 @@
 #include <global.h>
 
-#define LOG_SEVERITY_NOLOG          0
-#define LOG_SEVERITY_ERROR          2
-#define LOG_SEVERITY_VERBOSE        3
+#define LOG_SEVERITY_NOLOG 0
+#define LOG_SEVERITY_ERROR 2
+#define LOG_SEVERITY_VERBOSE 3
 
 s32 gDebugArenaLogSeverity = LOG_SEVERITY_ERROR;
 Arena sDebugArena;
 
-void DebugArena_CheckPointer(void* ptr, u32 size, const char* name, const char* action)
-{
-    if (!ptr)
-    {
-        if (gDebugArenaLogSeverity >= LOG_SEVERITY_ERROR)
-        {
+void DebugArena_CheckPointer(void* ptr, u32 size, const char* name, const char* action) {
+    if (!ptr) {
+        if (gDebugArenaLogSeverity >= LOG_SEVERITY_ERROR) {
             //"%s: %u bytes %s failed\n"
             osSyncPrintf("%s: %u バイトの%sに失敗しました\n", name, size, action);
-            __osDisplayArena(&sDebugArena);  
+            __osDisplayArena(&sDebugArena);
             return;
         }
-    }
-    else if (gDebugArenaLogSeverity >= LOG_SEVERITY_VERBOSE)
-    {
+    } else if (gDebugArenaLogSeverity >= LOG_SEVERITY_VERBOSE) {
         //"%s: %u bytes %s succeeded\n"
         osSyncPrintf("%s: %u バイトの%sに成功しました\n", name, size, action);
     }
 }
 
-void* DebugArena_Malloc(u32 size)
-{
+void* DebugArena_Malloc(u32 size) {
     void* ptr;
     ptr = __osMalloc(&sDebugArena, size);
-    DebugArena_CheckPointer(ptr, size, "debug_malloc", "確保"); //Secure
+    DebugArena_CheckPointer(ptr, size, "debug_malloc", "確保"); // Secure
     return ptr;
 }
 
-void* DebugArena_MallocDebug(u32 size, const char* file, s32 line)
-{
+void* DebugArena_MallocDebug(u32 size, const char* file, s32 line) {
     void* ptr;
     ptr = __osMallocDebug(&sDebugArena, size, file, line);
-    DebugArena_CheckPointer(ptr, size, "debug_malloc_DEBUG", "確保"); //Secure
+    DebugArena_CheckPointer(ptr, size, "debug_malloc_DEBUG", "確保"); // Secure
     return ptr;
 }
 
-void* DebugArena_MallocR(u32 size)
-{
+void* DebugArena_MallocR(u32 size) {
     void* ptr;
     ptr = __osMallocR(&sDebugArena, size);
-    DebugArena_CheckPointer(ptr, size, "debug_malloc_r", "確保"); //Secure
+    DebugArena_CheckPointer(ptr, size, "debug_malloc_r", "確保"); // Secure
     return ptr;
 }
 
-void* DebugArena_MallocRDebug(u32 size, const char* file, s32 line)
-{
+void* DebugArena_MallocRDebug(u32 size, const char* file, s32 line) {
     void* ptr;
     ptr = __osMallocRDebug(&sDebugArena, size, file, line);
-    DebugArena_CheckPointer(ptr, size, "debug_malloc_r_DEBUG", "確保"); //Secure
+    DebugArena_CheckPointer(ptr, size, "debug_malloc_r_DEBUG", "確保"); // Secure
     return ptr;
 }
 
-void* DebugArena_Realloc(void* ptr, u32 newSize)
-{
+void* DebugArena_Realloc(void* ptr, u32 newSize) {
     ptr = __osRealloc(&sDebugArena, ptr, newSize);
     DebugArena_CheckPointer(ptr, newSize, "debug_realloc", "再確保"); // Re-securing
     return ptr;
 }
 
-void* DebugArena_ReallocDebug(void* ptr, u32 newSize, const char* file, s32 line)
-{
+void* DebugArena_ReallocDebug(void* ptr, u32 newSize, const char* file, s32 line) {
     ptr = __osReallocDebug(&sDebugArena, ptr, newSize, file, line);
     DebugArena_CheckPointer(ptr, newSize, "debug_realloc_DEBUG", "再確保"); // Re-securing
     return ptr;
 }
 
-void DebugArena_Free(void* ptr)
-{
+void DebugArena_Free(void* ptr) {
     __osFree(&sDebugArena, ptr);
 }
 
-void DebugArena_FreeDebug(void* ptr, const char* file, s32 line)
-{
+void DebugArena_FreeDebug(void* ptr, const char* file, s32 line) {
     __osFreeDebug(&sDebugArena, ptr, file, line);
 }
 
-void* DebugArena_Calloc(u32 num, u32 size)
-{
+void* DebugArena_Calloc(u32 num, u32 size) {
     void* ret;
     u32 n;
-    
-    n = num*size;
+
+    n = num * size;
     ret = __osMalloc(&sDebugArena, n);
-    if (ret)
+    if (ret) {
         bzero(ret, n);
+    }
 
     DebugArena_CheckPointer(ret, n, "debug_calloc", "確保");
     return ret;
 }
 
-void DebugArena_Display()
-{
-    //Zelda heap display (devs forgot to change "Zelda" to "Debug" apparently)
+void DebugArena_Display() {
+    // Zelda heap display (devs forgot to change "Zelda" to "Debug" apparently)
     osSyncPrintf("ゼルダヒープ表示\n");
     __osDisplayArena(&sDebugArena);
 }
 
-void DebugArena_GetSizes(u32* outMaxFree, u32* outFree, u32* outAlloc)
-{
+void DebugArena_GetSizes(u32* outMaxFree, u32* outFree, u32* outAlloc) {
     ArenaImpl_GetSizes(&sDebugArena, outMaxFree, outFree, outAlloc);
 }
 
-void DebugArena_Check()
-{
+void DebugArena_Check() {
     __osCheckArena(&sDebugArena);
 }
 
-void DebugArena_Init(void* start, u32 size)
-{
+void DebugArena_Init(void* start, u32 size) {
     gDebugArenaLogSeverity = LOG_SEVERITY_NOLOG;
     __osMallocInit(&sDebugArena, start, size);
 }
 
-void DebugArena_Cleanup()
-{
+void DebugArena_Cleanup() {
     gDebugArenaLogSeverity = LOG_SEVERITY_NOLOG;
     __osMallocCleanup(&sDebugArena);
 }
 
-u8 DebugArena_IsInitalized()
-{
+u8 DebugArena_IsInitalized() {
     return __osMallocIsInitalized(&sDebugArena);
 }
diff --git a/src/code/fault.c b/src/code/fault.c
index 528d8beaf..05bee87d5 100644
--- a/src/code/fault.c
+++ b/src/code/fault.c
@@ -1,10 +1,10 @@
 #include <ultra64.h>
 #include <global.h>
+#include <alloca.h>
 #include <vt.h>
 
-//data
-const char* sExceptionNames[] =
-{
+// data
+const char* sExceptionNames[] = {
     "Interrupt",
     "TLB modification",
     "TLB exception on load",
@@ -31,7 +31,7 @@ const char* sExceptionNames[] =
     "Inexact operation",
 };
 
-//bss
+// bss
 FaultThreadStruct* sFaultStructPtr;
 u8 sFaultIsWaitingForInput;
 char sFaultStack[0x600];
@@ -40,76 +40,67 @@ FaultThreadStruct gFaultStruct;
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/fault/pad_800D3F10.s")
 
-void Fault_SleepImpl(u32 duration)
-{
+void Fault_SleepImpl(u32 duration) {
     u64 value = (duration * OS_CPU_COUNTER) / 1000ull;
     func_800FF3A0(value);
 }
 
-void Fault_ClientProcessThread(FaultClientContext* ctx)
-{
-    if (ctx->callback)
+void Fault_ClientProcessThread(FaultClientContext* ctx) {
+    if (ctx->callback) {
         ctx->ret = ctx->callback(ctx->param0, ctx->param1);
+    }
 
-    if (ctx->queue)
+    if (ctx->queue) {
         osSendMesg(ctx->queue, ctx->msg, 1);
+    }
 }
 
-#ifdef NON_MATCHING
-void Fault_ProcessClientContext(FaultClientContext* ctx)
-{
+void Fault_ProcessClientContext(FaultClientContext* ctx) {
     OSMesgQueue queue;
     OSMesg msg;
-    OSThread* t;
-    OSTimer timer;
     OSMesg recMsg;
+    OSThread* thread;
+    OSTimer timer;
+    u32 timerMsgVal;
+
+    timerMsgVal = 666;
+    thread = NULL;
 
     osCreateMesgQueue(&queue, &msg, 1);
     ctx->queue = &queue;
     ctx->msg = NULL;
-    if (sFaultStructPtr->currClientThreadSp)
-    {
+
+    if (sFaultStructPtr->currClientThreadSp != 0) {
+        thread = alloca(sizeof(OSThread));
+        osCreateThread(thread, 2, Fault_ClientProcessThread, ctx, sFaultStructPtr->currClientThreadSp, 0x7E);
+        osStartThread(thread);
+    } else {
         Fault_ClientProcessThread(ctx);
-        t = NULL;
-    }
-    else
-    {
-        OSThread thread;
-        osCreateThread(&thread, 2, &Fault_ClientProcessThread, ctx, sFaultStructPtr->currClientThreadSp, 0x7E);
-        osStartThread(&thread);
-        t = &thread;
     }
 
-    while(true)
-    {
-        osSetTimer(&timer, OS_USEC_TO_CYCLES(1000000), 0, &queue, (OSMesg)0x29A);
+    while (true) {
+        osSetTimer(&timer, OS_USEC_TO_CYCLES(1000000), 0, &queue, (OSMesg)timerMsgVal);
         osRecvMesg(&queue, &recMsg, 1);
 
-        if (recMsg == (OSMesg)0x29A)
+        if (recMsg != (OSMesg)666) {
             break;
+        }
 
-        if (sFaultIsWaitingForInput)
-        {
+        if (!sFaultIsWaitingForInput) {
             ctx->ret = -1;
             break;
         }
     }
 
     osStopTimer(&timer);
-    if (t)
-    {
-        osStopThread(t);
-        //osDestroyThread(t);
-        osDestroyThread(t);
+
+    if (thread != NULL) {
+        osStopThread(thread);
+        osDestroyThread(thread);
     }
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/fault/Fault_ProcessClientContext.s")
-#endif
-
 
-u32 Fault_ProcessClient(u32 callback, u32 param0, u32 param1)
-{
+u32 Fault_ProcessClient(u32 callback, u32 param0, u32 param1) {
     FaultClientContext a;
     a.callback = callback;
     a.param0 = param0;
@@ -120,16 +111,19 @@ u32 Fault_ProcessClient(u32 callback, u32 param0, u32 param1)
 }
 
 #ifdef NON_MATCHING
-void Fault_AddClient(FaultClient *client, void* callback, void* param0, void* param1)
-{
-    bool alreadyExist = false;
-    OSIntMask mask = osSetIntMask(1);
-    FaultClient* iter = sFaultStructPtr->clients;
-    while (iter)
-    {
-        if (iter == client)
-        {
-            alreadyExist = true;
+// minor ordering differences
+void Fault_AddClient(FaultClient* client, void* callback, void* param0, void* param1) {
+    OSIntMask mask;
+    u32 alreadyExists;
+    FaultClient* iter;
+
+    alreadyExists = false;
+    mask = osSetIntMask(1);
+
+    iter = sFaultStructPtr->clients;
+    while (iter) {
+        if (iter == client) {
+            alreadyExists = true;
             goto end;
         }
         iter = iter->next;
@@ -143,8 +137,9 @@ void Fault_AddClient(FaultClient *client, void* callback, void* param0, void* pa
 
 end:
     osSetIntMask(mask);
-    if (alreadyExist)
+    if (alreadyExists) {
         osSyncPrintf(VT_COL(RED, WHITE) "fault_AddClient: %08x は既にリスト中にある\n" VT_RST, client);
+    }
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/fault/Fault_AddClient.s")
@@ -183,11 +178,11 @@ void Fault_RemoveClient(FaultClient* client) {
 
     osSetIntMask(mask);
 
-    if (listIsEmpty)
+    if (listIsEmpty) {
         osSyncPrintf(VT_COL(RED, WHITE) "fault_RemoveClient: %08x リスト不整合です\n" VT_RST, client);
+    }
 }
 
-
 #pragma GLOBAL_ASM("asm/non_matchings/code/fault/Fault_AddAddrConvClient.s")
 
 void Fault_RemoveAddrConvClient(FaultAddrConvClient* client) {
@@ -224,24 +219,23 @@ void Fault_RemoveAddrConvClient(FaultAddrConvClient* client) {
     osSetIntMask(mask);
 
     if (listIsEmpty) {
-        osSyncPrintf(VT_COL(RED, WHITE) "fault_AddressConverterRemoveClient: %08x は既にリスト中にある\n" VT_RST, client);
+        osSyncPrintf(VT_COL(RED, WHITE) "fault_AddressConverterRemoveClient: %08x は既にリスト中にある\n" VT_RST,
+                     client);
     }
 }
 
-u32 Fault_ConvertAddress(FaultAddrConvClient* client)
-{
+u32 Fault_ConvertAddress(FaultAddrConvClient* client) {
     u32 ret;
     FaultAddrConvClient* iter = sFaultStructPtr->addrConvClients;
 
-    while(iter)
-    {
-        if (iter->callback)
-        {
+    while (iter) {
+        if (iter->callback) {
             ret = Fault_ProcessClient(iter->callback, client, iter->param);
-            if (ret == -1)
+            if (ret == -1) {
                 Fault_RemoveAddrConvClient(iter);
-            else if (ret)
+            } else if (ret) {
                 return ret;
+            }
         }
         iter = iter->next;
     }
@@ -249,131 +243,127 @@ u32 Fault_ConvertAddress(FaultAddrConvClient* client)
     return 0;
 }
 
-void Fault_Sleep(u32 duration)
-{
+void Fault_Sleep(u32 duration) {
     Fault_SleepImpl(duration);
 }
 
-void Fault_PadCallback(Input* input)
-{
-    //BUG: this function is not called correctly and thus will crash from reading a bad pointer at 0x800C7E4C
+void Fault_PadCallback(Input* input) {
+    // BUG: this function is not called correctly and thus will crash from reading a bad pointer at 0x800C7E4C
     func_800C7E08(input, 0);
 }
 
-void Fault_UpdatePadImpl()
-{
+void Fault_UpdatePadImpl() {
     sFaultStructPtr->padCallback(&sFaultStructPtr->padInput);
 }
 
 #ifdef NON_MATCHING
-bool Fault_WaitForInputImpl()
-{
+// ordering differences and possibly regalloc
+u32 Fault_WaitForInputImpl() {
     u16 kDown;
-    bool exitDebugger;
-
+    u32 exitDebugger;
     s32 count = 600;
     Input* curInput = &sFaultStructPtr->padInput;
-    while (true)
-    {
-        while (true)
-        {
+
+    while (true) {
+        while (true) {
             Fault_Sleep(0x10);
             Fault_UpdatePadImpl();
+
             kDown = curInput->padPressed;
-            if (kDown == 0x20)
+
+            if (kDown == 0x20) {
                 sFaultStructPtr->faultActive = !sFaultStructPtr->faultActive;
+            }
 
-            if (!sFaultStructPtr->faultActive)
+            if (!sFaultStructPtr->faultActive) {
                 break;
+            }
 
-            if (count-- < 1)
+            if (count-- < 1) {
                 return false;
+            }
         }
 
-        if (kDown == 0x8000 || kDown == 0x100)
-            break;
-        if (kDown == 0x200)
+        if (kDown == 0x8000 || kDown == 0x100) {
+            return false;
+        }
+
+        if (kDown == 0x200) {
             return true;
-        if (kDown == 0x800)
+        }
+
+        if (kDown == 0x800) {
             FaultDrawer_SetOsSyncPrintfEnabled(true);
-        if (kDown == 0x400)
+        }
+
+        if (kDown == 0x400) {
             FaultDrawer_SetOsSyncPrintfEnabled(false);
+        }
     }
+
     return false;
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/fault/Fault_WaitForInputImpl.s")
 #endif
 
-void Fault_WaitForInput()
-{
+void Fault_WaitForInput() {
     sFaultIsWaitingForInput = 1;
     Fault_WaitForInputImpl();
     sFaultIsWaitingForInput = 0;
 }
 
-void Fault_DrawRec(s32 x, s32 y, s32 w, s32 h, u16 color)
-{
+void Fault_DrawRec(s32 x, s32 y, s32 w, s32 h, u16 color) {
     FaultDrawer_DrawRecImpl(x, y, x + w - 1, y + h - 1, color);
 }
 
-void Fault_FillScreenBlack()
-{
+void Fault_FillScreenBlack() {
     FaultDrawer_SetForeColor(0xFFFF);
     FaultDrawer_SetBackColor(1);
     FaultDrawer_FillScreen();
     FaultDrawer_SetBackColor(0);
 }
 
-void Fault_FillScreenRed()
-{
+void Fault_FillScreenRed() {
     FaultDrawer_SetForeColor(0xFFFF);
     FaultDrawer_SetBackColor(0xF001);
     FaultDrawer_FillScreen();
     FaultDrawer_SetBackColor(0);
 }
 
-void Fault_DrawCornerRec(u16 color)
-{
+void Fault_DrawCornerRec(u16 color) {
     Fault_DrawRec(0x16, 0x10, 8, 1, color);
 }
 
-void Fault_PrintFReg(s32 idx, f32 *value)
-{
+void Fault_PrintFReg(s32 idx, f32* value) {
     u32 raw = *(u32*)value;
-    int v0 = ((raw & 0x7f800000) >> 0x17) - 0x7f;
+    s32 v0 = ((raw & 0x7f800000) >> 0x17) - 0x7f;
 
-    if ((v0 >= -0x7e && v0 < 0x80) || raw == 0)
+    if ((v0 >= -0x7e && v0 < 0x80) || raw == 0) {
         FaultDrawer_Printf("F%02d:%14.7e ", idx, *value);
-    else
+    } else {
         FaultDrawer_Printf("F%02d:  %08x(16) ", idx, raw);
+    }
 }
 
-#ifdef NON_MATCHING
-void Fault_LogFReg(s32 idx, f32 *value)
-{
+void Fault_LogFReg(s32 idx, f32* value) {
     u32 raw = *(u32*)value;
     s32 v0 = ((raw & 0x7f800000) >> 0x17) - 0x7f;
 
-    if ((v0 >= -0x7e && v0 < 0x80) || raw == 0)
+    if ((v0 >= -0x7e && v0 < 0x80) || raw == 0) {
         osSyncPrintf("F%02d:%14.7e ", idx, *value);
-    else
-        osSyncPrintf("F%02d:  %08x(16) ", idx, raw);
+    } else {
+        osSyncPrintf("F%02d:  %08x(16) ", idx, *(u32*)value);
+    }
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/fault/Fault_LogFReg.s")
-#endif
 
-void Fault_PrintFPCR(u32 value)
-{
+void Fault_PrintFPCR(u32 value) {
     s32 i;
     u32 flag = 0x20000;
     FaultDrawer_Printf("FPCSR:%08xH ", value);
-    for (i = 0; i < 6; i++)
-    {
-        if (value & flag)
-        {
-            FaultDrawer_Printf("(%s)", sExceptionNames[i+18]);
+    for (i = 0; i < 6; i++) {
+        if (value & flag) {
+            FaultDrawer_Printf("(%s)", sExceptionNames[i + 18]);
             break;
         }
         flag >>= 1;
@@ -381,30 +371,28 @@ void Fault_PrintFPCR(u32 value)
     FaultDrawer_Printf("\n");
 }
 
-void Fault_LogFPCR(u32 value)
-{
+void Fault_LogFPCR(u32 value) {
     s32 i;
     u32 flag = 0x20000;
     osSyncPrintf("FPCSR:%08xH  ", value);
-    for (i = 0; i < 6; i++)
-    {
-        if (value & flag)
-        {
-            osSyncPrintf("(%s)\n", sExceptionNames[i+18]);
+    for (i = 0; i < 6; i++) {
+        if (value & flag) {
+            osSyncPrintf("(%s)\n", sExceptionNames[i + 18]);
             break;
         }
         flag >>= 1;
     }
 }
 
-void Fault_PrintThreadContext(OSThread* t)
-{
-    __OSThreadContext *ctx;
-    s32 causeStrIdx = (s32) ((((u32) t->context.cause >> 2) & 0x1f) << 0x10) >> 0x10;
-    if (causeStrIdx == 0x17)
+void Fault_PrintThreadContext(OSThread* t) {
+    __OSThreadContext* ctx;
+    s32 causeStrIdx = (s32)((((u32)t->context.cause >> 2) & 0x1f) << 0x10) >> 0x10;
+    if (causeStrIdx == 0x17) {
         causeStrIdx = 0x10;
-    if (causeStrIdx == 0x1f)
+    }
+    if (causeStrIdx == 0x1f) {
         causeStrIdx = 0x11;
+    }
 
     FaultDrawer_FillScreen();
     FaultDrawer_SetCharPad(-2, 4);
@@ -455,14 +443,15 @@ void Fault_PrintThreadContext(OSThread* t)
     FaultDrawer_SetCharPad(0, 0);
 }
 
-void Fault_LogThreadContext(OSThread* t)
-{
-    __OSThreadContext *ctx;
-    s32 causeStrIdx = (s32) ((((u32) t->context.cause >> 2) & 0x1f) << 0x10) >> 0x10;
-    if (causeStrIdx == 0x17)
+void Fault_LogThreadContext(OSThread* t) {
+    __OSThreadContext* ctx;
+    s32 causeStrIdx = (s32)((((u32)t->context.cause >> 2) & 0x1f) << 0x10) >> 0x10;
+    if (causeStrIdx == 0x17) {
         causeStrIdx = 0x10;
-    if (causeStrIdx == 0x1f)
+    }
+    if (causeStrIdx == 0x1f) {
         causeStrIdx = 0x11;
+    }
 
     ctx = &t->context;
     osSyncPrintf("\n");
@@ -508,26 +497,23 @@ void Fault_LogThreadContext(OSThread* t)
     osSyncPrintf("\n");
 }
 
-OSThread* Fault_FindFaultedThread()
-{
+OSThread* Fault_FindFaultedThread() {
     OSThread* iter = func_80104140();
-    while (iter->priority != -1)
-    {
-        if (iter->priority > 0 && iter->priority < 0x7f && (iter->flags & 3))
+    while (iter->priority != -1) {
+        if (iter->priority > 0 && iter->priority < 0x7f && (iter->flags & 3)) {
             return iter;
+        }
         iter = iter->tlnext;
     }
     return NULL;
 }
 
-void Fault_Wait5Seconds(void)
-{
-    OSTime start[2]; //to make the function allocate 0x28 bytes of stack instead of 0x20
+void Fault_Wait5Seconds(void) {
+    OSTime start[2]; // to make the function allocate 0x28 bytes of stack instead of 0x20
     start[0] = osGetTime();
-    do
-    {
+    do {
         Fault_Sleep(0x10);
-    } while ((osGetTime() - start[0]) < OS_USEC_TO_CYCLES(5000000)+1); //0xdf84759
+    } while ((osGetTime() - start[0]) < OS_USEC_TO_CYCLES(5000000) + 1); // 0xdf84759
 
     sFaultStructPtr->faultActive = true;
 }
@@ -554,7 +540,7 @@ void Fault_DrawMemDumpPage(const char* title, u32* addr, u32 param_3) {
     Fault_FillScreenBlack();
     FaultDrawer_SetCharPad(-2, 0);
 
-    FaultDrawer_DrawText(0x24, 0x12, "%s %08x", title? title : "PrintDump", alignedAddr);
+    FaultDrawer_DrawText(0x24, 0x12, "%s %08x", title ? title : "PrintDump", alignedAddr);
     if (alignedAddr >= (u32*)0x80000000 && alignedAddr < (u32*)0xC0000000) {
         for (y = 0x1C; y != 0xE2; y += 9) {
             FaultDrawer_DrawText(0x18, y, "%06x", writeAddr);
@@ -567,65 +553,83 @@ void Fault_DrawMemDumpPage(const char* title, u32* addr, u32 param_3) {
     FaultDrawer_SetCharPad(0, 0);
 }
 
-
 #ifdef NON_MATCHING
-void Fault_DrawMemDump(u32 pc, u32 sp, u32 unk0, u32 unk1)
-{
+// saved register and stack usage differences
+// possibly some minor ordering and regalloc differences
+void Fault_DrawMemDump(u32 pc, u32 sp, u32 unk0, u32 unk1) {
+    Input* curInput = &sFaultStructPtr->padInput;
+    u32 addr = pc;
     s32 count;
-    u16 held;
     s32 off;
-    u32 addr = pc;
-    while (true)
-    {
-        if (addr < 0x80000000)
+
+    while (true) {
+        if (addr < 0x80000000) {
             addr = 0x80000000;
-        if (addr > 0x807fff00)
+        }
+        if (addr > 0x807fff00) {
             addr = 0x807fff00;
+        }
 
         addr &= ~0xF;
-        Fault_DrawMemDumpPage("Dump", (u32*)addr);
+        Fault_DrawMemDumpPage("Dump", (u32*)addr, 0);
         count = 600;
-        while (sFaultStructPtr->faultActive)
-        {
-            if (count-- == 0)
+
+        while (sFaultStructPtr->faultActive) {
+            if (count == 0) {
                 return;
+            }
+
+            count--;
             Fault_Sleep(0x10);
             Fault_UpdatePadImpl();
-            if ((sFaultStructPtr->padInput.padPressed | ~0x20) == ~0x20)
+            if (!~(curInput->padPressed | ~0x20)) {
                 sFaultStructPtr->faultActive = false;
+            }
         }
-        do
-        {
+
+        do {
             Fault_Sleep(0x10);
             Fault_UpdatePadImpl();
-        } while (sFaultStructPtr->padInput.padPressed == 0);
+        } while (curInput->padPressed == 0);
 
-        if ((sFaultStructPtr->padInput.padPressed | ~0x1000) == ~0)
+        if (!~(curInput->padPressed | ~0x1000)) {
             return;
-        held = sFaultStructPtr->padInput.status;
-        if ((held | ~0x8000) == ~0)
+        }
+
+        if (!~(curInput->raw.pad | ~0x8000)) {
             return;
+        }
 
         off = 0x10;
-        if ((held | ~0x2000) == ~0)
+        if (!~(curInput->raw.pad | ~0x2000)) {
             off = 0x100;
-        if ((held | ~0x4000) == ~0)
+        }
+        if (!~(curInput->raw.pad | ~0x4000)) {
             off <<= 8;
-        if ((held | ~0x800) == ~0)
-            addr -= off;
-        if ((held | ~0x400) == ~0)
+        }
+        if (!~(curInput->raw.pad | ~0x800)) {
             addr -= off;
-        if ((held | ~0x8) == ~0)
+        }
+        if (!~(curInput->raw.pad | ~0x400)) {
+            addr += off;
+        }
+        if (!~(curInput->raw.pad | ~0x8)) {
             addr = pc;
-        if ((held | ~0x4) == ~0)
+        }
+        if (!~(curInput->raw.pad | ~0x4)) {
             addr = sp;
-        if ((held | ~0x2) == ~0)
+        }
+        if (!~(curInput->raw.pad | ~0x2)) {
             addr = unk0;
-        if ((held | ~0x1) == ~0)
+        }
+        if (!~(curInput->raw.pad | ~0x1)) {
             addr = unk1;
-        if ((held | ~0x20) == ~0)
+        }
+        if (!~(curInput->raw.pad | ~0x20)) {
             break;
+        }
     }
+
     sFaultStructPtr->faultActive = true;
 }
 #else
@@ -638,8 +642,7 @@ void Fault_DrawMemDump(u32 pc, u32 sp, u32 unk0, u32 unk1)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/fault/Fault_LogStackTrace.s")
 
-void Fault_ResumeThread(OSThread* t)
-{
+void Fault_ResumeThread(OSThread* t) {
     t->context.cause = 0;
     t->context.fpcsr = 0;
     t->context.pc += 4;
@@ -649,38 +652,39 @@ void Fault_ResumeThread(OSThread* t)
     osStartThread(t);
 }
 
-void Fault_CommitFB()
-{
+void Fault_CommitFB() {
     u16* fb;
     osViSetYScale(1.0f);
     osViSetMode(&osViModeNtscLan1);
-    osViSetSpecialFeatures(0x42); //gama_disable|dither_fliter_enable_aa_mode3_disable
+    osViSetSpecialFeatures(0x42); // gama_disable|dither_fliter_enable_aa_mode3_disable
     osViBlack(false);
 
-    if (sFaultStructPtr->fb)
+    if (sFaultStructPtr->fb) {
         fb = sFaultStructPtr->fb;
-    else
-    {
+    } else {
         fb = (u16*)osViGetNextFramebuffer();
-        if ((u32)fb == 0x80000000)
+        if ((u32)fb == 0x80000000) {
             fb = (u16*)((osMemSize | 0x80000000) - 0x25800);
+        }
     }
 
     osViSwapBuffer(fb);
     FaultDrawer_SetDrawerFB(fb, 0x140, 0xf0);
 }
 
-void Fault_ProcessClients(void)
-{
+void Fault_ProcessClients(void) {
     FaultClient* iter = sFaultStructPtr->clients;
     s32 idx = 0;
-    while(iter)
-    {
-        if (iter->callback)
-        {
+
+    while (iter) {
+        if (iter->callback) {
             Fault_FillScreenBlack();
             FaultDrawer_SetCharPad(-2, 0);
-            FaultDrawer_Printf("\x1a""8CallBack (%d) %08x %08x %08x\n""\x1a""7", idx++, iter, iter->param1, iter->param2);
+            FaultDrawer_Printf("\x1a"
+                               "8CallBack (%d) %08x %08x %08x\n"
+                               "\x1a"
+                               "7",
+                               idx++, iter, iter->param1, iter->param2);
             FaultDrawer_SetCharPad(0, 0);
             Fault_ProcessClient(iter->callback, iter->param1, iter->param2);
             Fault_WaitForInput();
@@ -690,71 +694,60 @@ void Fault_ProcessClients(void)
     }
 }
 
-void Fault_UpdatePad()
-{
+void Fault_UpdatePad() {
     Fault_UpdatePadImpl();
 }
 
 #ifdef NON_MATCHING
-
-void Fault_ThreadEntry(u32 unused)
-{
-    OSThread *faultedThread;
+// saved register and stack usage differences
+void Fault_ThreadEntry(void* arg) {
+    OSThread* faultedThread;
     OSMesg msg;
 
-    //osSetEventMesg
     osSetEventMesg(OS_EVENT_CPU_BREAK, &sFaultStructPtr->queue, 1);
     osSetEventMesg(OS_EVENT_FAULT, &sFaultStructPtr->queue, 2);
-    while (true)
-    {
-        osRecvMesg(&sFaultStructPtr->queue, &msg, 1);
 
-        if (msg == (OSMesg)1)
-        {
-            sFaultStructPtr->msgId = 1;
-            osSyncPrintf("フォルトマネージャ:OS_EVENT_CPU_BREAKを受信しました\n");
-        }
-        else if (msg == (OSMesg)2)
-        {
-            sFaultStructPtr->msgId = 2;
-            osSyncPrintf("フォルトマネージャ:OS_EVENT_FAULTを受信しました\n");
-        }
-        else if (msg != (OSMesg)3)
-        {
-            sFaultStructPtr->msgId = (u8)3;
-            osSyncPrintf("フォルトマネージャ:不明なメッセージを受信しました\n");
-        }
+    while (true) {
+        do {
+            osRecvMesg(&sFaultStructPtr->queue, &msg, 1);
+
+            if (msg == (OSMesg)1) {
+                sFaultStructPtr->msgId = 1;
+                osSyncPrintf("フォルトマネージャ:OS_EVENT_CPU_BREAKを受信しました\n");
+            } else if (1 && msg == (OSMesg)2) {
+                sFaultStructPtr->msgId = 2;
+                osSyncPrintf("フォルトマネージャ:OS_EVENT_FAULTを受信しました\n");
+            } else if (msg == (OSMesg)3) {
+                Fault_UpdatePad();
+                faultedThread = NULL;
+                continue;
+            } else {
+                sFaultStructPtr->msgId = 3;
+                osSyncPrintf("フォルトマネージャ:不明なメッセージを受信しました\n");
+            }
 
-        if (msg == (OSMesg)3)
-        {
-            Fault_UpdatePad();
-            faultedThread = NULL;
-        }
-        else
-        {
             faultedThread = __osGetCurrFaultedThread();
             osSyncPrintf("__osGetCurrFaultedThread()=%08x\n", faultedThread);
-            if (!faultedThread)
-            {
+
+            if (faultedThread == NULL) {
                 faultedThread = Fault_FindFaultedThread();
                 osSyncPrintf("FindFaultedThread()=%08x\n", faultedThread);
             }
-        }
-
-        if (!faultedThread)
-            continue;
+        } while (faultedThread == NULL);
 
         __osSetFpcCsr(__osGetFpcCsr() & -0xf81);
         sFaultStructPtr->faultedThread = faultedThread;
-        while (!sFaultStructPtr->faultHandlerEnabled)
+
+        while (!sFaultStructPtr->faultHandlerEnabled) {
             Fault_Sleep(1000);
+        }
+
         Fault_Sleep(500);
         Fault_CommitFB();
 
-        if (sFaultStructPtr->faultActive)
+        if (sFaultStructPtr->faultActive) {
             Fault_Wait5Seconds();
-        else
-        {
+        } else {
             Fault_DrawCornerRec(0xF801);
             Fault_WaitForButtonCombo();
         }
@@ -763,8 +756,7 @@ void Fault_ThreadEntry(u32 unused)
         FaultDrawer_SetForeColor(0xFFFF);
         FaultDrawer_SetBackColor(0);
 
-        do
-        {
+        do {
             Fault_PrintThreadContext(faultedThread);
             Fault_LogThreadContext(faultedThread);
             Fault_WaitForInput();
@@ -781,10 +773,9 @@ void Fault_ThreadEntry(u32 unused)
             FaultDrawer_DrawText(0x40, 0x64, "       THANK YOU!       ");
             FaultDrawer_DrawText(0x40, 0x6E, " You are great debugger!");
             Fault_WaitForInput();
-
         } while (!sFaultStructPtr->exitDebugger);
 
-        while(!sFaultStructPtr->exitDebugger){}
+        while (!sFaultStructPtr->exitDebugger) {}
 
         Fault_ResumeThread(faultedThread);
     }
@@ -793,14 +784,12 @@ void Fault_ThreadEntry(u32 unused)
 #pragma GLOBAL_ASM("asm/non_matchings/code/fault/Fault_ThreadEntry.s")
 #endif
 
-void Fault_SetFB(void* fb, u16 w, u16 h)
-{
+void Fault_SetFB(void* fb, u16 w, u16 h) {
     sFaultStructPtr->fb = fb;
     FaultDrawer_SetDrawerFB(fb, w, h);
 }
 
-void Fault_Start(void)
-{
+void Fault_Start(void) {
     sFaultStructPtr = &gFaultStruct;
     bzero(sFaultStructPtr, sizeof(FaultThreadStruct));
     FaultDrawer_SetDefault();
@@ -814,13 +803,12 @@ void Fault_Start(void)
     sFaultStructPtr->faultActive = false;
     gFaultStruct.faultHandlerEnabled = true;
     osCreateMesgQueue(&sFaultStructPtr->queue, &sFaultStructPtr->msg, 1);
-    StackCheck_Init(sFaultThreadInfo, &sFaultStack, sFaultStack+sizeof(sFaultStack), 0, 0x100, "fault");
+    StackCheck_Init(sFaultThreadInfo, &sFaultStack, sFaultStack + sizeof(sFaultStack), 0, 0x100, "fault");
     osCreateThread(&sFaultStructPtr->thread, 2, &Fault_ThreadEntry, 0, sFaultThreadInfo, 0x7f);
     osStartThread(&sFaultStructPtr->thread);
 }
 
-void Fault_HangupFaultClient(const char* arg0, const char* arg1)
-{
+void Fault_HangupFaultClient(const char* arg0, const char* arg1) {
     osSyncPrintf("HungUp on Thread %d\n", osGetThreadId(0));
     osSyncPrintf("%s\n", arg0 ? arg0 : "(NULL)");
     osSyncPrintf("%s\n", arg1 ? arg1 : "(NULL)");
@@ -829,16 +817,14 @@ void Fault_HangupFaultClient(const char* arg0, const char* arg1)
     FaultDrawer_Printf("%s\n", arg1 ? arg1 : "(NULL)");
 }
 
-void Fault_AddHungupAndCrashImpl(const char* arg0, const char* arg1)
-{
+void Fault_AddHungupAndCrashImpl(const char* arg0, const char* arg1) {
     FaultClient client;
     char padd[4];
     Fault_AddClient(&client, &Fault_HangupFaultClient, arg0, arg1);
-    *(u32*)0x11111111 = 0; //trigger an exception
+    *(u32*)0x11111111 = 0; // trigger an exception
 }
 
-void Fault_AddHungupAndCrash(const char* filename, u32 line)
-{
+void Fault_AddHungupAndCrash(const char* filename, u32 line) {
     char msg[256];
     sprintf(msg, "HungUp %s:%d", filename, line);
     Fault_AddHungupAndCrashImpl(msg, NULL);
diff --git a/src/code/fault_drawer.c b/src/code/fault_drawer.c
index 522f0b2ff..ef7a784ae 100644
--- a/src/code/fault_drawer.c
+++ b/src/code/fault_drawer.c
@@ -2,277 +2,268 @@
 #include <global.h>
 #include <vt.h>
 
-//rodata
+// rodata
 const u32 sFaultDrawerFont[] = {
-    0x00DFFD00, 0x0AEEFFA0, 0x0DF22DD0, 0x06611DC0, 0x01122DD0, 0x06719900, 0x011EED10, 0x077EF700,
-    0x01562990, 0x05589760, 0x0DD22990, 0x05599770, 0x04DFFD40, 0x026EF700, 0x00000000, 0x00000000,
-    0x08BFFB00, 0x0EFFFFC0, 0x0BF00FB0, 0x0FF00330, 0x0FF00FF0, 0x0FF00220, 0x0CFBBF60, 0x0FFCCE20,
-    0x0DD44FF0, 0x0FF00220, 0x0FF00FF0, 0x0FF00330, 0x0CFBBF40, 0x0EF77740, 0x00000000, 0x00000000,
-    0x00DFFD00, 0x0AEEFFA0, 0x0DF22DD0, 0x06611DC0, 0x01122DD0, 0x06719900, 0x011EED10, 0x077EF700,
-    0x01562990, 0x05589760, 0x0DD22990, 0x05599770, 0x04DFFD40, 0x026EF700, 0x00000000, 0x00000000,
-    0x08BFFB00, 0x000DE000, 0x0BF00FB0, 0x005DE600, 0x0FF00FF0, 0x055CC660, 0x0CFBBF60, 0x773FF377,
-    0x0DD44FF0, 0xBB3FF3BB, 0x0FF00FF0, 0x099CCAA0, 0x0CFBBF40, 0x009DEA00, 0x00000000, 0x000DE000,
-    0x04C22C40, 0x028D5020, 0x0CCAACC0, 0x21F91710, 0x04C22C40, 0x12493400, 0x00820800, 0x01975110,
-    0x088A8880, 0x04615241, 0x00800800, 0x43117530, 0x00A20800, 0x60055600, 0x00000000, 0x04400040,
-    0x00221100, 0x00000080, 0x000FB000, 0x00000880, 0x040DA400, 0x00008800, 0x08CDE880, 0x022AA220,
-    0x08CDE880, 0x02AA2220, 0x040DA400, 0x0CD10000, 0x000FB000, 0x8C510000, 0x00221100, 0x81100000,
-    0x00DFFD00, 0x0AEEFFA0, 0x0DF22DD0, 0x06611DC0, 0x01122DD0, 0x06719900, 0x011EED10, 0x077EF700,
-    0x01562990, 0x05589760, 0x0DD22990, 0x05599770, 0x04DFFD40, 0x026EF700, 0x00000000, 0x00000000,
-    0x00333300, 0x04489980, 0x033CC330, 0x00CD1088, 0x033CC330, 0x02BF62A8, 0x00333320, 0x01104C80,
-    0x01100330, 0x0015C800, 0x033CC330, 0x02673220, 0x003FF300, 0x04409900, 0x00880000, 0x00000000,
-    0x05DFFD10, 0x07FFFF60, 0x1CE00EC1, 0x0FF00990, 0x1EE11661, 0x0FF00110, 0x1EF45621, 0x0FF66710,
-    0x1EF23661, 0x0FF08990, 0x1EF10FE1, 0x0FF00990, 0x16ECCE21, 0x07FBBB20, 0x01111110, 0x00000000,
-    0x09B66FD0, 0x27D88E60, 0x0992ED10, 0x2FF02EE0, 0x099AE510, 0x2FF62EE0, 0x099B7510, 0x2FD64EE0,
-    0x0DDAE510, 0x2FD04EE0, 0x0DD2ED10, 0x2FD00EE0, 0x09F66F90, 0x27D99F70, 0x00000000, 0x00000000,
-    0x07FFFF00, 0x8F711FF0, 0x2FD00FF0, 0x8F711FF0, 0x2FD00770, 0x8E611EE0, 0x27DDDF60, 0x8E691EE0,
-    0x27764AA0, 0x8EE99EE0, 0x2FD06E80, 0x8AE7FEA0, 0x07FA8E60, 0x88277A80, 0x00000000, 0x00000000,
-    0x077CCFF0, 0x13266011, 0x077CCFF0, 0x03766510, 0x0239D720, 0x04533540, 0x002FF200, 0x01133110,
-    0x005FB100, 0x00033000, 0x055EE550, 0x01133110, 0x055EEDD0, 0x02233000, 0x00088880, 0x8AABB888,
-    0x00001100, 0x00044510, 0x04623320, 0x00440110, 0x04C89AA0, 0x00EEAB10, 0x0CE66720, 0x0EF55FB0,
-    0x0EE00660, 0x0BF62B90, 0x0EE00660, 0x03FC8990, 0x04EEEEA0, 0x00773BB0, 0x00000000, 0x08888800,
-    0x09900000, 0x00111000, 0x09922440, 0x00011000, 0x09908800, 0x26EFDE20, 0x099BB540, 0x2EC33CE2,
-    0x0D9A2550, 0x2EC33CE2, 0x0DDAA550, 0x2EC33CE2, 0x09D6ED10, 0x26CBBC62, 0x00000000, 0x00000000,
-    0x00000000, 0x00000000, 0x00000000, 0x00011000, 0x05FBFFE0, 0x8E6116E8, 0x0FF40330, 0x8F7117F8,
-    0x07FC8B30, 0x8E6996E8, 0x05733BA0, 0x8A6DD6A8, 0x0DD88A20, 0x08A779B2, 0x01100220, 0x00000000,
-    0x00000080, 0x8A011000, 0x00000800, 0x80A11000, 0x07744F70, 0x80A99000, 0x0231DF20, 0x84E60004,
-    0x0027DA20, 0xC8AA4C40, 0x00573B20, 0x00A11800, 0x05546F50, 0x00A99800, 0x02222080, 0x02001888,
+    0x00DFFD00, 0x0AEEFFA0, 0x0DF22DD0, 0x06611DC0, 0x01122DD0, 0x06719900, 0x011EED10, 0x077EF700, 0x01562990,
+    0x05589760, 0x0DD22990, 0x05599770, 0x04DFFD40, 0x026EF700, 0x00000000, 0x00000000, 0x08BFFB00, 0x0EFFFFC0,
+    0x0BF00FB0, 0x0FF00330, 0x0FF00FF0, 0x0FF00220, 0x0CFBBF60, 0x0FFCCE20, 0x0DD44FF0, 0x0FF00220, 0x0FF00FF0,
+    0x0FF00330, 0x0CFBBF40, 0x0EF77740, 0x00000000, 0x00000000, 0x00DFFD00, 0x0AEEFFA0, 0x0DF22DD0, 0x06611DC0,
+    0x01122DD0, 0x06719900, 0x011EED10, 0x077EF700, 0x01562990, 0x05589760, 0x0DD22990, 0x05599770, 0x04DFFD40,
+    0x026EF700, 0x00000000, 0x00000000, 0x08BFFB00, 0x000DE000, 0x0BF00FB0, 0x005DE600, 0x0FF00FF0, 0x055CC660,
+    0x0CFBBF60, 0x773FF377, 0x0DD44FF0, 0xBB3FF3BB, 0x0FF00FF0, 0x099CCAA0, 0x0CFBBF40, 0x009DEA00, 0x00000000,
+    0x000DE000, 0x04C22C40, 0x028D5020, 0x0CCAACC0, 0x21F91710, 0x04C22C40, 0x12493400, 0x00820800, 0x01975110,
+    0x088A8880, 0x04615241, 0x00800800, 0x43117530, 0x00A20800, 0x60055600, 0x00000000, 0x04400040, 0x00221100,
+    0x00000080, 0x000FB000, 0x00000880, 0x040DA400, 0x00008800, 0x08CDE880, 0x022AA220, 0x08CDE880, 0x02AA2220,
+    0x040DA400, 0x0CD10000, 0x000FB000, 0x8C510000, 0x00221100, 0x81100000, 0x00DFFD00, 0x0AEEFFA0, 0x0DF22DD0,
+    0x06611DC0, 0x01122DD0, 0x06719900, 0x011EED10, 0x077EF700, 0x01562990, 0x05589760, 0x0DD22990, 0x05599770,
+    0x04DFFD40, 0x026EF700, 0x00000000, 0x00000000, 0x00333300, 0x04489980, 0x033CC330, 0x00CD1088, 0x033CC330,
+    0x02BF62A8, 0x00333320, 0x01104C80, 0x01100330, 0x0015C800, 0x033CC330, 0x02673220, 0x003FF300, 0x04409900,
+    0x00880000, 0x00000000, 0x05DFFD10, 0x07FFFF60, 0x1CE00EC1, 0x0FF00990, 0x1EE11661, 0x0FF00110, 0x1EF45621,
+    0x0FF66710, 0x1EF23661, 0x0FF08990, 0x1EF10FE1, 0x0FF00990, 0x16ECCE21, 0x07FBBB20, 0x01111110, 0x00000000,
+    0x09B66FD0, 0x27D88E60, 0x0992ED10, 0x2FF02EE0, 0x099AE510, 0x2FF62EE0, 0x099B7510, 0x2FD64EE0, 0x0DDAE510,
+    0x2FD04EE0, 0x0DD2ED10, 0x2FD00EE0, 0x09F66F90, 0x27D99F70, 0x00000000, 0x00000000, 0x07FFFF00, 0x8F711FF0,
+    0x2FD00FF0, 0x8F711FF0, 0x2FD00770, 0x8E611EE0, 0x27DDDF60, 0x8E691EE0, 0x27764AA0, 0x8EE99EE0, 0x2FD06E80,
+    0x8AE7FEA0, 0x07FA8E60, 0x88277A80, 0x00000000, 0x00000000, 0x077CCFF0, 0x13266011, 0x077CCFF0, 0x03766510,
+    0x0239D720, 0x04533540, 0x002FF200, 0x01133110, 0x005FB100, 0x00033000, 0x055EE550, 0x01133110, 0x055EEDD0,
+    0x02233000, 0x00088880, 0x8AABB888, 0x00001100, 0x00044510, 0x04623320, 0x00440110, 0x04C89AA0, 0x00EEAB10,
+    0x0CE66720, 0x0EF55FB0, 0x0EE00660, 0x0BF62B90, 0x0EE00660, 0x03FC8990, 0x04EEEEA0, 0x00773BB0, 0x00000000,
+    0x08888800, 0x09900000, 0x00111000, 0x09922440, 0x00011000, 0x09908800, 0x26EFDE20, 0x099BB540, 0x2EC33CE2,
+    0x0D9A2550, 0x2EC33CE2, 0x0DDAA550, 0x2EC33CE2, 0x09D6ED10, 0x26CBBC62, 0x00000000, 0x00000000, 0x00000000,
+    0x00000000, 0x00000000, 0x00011000, 0x05FBFFE0, 0x8E6116E8, 0x0FF40330, 0x8F7117F8, 0x07FC8B30, 0x8E6996E8,
+    0x05733BA0, 0x8A6DD6A8, 0x0DD88A20, 0x08A779B2, 0x01100220, 0x00000000, 0x00000080, 0x8A011000, 0x00000800,
+    0x80A11000, 0x07744F70, 0x80A99000, 0x0231DF20, 0x84E60004, 0x0027DA20, 0xC8AA4C40, 0x00573B20, 0x00A11800,
+    0x05546F50, 0x00A99800, 0x02222080, 0x02001888,
 };
 
-//data
-FaultDrawer sFaultDrawerDefault =
-{
-    (u16*)0x803DA800, //fb
-    320, 240, //w, h
-    16, 223, //yStart, yEnd
-    22, 297,//xStart, xEnd
-    0xFFFF, 0x0000, //foreColor, backColor
-    22, 16, //cursorX, cursorY
-    &sFaultDrawerFont, //font
+// data
+// clang-format off
+FaultDrawer sFaultDrawerDefault = {
+    (u16*)0x803DA800, // fb
+    320, 240, // w, h
+    16, 223, // yStart, yEnd
+    22, 297, // xStart, xEnd
+    0xFFFF, 0x0000, // foreColor, backColor
+    22, 16, // cursorX, cursorY
+    sFaultDrawerFont, // font
     8, 8, 0, 0,
-    { //printColors
+    { // printColors
         0x0001, 0xF801, 0x07C1, 0xFFC1,
         0x003F, 0xF83F, 0x07FF, 0xFFFF,
         0x7BDF, 0xB5AD
     },
-    0, //escCode
-    0, //osSyncPrintfEnabled
-    NULL, //inputCallback
+    0, // escCode
+    0, // osSyncPrintfEnabled
+    NULL, // inputCallback
 };
+// clang-format on
 
-//bss
+// bss
 FaultDrawer sFaultDrawerStruct;
 char D_8016B6C0[0x20]; //? unused
 
-
-void FaultDrawer_SetOsSyncPrintfEnabled(u32 enabled)
-{
+void FaultDrawer_SetOsSyncPrintfEnabled(u32 enabled) {
     sFaultDrawerStruct.osSyncPrintfEnabled = enabled;
 }
 
-#ifdef NON_MATCHING
-void FaultDrawer_DrawRecImpl(s32 xstart, s32 ystart, s32 xend, s32 yend, u16 color)
-{
-    if (sFaultDrawerStruct.w - xstart > 0 && sFaultDrawerStruct.h - ystart > 0)
-    {
-        s32 x, y;
-        for (y = 0; y < yend-ystart+1; y++)
-            for (x = 0; x < xend-xstart+1; x++)
-                sFaultDrawerStruct.fb[sFaultDrawerStruct.w*y+x] = color;
+void FaultDrawer_DrawRecImpl(s32 xStart, s32 yStart, s32 xEnd, s32 yEnd, u16 color) {
+    u16* fb;
+    s32 x, y;
+    s32 xDiff = sFaultDrawerStruct.w - xStart;
+    s32 yDiff = sFaultDrawerStruct.h - yStart;
+    s32 xSize = xEnd - xStart + 1;
+    s32 ySize = yEnd - yStart + 1;
+
+    if (xDiff > 0 && yDiff > 0) {
+        if (xDiff < xSize) {
+            xSize = xDiff;
+        }
+
+        if (yDiff < ySize) {
+            ySize = yDiff;
+        }
+
+        fb = sFaultDrawerStruct.fb + sFaultDrawerStruct.w * yStart + xStart;
+        for (y = 0; y < ySize; y++) {
+            for (x = 0; x < xSize; x++) {
+                *fb++ = color;
+            }
+            fb += sFaultDrawerStruct.w - xSize;
+        }
 
         osWritebackDCacheAll();
     }
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/fault_drawer/FaultDrawer_DrawRecImpl.s")
-#endif
-
 
-#ifdef NON_MATCHING
-void FaultDrawer_DrawChar(char c)
-{
+void FaultDrawer_DrawChar(char c) {
+    u16* fb;
     s32 x, y;
-    u32* dataStart = &sFaultDrawerStruct.fontData[(c >> 3) * 0x10 + (c & 4) >> 2];
-    u16* fb = &sFaultDrawerStruct.fb[sFaultDrawerStruct.w * sFaultDrawerStruct.cursorY + sFaultDrawerStruct.cursorX];
-
-    if (sFaultDrawerStruct.xStart <= sFaultDrawerStruct.cursorX &&
-        sFaultDrawerStruct.charW + sFaultDrawerStruct.cursorX -1 <= sFaultDrawerStruct.xEnd &&
-        sFaultDrawerStruct.yStart <= sFaultDrawerStruct.cursorY &&
-        sFaultDrawerStruct.charH + sFaultDrawerStruct.cursorY -1 <= sFaultDrawerStruct.yEnd &&
-        sFaultDrawerStruct.charH != 0
-        )
-    {
-        for (y = 0; y < sFaultDrawerStruct.charH; y++)
-        {
-            u32 mask = 0x10000000 << (c & 3);
-            for (x = 0; x < sFaultDrawerStruct.charW; x++)
-            {
-                if ((mask & *dataStart))
+    u32* dataPtr;
+    u32 data;
+    s32 cursorX = sFaultDrawerStruct.cursorX;
+    s32 cursorY = sFaultDrawerStruct.cursorY;
+    u32** fontData = &sFaultDrawerStruct.fontData;
+    s32 shift = c % 4;
+
+    dataPtr = &fontData[0][(((c / 8) * 16) + ((c & 4) >> 2))];
+    fb = sFaultDrawerStruct.fb + (sFaultDrawerStruct.w * cursorY) + cursorX;
+
+    if ((sFaultDrawerStruct.xStart <= cursorX) &&
+        ((sFaultDrawerStruct.charW + cursorX - 1) <= sFaultDrawerStruct.xEnd) &&
+        (sFaultDrawerStruct.yStart <= cursorY) &&
+        ((sFaultDrawerStruct.charH + cursorY - 1) <= sFaultDrawerStruct.yEnd)) {
+        for (y = 0; y < sFaultDrawerStruct.charH; y++) {
+            u32 mask = 0x10000000 << shift;
+            data = *dataPtr;
+            for (x = 0; x < sFaultDrawerStruct.charW; x++) {
+                if (mask & data) {
                     fb[x] = sFaultDrawerStruct.foreColor;
-                else
-                    if (sFaultDrawerStruct.backColor & 1)
-                        fb[x] = sFaultDrawerStruct.backColor;
+                } else if (sFaultDrawerStruct.backColor & 1) {
+                    fb[x] = sFaultDrawerStruct.backColor;
+                }
                 mask >>= 4;
             }
             fb += sFaultDrawerStruct.w;
-            dataStart += 2;
+            dataPtr += 2;
         }
     }
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/fault_drawer/FaultDrawer_DrawChar.s")
-#endif
 
-s32 FaultDrawer_ColorToPrintColor(u16 color)
-{
+s32 FaultDrawer_ColorToPrintColor(u16 color) {
     s32 i;
-    for (i = 0; i < 10; i++)
-        if (color == sFaultDrawerStruct.printColors[i])
+    for (i = 0; i < 10; i++) {
+        if (color == sFaultDrawerStruct.printColors[i]) {
             return i;
+        }
+    }
     return -1;
 }
 
-void FaultDrawer_UpdatePrintColor()
-{
+void FaultDrawer_UpdatePrintColor() {
     s32 idx;
-    if (sFaultDrawerStruct.osSyncPrintfEnabled)
-    {
+    if (sFaultDrawerStruct.osSyncPrintfEnabled) {
         osSyncPrintf(VT_RST);
         idx = FaultDrawer_ColorToPrintColor(sFaultDrawerStruct.foreColor);
-        if (idx >= 0 && idx < 8)
+        if (idx >= 0 && idx < 8) {
             osSyncPrintf(VT_SGR("3%d"), idx);
+        }
         idx = FaultDrawer_ColorToPrintColor(sFaultDrawerStruct.backColor);
-        if (idx >= 0 && idx < 8)
+        if (idx >= 0 && idx < 8) {
             osSyncPrintf(VT_SGR("4%d"), idx);
+        }
     }
 }
 
-void FaultDrawer_SetForeColor(u16 color)
-{
+void FaultDrawer_SetForeColor(u16 color) {
     sFaultDrawerStruct.foreColor = color;
     FaultDrawer_UpdatePrintColor();
 }
 
-void FaultDrawer_SetBackColor(u16 color)
-{
+void FaultDrawer_SetBackColor(u16 color) {
     sFaultDrawerStruct.backColor = color;
     FaultDrawer_UpdatePrintColor();
 }
 
-void FaultDrawer_SetFontColor(u16 color)
-{
-    FaultDrawer_SetForeColor((u16)(color | 1)); //force alpha to be set
+void FaultDrawer_SetFontColor(u16 color) {
+    FaultDrawer_SetForeColor(color | 1); // force alpha to be set
 }
 
-void FaultDrawer_SetCharPad(s8 padW, s8 padH)
-{
+void FaultDrawer_SetCharPad(s8 padW, s8 padH) {
     sFaultDrawerStruct.charWPad = padW;
     sFaultDrawerStruct.charHPad = padH;
 }
 
-void FaultDrawer_SetCursor(s32 x, s32 y)
-{
-    if (sFaultDrawerStruct.osSyncPrintfEnabled)
-        osSyncPrintf(VT_CUP(%d, %d), (y - sFaultDrawerStruct.yStart) / (sFaultDrawerStruct.charH + sFaultDrawerStruct.charHPad), (x - sFaultDrawerStruct.xStart) / (sFaultDrawerStruct.charW + sFaultDrawerStruct.charWPad));
+void FaultDrawer_SetCursor(s32 x, s32 y) {
+    if (sFaultDrawerStruct.osSyncPrintfEnabled) {
+        osSyncPrintf(VT_CUP("%d", "%d"),
+                     (y - sFaultDrawerStruct.yStart) / (sFaultDrawerStruct.charH + sFaultDrawerStruct.charHPad),
+                     (x - sFaultDrawerStruct.xStart) / (sFaultDrawerStruct.charW + sFaultDrawerStruct.charWPad));
+    }
     sFaultDrawerStruct.cursorX = x;
     sFaultDrawerStruct.cursorY = y;
 }
 
-void FaultDrawer_FillScreen()
-{
-    if (sFaultDrawerStruct.osSyncPrintfEnabled)
+void FaultDrawer_FillScreen() {
+    if (sFaultDrawerStruct.osSyncPrintfEnabled) {
         osSyncPrintf(VT_CLS);
+    }
 
-    FaultDrawer_DrawRecImpl(sFaultDrawerStruct.xStart, sFaultDrawerStruct.yStart, sFaultDrawerStruct.xEnd, sFaultDrawerStruct.yEnd, sFaultDrawerStruct.backColor | 1);
+    FaultDrawer_DrawRecImpl(sFaultDrawerStruct.xStart, sFaultDrawerStruct.yStart, sFaultDrawerStruct.xEnd,
+                            sFaultDrawerStruct.yEnd, sFaultDrawerStruct.backColor | 1);
     FaultDrawer_SetCursor(sFaultDrawerStruct.xStart, sFaultDrawerStruct.yStart);
 }
 
-#ifdef NON_MATCHING
-u32 FaultDrawer_FormatStringFunc(u32 arg0, const char* str, s32 count)
-{
-    while (count)
-    {
-        s32 curXStart; //s32?
+u32 FaultDrawer_FormatStringFunc(u32 arg0, const char* str, s32 count) {
+    for (count; count != 0; count--, str++) {
+        s32 curXStart;
         s32 curXEnd;
 
-        if (sFaultDrawerStruct.escCode)
-        {
+        if (sFaultDrawerStruct.escCode) {
             sFaultDrawerStruct.escCode = false;
-            if (*str > 0x30 && *str < 0x3A)
-                FaultDrawer_SetForeColor(gFaultStruct.colors[*str + 12]);
+            if (*str > 0x30 && *str < 0x3A) {
+                FaultDrawer_SetForeColor(sFaultDrawerStruct.printColors[*str - 0x30]);
+            }
 
             curXStart = sFaultDrawerStruct.cursorX;
             curXEnd = sFaultDrawerStruct.xEnd - sFaultDrawerStruct.charW;
-        }
-        else
-        {
-            if (*str == '\n')
-            {
-                if (sFaultDrawerStruct.osSyncPrintfEnabled)
-                    osSyncPrintf("\n");
-
-                sFaultDrawerStruct.cursorX = sFaultDrawerStruct.w;
-                curXStart = sFaultDrawerStruct.w;
-                curXEnd = sFaultDrawerStruct.xEnd - sFaultDrawerStruct.charW;
-            }
-            else if (*str == '\x1a')
-            {
-                sFaultDrawerStruct.escCode = true;
-                curXStart = sFaultDrawerStruct.cursorX;
-                curXEnd = sFaultDrawerStruct.xEnd - sFaultDrawerStruct.charW;
-            }
-            else
-            {
-                if (sFaultDrawerStruct.osSyncPrintfEnabled)
-                    osSyncPrintf("%c", *str);
-
-                FaultDrawer_DrawChar(*str);
-                sFaultDrawerStruct.cursorX += sFaultDrawerStruct.charW + sFaultDrawerStruct.charWPad;
-
-                curXStart = sFaultDrawerStruct.cursorX;
-                curXEnd = sFaultDrawerStruct.xEnd - sFaultDrawerStruct.charW;
+        } else {
+            switch (*str) {
+                case '\n':
+                    if (sFaultDrawerStruct.osSyncPrintfEnabled) {
+                        osSyncPrintf("\n");
+                    }
+
+                    sFaultDrawerStruct.cursorX = sFaultDrawerStruct.w;
+                    curXStart = sFaultDrawerStruct.cursorX;
+                    curXEnd = sFaultDrawerStruct.xEnd - sFaultDrawerStruct.charW;
+                    break;
+                case '\x1A':
+                    sFaultDrawerStruct.escCode = true;
+                    curXStart = sFaultDrawerStruct.cursorX;
+                    curXEnd = sFaultDrawerStruct.xEnd - sFaultDrawerStruct.charW;
+                    break;
+                default:
+                    if (sFaultDrawerStruct.osSyncPrintfEnabled) {
+                        osSyncPrintf("%c", *str);
+                    }
+
+                    FaultDrawer_DrawChar(*str);
+                    sFaultDrawerStruct.cursorX += sFaultDrawerStruct.charW + sFaultDrawerStruct.charWPad;
+
+                    curXStart = sFaultDrawerStruct.cursorX;
+                    curXEnd = sFaultDrawerStruct.xEnd - sFaultDrawerStruct.charW;
             }
         }
 
-        if (curXEnd <= curXStart)
-        {
-            sFaultDrawerStruct.cursorY += sFaultDrawerStruct.charH + sFaultDrawerStruct.charHPad;
+        if (curXEnd <= curXStart) {
             sFaultDrawerStruct.cursorX = sFaultDrawerStruct.xStart;
-            if (sFaultDrawerStruct.yEnd - sFaultDrawerStruct.charH <= (u16)sFaultDrawerStruct.cursorY) //cast?
-            {
-                if (sFaultDrawerStruct.inputCallback)
-                {
+            sFaultDrawerStruct.cursorY += sFaultDrawerStruct.charH + sFaultDrawerStruct.charHPad;
+            if (sFaultDrawerStruct.yEnd - sFaultDrawerStruct.charH <= sFaultDrawerStruct.cursorY) {
+                if (sFaultDrawerStruct.inputCallback) {
                     sFaultDrawerStruct.inputCallback();
                     FaultDrawer_FillScreen();
                 }
                 sFaultDrawerStruct.cursorY = sFaultDrawerStruct.yStart;
             }
         }
-
-        count--;
-        str++;
     }
+
     osWritebackDCacheAll();
+
     return arg0;
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/fault_drawer/FaultDrawer_FormatStringFunc.s")
-#endif
 
-void FaultDrawer_VPrintf(const char* str, char* args) //va_list
-{
+void FaultDrawer_VPrintf(const char* str, char* args) { // va_list
     _Printf(&FaultDrawer_FormatStringFunc, &sFaultDrawerStruct, str, args);
 }
 
-void FaultDrawer_Printf(const char* fmt, ...)
-{
+void FaultDrawer_Printf(const char* fmt, ...) {
     va_list args;
     va_start(args, fmt);
 
     FaultDrawer_VPrintf(fmt, args);
 }
 
-void FaultDrawer_DrawText(s32 x, s32 y, const char* fmt, ...)
-{
+void FaultDrawer_DrawText(s32 x, s32 y, const char* fmt, ...) {
     va_list args;
     va_start(args, fmt);
 
@@ -280,25 +271,21 @@ void FaultDrawer_DrawText(s32 x, s32 y, const char* fmt, ...)
     FaultDrawer_VPrintf(fmt, args);
 }
 
-void FaultDrawer_SetDrawerFB(void* fb, u16 w, u16 h)
-{
-    sFaultDrawerStruct.fb = (u16*)fb;
+void FaultDrawer_SetDrawerFB(void* fb, u16 w, u16 h) {
+    sFaultDrawerStruct.fb = fb;
     sFaultDrawerStruct.w = w;
     sFaultDrawerStruct.h = h;
 }
 
-void FaultDrawer_SetInputCallback(void(*callback)())
-{
+void FaultDrawer_SetInputCallback(void (*callback)()) {
     sFaultDrawerStruct.inputCallback = callback;
 }
 
-void FaultDrawer_WritebackFBDCache()
-{
-    osWritebackDCache(sFaultDrawerStruct.fb, sFaultDrawerStruct.w*sFaultDrawerStruct.h*2);
+void FaultDrawer_WritebackFBDCache() {
+    osWritebackDCache(sFaultDrawerStruct.fb, sFaultDrawerStruct.w * sFaultDrawerStruct.h * 2);
 }
 
-void FaultDrawer_SetDefault()
-{
+void FaultDrawer_SetDefault() {
     bcopy(&sFaultDrawerDefault, &sFaultDrawerStruct, sizeof(FaultDrawer));
     sFaultDrawerStruct.fb = (u16*)((osMemSize | 0x80000000) - 0x25800);
 }
diff --git a/src/code/gamealloc.c b/src/code/gamealloc.c
index 87a32db16..9ec6886b2 100644
--- a/src/code/gamealloc.c
+++ b/src/code/gamealloc.c
@@ -1,26 +1,22 @@
 #include <global.h>
 
-void GameAlloc_Log(GameAlloc* this)
-{
+void GameAlloc_Log(GameAlloc* this) {
     GameAllocEntry* iter;
 
     osSyncPrintf("this = %08x\n", this);
 
     iter = this->base.next;
-    while (iter != &this->base)
-    {
+    while (iter != &this->base) {
         osSyncPrintf("ptr = %08x size = %d\n", iter, iter->size);
         iter = iter->next;
     }
 }
 
-void* GameAlloc_MallocDebug(GameAlloc* this, u32 size, const char* file, s32 line)
-{
+void* GameAlloc_MallocDebug(GameAlloc* this, u32 size, const char* file, s32 line) {
     GameAllocEntry* ptr;
 
-    ptr = SystemArena_MallocDebug(size+sizeof(GameAllocEntry), file, line);
-    if (ptr)
-    {
+    ptr = SystemArena_MallocDebug(size + sizeof(GameAllocEntry), file, line);
+    if (ptr) {
         ptr->size = size;
         ptr->prev = this->head;
         this->head->next = ptr;
@@ -28,18 +24,16 @@ void* GameAlloc_MallocDebug(GameAlloc* this, u32 size, const char* file, s32 lin
         ptr->next = &this->base;
         this->base.prev = this->head;
         return ptr + 1;
-    }
-    else
+    } else {
         return NULL;
+    }
 }
 
-void* GameAlloc_Malloc(GameAlloc* this, u32 size)
-{
+void* GameAlloc_Malloc(GameAlloc* this, u32 size) {
     GameAllocEntry* ptr;
 
-    ptr = SystemArena_MallocDebug(size+sizeof(GameAllocEntry), "../gamealloc.c", 93);
-    if (ptr)
-    {
+    ptr = SystemArena_MallocDebug(size + sizeof(GameAllocEntry), "../gamealloc.c", 93);
+    if (ptr) {
         ptr->size = size;
         ptr->prev = this->head;
         this->head->next = ptr;
@@ -47,17 +41,15 @@ void* GameAlloc_Malloc(GameAlloc* this, u32 size)
         ptr->next = &this->base;
         this->base.prev = this->head;
         return ptr + 1;
-    }
-    else
+    } else {
         return NULL;
+    }
 }
 
-void GameAlloc_Free(GameAlloc* this, void* data)
-{
+void GameAlloc_Free(GameAlloc* this, void* data) {
     GameAllocEntry* ptr;
 
-    if (data)
-    {
+    if (data) {
         ptr = &((GameAllocEntry*)data)[-1];
         LogUtils_CheckNullPointer("ptr->prev", ptr->prev, "../gamealloc.c", 120);
         LogUtils_CheckNullPointer("ptr->next", ptr->next, "../gamealloc.c", 121);
@@ -68,14 +60,12 @@ void GameAlloc_Free(GameAlloc* this, void* data)
     }
 }
 
-void GameAlloc_Cleanup(GameAlloc* this)
-{
+void GameAlloc_Cleanup(GameAlloc* this) {
     GameAllocEntry* next;
     GameAllocEntry* cur;
 
     next = this->base.next;
-    while (&this->base != next)
-    {
+    while (&this->base != next) {
         cur = next;
         next = next->next;
         SystemArena_FreeDebug(cur, "../gamealloc.c", 145);
@@ -84,11 +74,9 @@ void GameAlloc_Cleanup(GameAlloc* this)
     this->head = &this->base;
     this->base.next = &this->base;
     this->base.prev = &this->base;
-    
 }
 
-void GameAlloc_Init(GameAlloc* this)
-{
+void GameAlloc_Init(GameAlloc* this) {
     this->head = &this->base;
     this->base.next = &this->base;
     this->base.prev = &this->base;
diff --git a/src/code/gfxprint.c b/src/code/gfxprint.c
index a1aaaced8..7d17af790 100644
--- a/src/code/gfxprint.c
+++ b/src/code/gfxprint.c
@@ -1,159 +1,204 @@
 #include <ultra64.h>
 #include <global.h>
 
-//.bss
+// .bss
 u8 D_801755F0;
 
-//.data
-u16 sGfxPrintFontTLUT[64] =
-{
-    0x0000, 0xFFFF, 0x0000, 0xFFFF,
-    0x0000, 0xFFFF, 0x0000, 0xFFFF,
-    0x0000, 0xFFFF, 0x0000, 0xFFFF,
-    0x0000, 0xFFFF, 0x0000, 0xFFFF,
-    0x0000, 0x0000, 0xFFFF, 0xFFFF,
-    0x0000, 0x0000, 0xFFFF, 0xFFFF,
-    0x0000, 0x0000, 0xFFFF, 0xFFFF,
-    0x0000, 0x0000, 0xFFFF, 0xFFFF,
-    0x0000, 0x0000, 0x0000, 0x0000,
-    0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
-    0x0000, 0x0000, 0x0000, 0x0000,
-    0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
-    0x0000, 0x0000, 0x0000, 0x0000,
-    0x0000, 0x0000, 0x0000, 0x0000,
-    0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
-    0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+// .data
+u16 sGfxPrintFontTLUT[64] = {
+    0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000,
+    0xFFFF, 0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000,
+    0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF,
+    0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
 };
 
-u16 sGfxPrintUnkTLUT[16] =
-{
-    0xF801, 0xFBC1, 0xFFC1, 0x07C1,
-    0x0421, 0x003F, 0x803F, 0xF83F,
-    0xF801, 0xFBC1, 0xFFC1, 0x07C1,
-    0x0421, 0x003F, 0x803F, 0xF83F,
+u16 sGfxPrintUnkTLUT[16] = {
+    0xF801, 0xFBC1, 0xFFC1, 0x07C1, 0x0421, 0x003F, 0x803F, 0xF83F,
+    0xF801, 0xFBC1, 0xFFC1, 0x07C1, 0x0421, 0x003F, 0x803F, 0xF83F,
 };
 
 u8 sGfxPrintUnkData[8] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
 
-u8 sGfxPrintFontData[(16*256)/2] =
-{
-    0x00, 0xDF, 0xFD, 0x00, 0x0A, 0xEE, 0xFF, 0xA0, 0x0D, 0xF2, 0x2D, 0xD0, 0x06, 0x61, 0x1D, 0xC0, 0x01, 0x12, 0x2D, 0xD0, 0x06, 0x71, 0x99, 0x00, 0x01, 0x1E, 0xED, 0x10, 0x07, 0x7E, 0xF7, 0x00,
-    0x01, 0x56, 0x29, 0x90, 0x05, 0x58, 0x97, 0x60, 0x0D, 0xD2, 0x29, 0x90, 0x05, 0x59, 0x97, 0x70, 0x04, 0xDF, 0xFD, 0x40, 0x02, 0x6E, 0xF7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x08, 0xBF, 0xFB, 0x00, 0x0E, 0xFF, 0xFF, 0xC0, 0x0B, 0xF0, 0x0F, 0xB0, 0x0F, 0xF0, 0x03, 0x30, 0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x02, 0x20, 0x0C, 0xFB, 0xBF, 0x60, 0x0F, 0xFC, 0xCE, 0x20,
-    0x0D, 0xD4, 0x4F, 0xF0, 0x0F, 0xF0, 0x02, 0x20, 0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x03, 0x30, 0x0C, 0xFB, 0xBF, 0x40, 0x0E, 0xF7, 0x77, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0xDF, 0xFD, 0x00, 0x0A, 0xEE, 0xFF, 0xA0, 0x0D, 0xF2, 0x2D, 0xD0, 0x06, 0x61, 0x1D, 0xC0, 0x01, 0x12, 0x2D, 0xD0, 0x06, 0x71, 0x99, 0x00, 0x01, 0x1E, 0xED, 0x10, 0x07, 0x7E, 0xF7, 0x00,
-    0x01, 0x56, 0x29, 0x90, 0x05, 0x58, 0x97, 0x60, 0x0D, 0xD2, 0x29, 0x90, 0x05, 0x59, 0x97, 0x70, 0x04, 0xDF, 0xFD, 0x40, 0x02, 0x6E, 0xF7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x08, 0xBF, 0xFB, 0x00, 0x00, 0x0D, 0xE0, 0x00, 0x0B, 0xF0, 0x0F, 0xB0, 0x00, 0x5D, 0xE6, 0x00, 0x0F, 0xF0, 0x0F, 0xF0, 0x05, 0x5C, 0xC6, 0x60, 0x0C, 0xFB, 0xBF, 0x60, 0x77, 0x3F, 0xF3, 0x77,
-    0x0D, 0xD4, 0x4F, 0xF0, 0xBB, 0x3F, 0xF3, 0xBB, 0x0F, 0xF0, 0x0F, 0xF0, 0x09, 0x9C, 0xCA, 0xA0, 0x0C, 0xFB, 0xBF, 0x40, 0x00, 0x9D, 0xEA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D, 0xE0, 0x00,
-    0x04, 0xC2, 0x2C, 0x40, 0x02, 0x8D, 0x50, 0x20, 0x0C, 0xCA, 0xAC, 0xC0, 0x21, 0xF9, 0x17, 0x10, 0x04, 0xC2, 0x2C, 0x40, 0x12, 0x49, 0x34, 0x00, 0x00, 0x82, 0x08, 0x00, 0x01, 0x97, 0x51, 0x10,
-    0x08, 0x8A, 0x88, 0x80, 0x04, 0x61, 0x52, 0x41, 0x00, 0x80, 0x08, 0x00, 0x43, 0x11, 0x75, 0x30, 0x00, 0xA2, 0x08, 0x00, 0x60, 0x05, 0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x40, 0x00, 0x40,
-    0x00, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x0F, 0xB0, 0x00, 0x00, 0x00, 0x08, 0x80, 0x04, 0x0D, 0xA4, 0x00, 0x00, 0x00, 0x88, 0x00, 0x08, 0xCD, 0xE8, 0x80, 0x02, 0x2A, 0xA2, 0x20,
-    0x08, 0xCD, 0xE8, 0x80, 0x02, 0xAA, 0x22, 0x20, 0x04, 0x0D, 0xA4, 0x00, 0x0C, 0xD1, 0x00, 0x00, 0x00, 0x0F, 0xB0, 0x00, 0x8C, 0x51, 0x00, 0x00, 0x00, 0x22, 0x11, 0x00, 0x81, 0x10, 0x00, 0x00,
-    0x00, 0xDF, 0xFD, 0x00, 0x0A, 0xEE, 0xFF, 0xA0, 0x0D, 0xF2, 0x2D, 0xD0, 0x06, 0x61, 0x1D, 0xC0, 0x01, 0x12, 0x2D, 0xD0, 0x06, 0x71, 0x99, 0x00, 0x01, 0x1E, 0xED, 0x10, 0x07, 0x7E, 0xF7, 0x00,
-    0x01, 0x56, 0x29, 0x90, 0x05, 0x58, 0x97, 0x60, 0x0D, 0xD2, 0x29, 0x90, 0x05, 0x59, 0x97, 0x70, 0x04, 0xDF, 0xFD, 0x40, 0x02, 0x6E, 0xF7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x33, 0x33, 0x00, 0x04, 0x48, 0x99, 0x80, 0x03, 0x3C, 0xC3, 0x30, 0x00, 0xCD, 0x10, 0x88, 0x03, 0x3C, 0xC3, 0x30, 0x02, 0xBF, 0x62, 0xA8, 0x00, 0x33, 0x33, 0x20, 0x01, 0x10, 0x4C, 0x80,
-    0x01, 0x10, 0x03, 0x30, 0x00, 0x15, 0xC8, 0x00, 0x03, 0x3C, 0xC3, 0x30, 0x02, 0x67, 0x32, 0x20, 0x00, 0x3F, 0xF3, 0x00, 0x04, 0x40, 0x99, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x05, 0xDF, 0xFD, 0x10, 0x07, 0xFF, 0xFF, 0x60, 0x1C, 0xE0, 0x0E, 0xC1, 0x0F, 0xF0, 0x09, 0x90, 0x1E, 0xE1, 0x16, 0x61, 0x0F, 0xF0, 0x01, 0x10, 0x1E, 0xF4, 0x56, 0x21, 0x0F, 0xF6, 0x67, 0x10,
-    0x1E, 0xF2, 0x36, 0x61, 0x0F, 0xF0, 0x89, 0x90, 0x1E, 0xF1, 0x0F, 0xE1, 0x0F, 0xF0, 0x09, 0x90, 0x16, 0xEC, 0xCE, 0x21, 0x07, 0xFB, 0xBB, 0x20, 0x01, 0x11, 0x11, 0x10, 0x00, 0x00, 0x00, 0x00,
-    0x09, 0xB6, 0x6F, 0xD0, 0x27, 0xD8, 0x8E, 0x60, 0x09, 0x92, 0xED, 0x10, 0x2F, 0xF0, 0x2E, 0xE0, 0x09, 0x9A, 0xE5, 0x10, 0x2F, 0xF6, 0x2E, 0xE0, 0x09, 0x9B, 0x75, 0x10, 0x2F, 0xD6, 0x4E, 0xE0,
-    0x0D, 0xDA, 0xE5, 0x10, 0x2F, 0xD0, 0x4E, 0xE0, 0x0D, 0xD2, 0xED, 0x10, 0x2F, 0xD0, 0x0E, 0xE0, 0x09, 0xF6, 0x6F, 0x90, 0x27, 0xD9, 0x9F, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x07, 0xFF, 0xFF, 0x00, 0x8F, 0x71, 0x1F, 0xF0, 0x2F, 0xD0, 0x0F, 0xF0, 0x8F, 0x71, 0x1F, 0xF0, 0x2F, 0xD0, 0x07, 0x70, 0x8E, 0x61, 0x1E, 0xE0, 0x27, 0xDD, 0xDF, 0x60, 0x8E, 0x69, 0x1E, 0xE0,
-    0x27, 0x76, 0x4A, 0xA0, 0x8E, 0xE9, 0x9E, 0xE0, 0x2F, 0xD0, 0x6E, 0x80, 0x8A, 0xE7, 0xFE, 0xA0, 0x07, 0xFA, 0x8E, 0x60, 0x88, 0x27, 0x7A, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x07, 0x7C, 0xCF, 0xF0, 0x13, 0x26, 0x60, 0x11, 0x07, 0x7C, 0xCF, 0xF0, 0x03, 0x76, 0x65, 0x10, 0x02, 0x39, 0xD7, 0x20, 0x04, 0x53, 0x35, 0x40, 0x00, 0x2F, 0xF2, 0x00, 0x01, 0x13, 0x31, 0x10,
-    0x00, 0x5F, 0xB1, 0x00, 0x00, 0x03, 0x30, 0x00, 0x05, 0x5E, 0xE5, 0x50, 0x01, 0x13, 0x31, 0x10, 0x05, 0x5E, 0xED, 0xD0, 0x02, 0x23, 0x30, 0x00, 0x00, 0x08, 0x88, 0x80, 0x8A, 0xAB, 0xB8, 0x88,
-    0x00, 0x00, 0x11, 0x00, 0x00, 0x04, 0x45, 0x10, 0x04, 0x62, 0x33, 0x20, 0x00, 0x44, 0x01, 0x10, 0x04, 0xC8, 0x9A, 0xA0, 0x00, 0xEE, 0xAB, 0x10, 0x0C, 0xE6, 0x67, 0x20, 0x0E, 0xF5, 0x5F, 0xB0,
-    0x0E, 0xE0, 0x06, 0x60, 0x0B, 0xF6, 0x2B, 0x90, 0x0E, 0xE0, 0x06, 0x60, 0x03, 0xFC, 0x89, 0x90, 0x04, 0xEE, 0xEE, 0xA0, 0x00, 0x77, 0x3B, 0xB0, 0x00, 0x00, 0x00, 0x00, 0x08, 0x88, 0x88, 0x00,
-    0x09, 0x90, 0x00, 0x00, 0x00, 0x11, 0x10, 0x00, 0x09, 0x92, 0x24, 0x40, 0x00, 0x01, 0x10, 0x00, 0x09, 0x90, 0x88, 0x00, 0x26, 0xEF, 0xDE, 0x20, 0x09, 0x9B, 0xB5, 0x40, 0x2E, 0xC3, 0x3C, 0xE2,
-    0x0D, 0x9A, 0x25, 0x50, 0x2E, 0xC3, 0x3C, 0xE2, 0x0D, 0xDA, 0xA5, 0x50, 0x2E, 0xC3, 0x3C, 0xE2, 0x09, 0xD6, 0xED, 0x10, 0x26, 0xCB, 0xBC, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x10, 0x00, 0x05, 0xFB, 0xFF, 0xE0, 0x8E, 0x61, 0x16, 0xE8, 0x0F, 0xF4, 0x03, 0x30, 0x8F, 0x71, 0x17, 0xF8,
-    0x07, 0xFC, 0x8B, 0x30, 0x8E, 0x69, 0x96, 0xE8, 0x05, 0x73, 0x3B, 0xA0, 0x8A, 0x6D, 0xD6, 0xA8, 0x0D, 0xD8, 0x8A, 0x20, 0x08, 0xA7, 0x79, 0xB2, 0x01, 0x10, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x80, 0x8A, 0x01, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x80, 0xA1, 0x10, 0x00, 0x07, 0x74, 0x4F, 0x70, 0x80, 0xA9, 0x90, 0x00, 0x02, 0x31, 0xDF, 0x20, 0x84, 0xE6, 0x00, 0x04,
-    0x00, 0x27, 0xDA, 0x20, 0xC8, 0xAA, 0x4C, 0x40, 0x00, 0x57, 0x3B, 0x20, 0x00, 0xA1, 0x18, 0x00, 0x05, 0x54, 0x6F, 0x50, 0x00, 0xA9, 0x98, 0x00, 0x02, 0x22, 0x20, 0x80, 0x02, 0x00, 0x18, 0x88,
-    0x00, 0x04, 0x44, 0x40, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x44, 0x40, 0x0C, 0x44, 0x44, 0x00, 0x00, 0x04, 0x40, 0x00, 0x88, 0xC0, 0x00, 0x00, 0x00, 0x0C, 0xC0, 0x00, 0x0C, 0x46, 0xA4, 0x40,
-    0x00, 0x0C, 0xC0, 0x00, 0x08, 0x8E, 0xE0, 0x00, 0x02, 0x08, 0x80, 0x00, 0x80, 0xD0, 0x88, 0x00, 0x28, 0xA8, 0x80, 0x00, 0x88, 0xCD, 0x4C, 0x40, 0x0A, 0x88, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0xE0, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x88, 0x00, 0x80, 0x01, 0x06, 0x10, 0x00, 0x56, 0xE7, 0x50, 0x80, 0x02, 0x1F, 0xF1, 0x00,
-    0x38, 0x8C, 0xB8, 0x00, 0x0B, 0xF6, 0x0B, 0x00, 0x94, 0xC0, 0x28, 0x00, 0x06, 0x07, 0x6A, 0x00, 0xCB, 0xA6, 0xC8, 0x00, 0x00, 0x47, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x0A, 0x80, 0x00, 0x00, 0x39, 0x14, 0x20, 0x02, 0x22, 0x24, 0x00, 0x08, 0xAE, 0xA8, 0x60, 0x04, 0x28, 0x99, 0x70, 0x07, 0x75, 0xD1, 0x04, 0x0F, 0xB3, 0x33, 0xD0, 0x00, 0xAE, 0xBE, 0xA4,
-    0x25, 0x15, 0x20, 0xA0, 0x02, 0x61, 0x0C, 0x02, 0x20, 0x42, 0x08, 0x20, 0x2C, 0x30, 0x14, 0x02, 0x02, 0x28, 0x82, 0x00, 0x03, 0xAC, 0xC1, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x08, 0x12, 0x00, 0x08, 0x00, 0x28, 0x00, 0x0A, 0xCF, 0xEE, 0x20, 0x0B, 0x62, 0x2E, 0x20, 0x02, 0x10, 0x82, 0x40, 0x01, 0x44, 0xE4, 0x40, 0x03, 0x00, 0x0E, 0x00, 0x8D, 0xEA, 0xAC, 0x00,
-    0x02, 0x10, 0x0A, 0x00, 0x01, 0xE0, 0x24, 0x00, 0x0C, 0x21, 0x02, 0x00, 0x09, 0x42, 0x21, 0x00, 0x00, 0xCC, 0xF4, 0x40, 0x02, 0xBF, 0xD4, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x04, 0x44, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x44, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x40, 0x00, 0x0C, 0xCC, 0xC4, 0x40, 0x00, 0x0C, 0xC0, 0x00, 0x00, 0x02, 0xA0, 0x40,
-    0x00, 0x0C, 0xC0, 0x00, 0x04, 0xCE, 0x64, 0x40, 0x02, 0x08, 0x80, 0x00, 0x00, 0x90, 0x00, 0x40, 0x28, 0xA8, 0x80, 0x00, 0x08, 0x01, 0x04, 0x00, 0x0A, 0x88, 0x80, 0x00, 0x04, 0x44, 0x40, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x54, 0x44, 0x00, 0xEE, 0xFE, 0xE0, 0x00, 0x09, 0x3B, 0x3F, 0x00,
-    0x21, 0xD8, 0x20, 0x00, 0x00, 0x54, 0x4F, 0x00, 0x18, 0x58, 0x20, 0x00, 0x00, 0x01, 0x86, 0x00, 0xC6, 0x7E, 0x40, 0x00, 0x00, 0xEF, 0x66, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x80, 0x04, 0x00, 0x00, 0xC0, 0x20, 0x00, 0xAA, 0xAA, 0xEA, 0x20, 0xEF, 0xFF, 0xFF, 0x00, 0x80, 0x44, 0x19, 0x30, 0x00, 0x49, 0x24, 0x00, 0xC5, 0x35, 0x1B, 0x10, 0x00, 0x4B, 0x24, 0x00,
-    0x01, 0x35, 0xA0, 0x00, 0x8C, 0xA9, 0xAC, 0x80, 0x00, 0x2C, 0x00, 0x00, 0x04, 0x21, 0xA4, 0x00, 0x2A, 0x84, 0x00, 0x00, 0x73, 0x11, 0xF1, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x0B, 0x11, 0x19, 0x00, 0x00, 0x40, 0x00, 0x00, 0x8F, 0xEE, 0xEF, 0xE0, 0x0B, 0x76, 0x66, 0xD0, 0x1A, 0x00, 0x0B, 0x40, 0x4C, 0x40, 0x02, 0xD0, 0x28, 0x00, 0x1A, 0x40, 0x01, 0xD0, 0x2C, 0x10,
-    0x00, 0x00, 0x38, 0x40, 0x00, 0x40, 0x28, 0x10, 0x00, 0x01, 0xA0, 0x40, 0x00, 0x42, 0x83, 0x00, 0x05, 0xFE, 0x44, 0x40, 0x03, 0xFD, 0x54, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x09, 0x99, 0x9B, 0x00, 0x00, 0x10, 0x20, 0x00, 0x07, 0x26, 0x21, 0x40, 0x2A, 0xFE, 0xEE, 0xA0, 0x8D, 0x8C, 0xA9, 0xC0, 0x00, 0x10, 0x20, 0x80, 0x32, 0x33, 0xB3, 0x60, 0x00, 0x19, 0x28, 0x00,
-    0x00, 0x00, 0xA1, 0x40, 0x00, 0x10, 0xB1, 0x00, 0x00, 0x08, 0x34, 0x00, 0x00, 0x1A, 0x08, 0x00, 0x05, 0xF7, 0x40, 0x00, 0x8E, 0xF4, 0x44, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x08, 0x14, 0x02, 0x80, 0x00, 0x04, 0x00, 0x00, 0x1D, 0x11, 0xDB, 0x00, 0xDD, 0xFD, 0xDD, 0xD0, 0x0C, 0x88, 0x07, 0x00, 0x02, 0x06, 0x00, 0x90, 0x48, 0x00, 0x34, 0x00, 0x2C, 0x04, 0x2C, 0x10,
-    0x48, 0x11, 0x21, 0x40, 0x04, 0x84, 0x83, 0x40, 0x59, 0x03, 0x00, 0x50, 0x40, 0x0C, 0x10, 0x60, 0x42, 0xA9, 0x88, 0xC0, 0x40, 0x15, 0x80, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x11, 0x02, 0x00, 0x40, 0x08, 0x98, 0x88, 0x80, 0x08, 0xF9, 0x98, 0xC0, 0x06, 0x77, 0x75, 0x50, 0x02, 0x0C, 0x05, 0x00, 0x19, 0x98, 0xA8, 0xD0, 0x0B, 0x99, 0xCA, 0x80, 0x04, 0x54, 0x65, 0xC0,
-    0x20, 0x08, 0x50, 0x20, 0x00, 0x10, 0x20, 0xC0, 0x31, 0x1C, 0x04, 0x20, 0x00, 0x01, 0x28, 0x40, 0x26, 0x63, 0xBB, 0xE0, 0x26, 0xEF, 0xE6, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x01, 0x02, 0x01, 0x00, 0xC8, 0xC0, 0x00, 0x00, 0x0F, 0x8A, 0x89, 0x80, 0xC3, 0xF3, 0x11, 0x30, 0x0F, 0x02, 0x01, 0x80, 0xC9, 0xC0, 0x00, 0x30, 0x0F, 0x02, 0x05, 0xA0, 0x00, 0x00, 0x00, 0x30,
-    0x0E, 0x02, 0x05, 0xA0, 0x00, 0x00, 0x00, 0x30, 0x0E, 0x02, 0x52, 0x80, 0x00, 0x00, 0x03, 0x00, 0x2C, 0xDF, 0xA8, 0x80, 0x02, 0x33, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x03, 0x88, 0x00, 0x01, 0x02, 0x80, 0x00, 0x03, 0xFF, 0xF7, 0x00, 0x0F, 0x26, 0xE4, 0x72, 0xCC, 0x38, 0x00, 0x40, 0x0C, 0x38, 0x99, 0x00, 0x03, 0x0A, 0x31, 0x50, 0x0C, 0xB1, 0x82, 0x80,
-    0x03, 0x28, 0x06, 0x00, 0x87, 0x88, 0x2A, 0xA0, 0x01, 0x05, 0xC2, 0x00, 0x85, 0x82, 0xC2, 0x80, 0x10, 0x00, 0x39, 0x10, 0x08, 0x51, 0xBF, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x80, 0x04, 0x00, 0x48, 0x9D, 0xCC, 0x40, 0xC9, 0xE6, 0x7F, 0x40, 0x40, 0x00, 0x94, 0x00, 0x5B, 0x21, 0x0C, 0xB0, 0x48, 0xAE, 0xCC, 0x40, 0xE1, 0x30, 0x0C, 0x30, 0x43, 0x01, 0xA4, 0x00,
-    0xE1, 0x24, 0x5D, 0x30, 0x78, 0x8C, 0xD6, 0x10, 0xF1, 0x60, 0x94, 0x70, 0xD0, 0x40, 0x9C, 0x70, 0x0B, 0x8C, 0x53, 0x00, 0x0C, 0x9D, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x01, 0x39, 0x50, 0x00, 0x00, 0x88, 0xF0, 0x00, 0x2E, 0xAF, 0xC6, 0x00, 0x03, 0x01, 0x77, 0x60, 0x04, 0xF0, 0x41, 0x60, 0x03, 0x92, 0xF8, 0x12, 0x0F, 0xBD, 0x91, 0x40, 0x1B, 0x28, 0x60, 0x92,
-    0x70, 0xF4, 0x01, 0xF0, 0x0A, 0xD4, 0x65, 0x82, 0x53, 0xE0, 0x01, 0xE0, 0x04, 0x10, 0x68, 0x60, 0x04, 0x2A, 0xBE, 0x00, 0x00, 0x4F, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x02, 0x3A, 0xEE, 0x00, 0xC8, 0xC0, 0x00, 0x00, 0x0D, 0x84, 0xA5, 0x00, 0xC1, 0xC2, 0x11, 0x00, 0x45, 0x0E, 0x27, 0x00, 0xD9, 0xC3, 0x00, 0x10, 0x07, 0xF8, 0x8D, 0x20, 0x01, 0x30, 0x00, 0x10,
-    0xAC, 0x02, 0x25, 0xA0, 0x01, 0x22, 0x00, 0x10, 0x44, 0x20, 0x16, 0xA0, 0x13, 0x02, 0x00, 0x30, 0x04, 0x1B, 0xAA, 0x40, 0x21, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+u8 sGfxPrintFontData[(16 * 256) / 2] = {
+    0x00, 0xDF, 0xFD, 0x00, 0x0A, 0xEE, 0xFF, 0xA0, 0x0D, 0xF2, 0x2D, 0xD0, 0x06, 0x61, 0x1D, 0xC0, 0x01, 0x12, 0x2D,
+    0xD0, 0x06, 0x71, 0x99, 0x00, 0x01, 0x1E, 0xED, 0x10, 0x07, 0x7E, 0xF7, 0x00, 0x01, 0x56, 0x29, 0x90, 0x05, 0x58,
+    0x97, 0x60, 0x0D, 0xD2, 0x29, 0x90, 0x05, 0x59, 0x97, 0x70, 0x04, 0xDF, 0xFD, 0x40, 0x02, 0x6E, 0xF7, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0xBF, 0xFB, 0x00, 0x0E, 0xFF, 0xFF, 0xC0, 0x0B, 0xF0, 0x0F, 0xB0,
+    0x0F, 0xF0, 0x03, 0x30, 0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x02, 0x20, 0x0C, 0xFB, 0xBF, 0x60, 0x0F, 0xFC, 0xCE,
+    0x20, 0x0D, 0xD4, 0x4F, 0xF0, 0x0F, 0xF0, 0x02, 0x20, 0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x03, 0x30, 0x0C, 0xFB,
+    0xBF, 0x40, 0x0E, 0xF7, 0x77, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xDF, 0xFD, 0x00, 0x0A,
+    0xEE, 0xFF, 0xA0, 0x0D, 0xF2, 0x2D, 0xD0, 0x06, 0x61, 0x1D, 0xC0, 0x01, 0x12, 0x2D, 0xD0, 0x06, 0x71, 0x99, 0x00,
+    0x01, 0x1E, 0xED, 0x10, 0x07, 0x7E, 0xF7, 0x00, 0x01, 0x56, 0x29, 0x90, 0x05, 0x58, 0x97, 0x60, 0x0D, 0xD2, 0x29,
+    0x90, 0x05, 0x59, 0x97, 0x70, 0x04, 0xDF, 0xFD, 0x40, 0x02, 0x6E, 0xF7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x08, 0xBF, 0xFB, 0x00, 0x00, 0x0D, 0xE0, 0x00, 0x0B, 0xF0, 0x0F, 0xB0, 0x00, 0x5D, 0xE6, 0x00, 0x0F,
+    0xF0, 0x0F, 0xF0, 0x05, 0x5C, 0xC6, 0x60, 0x0C, 0xFB, 0xBF, 0x60, 0x77, 0x3F, 0xF3, 0x77, 0x0D, 0xD4, 0x4F, 0xF0,
+    0xBB, 0x3F, 0xF3, 0xBB, 0x0F, 0xF0, 0x0F, 0xF0, 0x09, 0x9C, 0xCA, 0xA0, 0x0C, 0xFB, 0xBF, 0x40, 0x00, 0x9D, 0xEA,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D, 0xE0, 0x00, 0x04, 0xC2, 0x2C, 0x40, 0x02, 0x8D, 0x50, 0x20, 0x0C, 0xCA,
+    0xAC, 0xC0, 0x21, 0xF9, 0x17, 0x10, 0x04, 0xC2, 0x2C, 0x40, 0x12, 0x49, 0x34, 0x00, 0x00, 0x82, 0x08, 0x00, 0x01,
+    0x97, 0x51, 0x10, 0x08, 0x8A, 0x88, 0x80, 0x04, 0x61, 0x52, 0x41, 0x00, 0x80, 0x08, 0x00, 0x43, 0x11, 0x75, 0x30,
+    0x00, 0xA2, 0x08, 0x00, 0x60, 0x05, 0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x40, 0x00, 0x40, 0x00, 0x22, 0x11,
+    0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x0F, 0xB0, 0x00, 0x00, 0x00, 0x08, 0x80, 0x04, 0x0D, 0xA4, 0x00, 0x00, 0x00,
+    0x88, 0x00, 0x08, 0xCD, 0xE8, 0x80, 0x02, 0x2A, 0xA2, 0x20, 0x08, 0xCD, 0xE8, 0x80, 0x02, 0xAA, 0x22, 0x20, 0x04,
+    0x0D, 0xA4, 0x00, 0x0C, 0xD1, 0x00, 0x00, 0x00, 0x0F, 0xB0, 0x00, 0x8C, 0x51, 0x00, 0x00, 0x00, 0x22, 0x11, 0x00,
+    0x81, 0x10, 0x00, 0x00, 0x00, 0xDF, 0xFD, 0x00, 0x0A, 0xEE, 0xFF, 0xA0, 0x0D, 0xF2, 0x2D, 0xD0, 0x06, 0x61, 0x1D,
+    0xC0, 0x01, 0x12, 0x2D, 0xD0, 0x06, 0x71, 0x99, 0x00, 0x01, 0x1E, 0xED, 0x10, 0x07, 0x7E, 0xF7, 0x00, 0x01, 0x56,
+    0x29, 0x90, 0x05, 0x58, 0x97, 0x60, 0x0D, 0xD2, 0x29, 0x90, 0x05, 0x59, 0x97, 0x70, 0x04, 0xDF, 0xFD, 0x40, 0x02,
+    0x6E, 0xF7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x33, 0x00, 0x04, 0x48, 0x99, 0x80,
+    0x03, 0x3C, 0xC3, 0x30, 0x00, 0xCD, 0x10, 0x88, 0x03, 0x3C, 0xC3, 0x30, 0x02, 0xBF, 0x62, 0xA8, 0x00, 0x33, 0x33,
+    0x20, 0x01, 0x10, 0x4C, 0x80, 0x01, 0x10, 0x03, 0x30, 0x00, 0x15, 0xC8, 0x00, 0x03, 0x3C, 0xC3, 0x30, 0x02, 0x67,
+    0x32, 0x20, 0x00, 0x3F, 0xF3, 0x00, 0x04, 0x40, 0x99, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0xDF, 0xFD, 0x10, 0x07, 0xFF, 0xFF, 0x60, 0x1C, 0xE0, 0x0E, 0xC1, 0x0F, 0xF0, 0x09, 0x90, 0x1E, 0xE1, 0x16, 0x61,
+    0x0F, 0xF0, 0x01, 0x10, 0x1E, 0xF4, 0x56, 0x21, 0x0F, 0xF6, 0x67, 0x10, 0x1E, 0xF2, 0x36, 0x61, 0x0F, 0xF0, 0x89,
+    0x90, 0x1E, 0xF1, 0x0F, 0xE1, 0x0F, 0xF0, 0x09, 0x90, 0x16, 0xEC, 0xCE, 0x21, 0x07, 0xFB, 0xBB, 0x20, 0x01, 0x11,
+    0x11, 0x10, 0x00, 0x00, 0x00, 0x00, 0x09, 0xB6, 0x6F, 0xD0, 0x27, 0xD8, 0x8E, 0x60, 0x09, 0x92, 0xED, 0x10, 0x2F,
+    0xF0, 0x2E, 0xE0, 0x09, 0x9A, 0xE5, 0x10, 0x2F, 0xF6, 0x2E, 0xE0, 0x09, 0x9B, 0x75, 0x10, 0x2F, 0xD6, 0x4E, 0xE0,
+    0x0D, 0xDA, 0xE5, 0x10, 0x2F, 0xD0, 0x4E, 0xE0, 0x0D, 0xD2, 0xED, 0x10, 0x2F, 0xD0, 0x0E, 0xE0, 0x09, 0xF6, 0x6F,
+    0x90, 0x27, 0xD9, 0x9F, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFF, 0x00, 0x8F, 0x71,
+    0x1F, 0xF0, 0x2F, 0xD0, 0x0F, 0xF0, 0x8F, 0x71, 0x1F, 0xF0, 0x2F, 0xD0, 0x07, 0x70, 0x8E, 0x61, 0x1E, 0xE0, 0x27,
+    0xDD, 0xDF, 0x60, 0x8E, 0x69, 0x1E, 0xE0, 0x27, 0x76, 0x4A, 0xA0, 0x8E, 0xE9, 0x9E, 0xE0, 0x2F, 0xD0, 0x6E, 0x80,
+    0x8A, 0xE7, 0xFE, 0xA0, 0x07, 0xFA, 0x8E, 0x60, 0x88, 0x27, 0x7A, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x07, 0x7C, 0xCF, 0xF0, 0x13, 0x26, 0x60, 0x11, 0x07, 0x7C, 0xCF, 0xF0, 0x03, 0x76, 0x65, 0x10, 0x02, 0x39,
+    0xD7, 0x20, 0x04, 0x53, 0x35, 0x40, 0x00, 0x2F, 0xF2, 0x00, 0x01, 0x13, 0x31, 0x10, 0x00, 0x5F, 0xB1, 0x00, 0x00,
+    0x03, 0x30, 0x00, 0x05, 0x5E, 0xE5, 0x50, 0x01, 0x13, 0x31, 0x10, 0x05, 0x5E, 0xED, 0xD0, 0x02, 0x23, 0x30, 0x00,
+    0x00, 0x08, 0x88, 0x80, 0x8A, 0xAB, 0xB8, 0x88, 0x00, 0x00, 0x11, 0x00, 0x00, 0x04, 0x45, 0x10, 0x04, 0x62, 0x33,
+    0x20, 0x00, 0x44, 0x01, 0x10, 0x04, 0xC8, 0x9A, 0xA0, 0x00, 0xEE, 0xAB, 0x10, 0x0C, 0xE6, 0x67, 0x20, 0x0E, 0xF5,
+    0x5F, 0xB0, 0x0E, 0xE0, 0x06, 0x60, 0x0B, 0xF6, 0x2B, 0x90, 0x0E, 0xE0, 0x06, 0x60, 0x03, 0xFC, 0x89, 0x90, 0x04,
+    0xEE, 0xEE, 0xA0, 0x00, 0x77, 0x3B, 0xB0, 0x00, 0x00, 0x00, 0x00, 0x08, 0x88, 0x88, 0x00, 0x09, 0x90, 0x00, 0x00,
+    0x00, 0x11, 0x10, 0x00, 0x09, 0x92, 0x24, 0x40, 0x00, 0x01, 0x10, 0x00, 0x09, 0x90, 0x88, 0x00, 0x26, 0xEF, 0xDE,
+    0x20, 0x09, 0x9B, 0xB5, 0x40, 0x2E, 0xC3, 0x3C, 0xE2, 0x0D, 0x9A, 0x25, 0x50, 0x2E, 0xC3, 0x3C, 0xE2, 0x0D, 0xDA,
+    0xA5, 0x50, 0x2E, 0xC3, 0x3C, 0xE2, 0x09, 0xD6, 0xED, 0x10, 0x26, 0xCB, 0xBC, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x10, 0x00,
+    0x05, 0xFB, 0xFF, 0xE0, 0x8E, 0x61, 0x16, 0xE8, 0x0F, 0xF4, 0x03, 0x30, 0x8F, 0x71, 0x17, 0xF8, 0x07, 0xFC, 0x8B,
+    0x30, 0x8E, 0x69, 0x96, 0xE8, 0x05, 0x73, 0x3B, 0xA0, 0x8A, 0x6D, 0xD6, 0xA8, 0x0D, 0xD8, 0x8A, 0x20, 0x08, 0xA7,
+    0x79, 0xB2, 0x01, 0x10, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x8A, 0x01, 0x10, 0x00, 0x00,
+    0x00, 0x08, 0x00, 0x80, 0xA1, 0x10, 0x00, 0x07, 0x74, 0x4F, 0x70, 0x80, 0xA9, 0x90, 0x00, 0x02, 0x31, 0xDF, 0x20,
+    0x84, 0xE6, 0x00, 0x04, 0x00, 0x27, 0xDA, 0x20, 0xC8, 0xAA, 0x4C, 0x40, 0x00, 0x57, 0x3B, 0x20, 0x00, 0xA1, 0x18,
+    0x00, 0x05, 0x54, 0x6F, 0x50, 0x00, 0xA9, 0x98, 0x00, 0x02, 0x22, 0x20, 0x80, 0x02, 0x00, 0x18, 0x88, 0x00, 0x04,
+    0x44, 0x40, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x44, 0x40, 0x0C, 0x44, 0x44, 0x00, 0x00, 0x04, 0x40, 0x00, 0x88,
+    0xC0, 0x00, 0x00, 0x00, 0x0C, 0xC0, 0x00, 0x0C, 0x46, 0xA4, 0x40, 0x00, 0x0C, 0xC0, 0x00, 0x08, 0x8E, 0xE0, 0x00,
+    0x02, 0x08, 0x80, 0x00, 0x80, 0xD0, 0x88, 0x00, 0x28, 0xA8, 0x80, 0x00, 0x88, 0xCD, 0x4C, 0x40, 0x0A, 0x88, 0x80,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0xE0, 0x08, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x08, 0x88, 0x00, 0x80, 0x01, 0x06, 0x10, 0x00, 0x56, 0xE7, 0x50, 0x80, 0x02, 0x1F, 0xF1, 0x00, 0x38,
+    0x8C, 0xB8, 0x00, 0x0B, 0xF6, 0x0B, 0x00, 0x94, 0xC0, 0x28, 0x00, 0x06, 0x07, 0x6A, 0x00, 0xCB, 0xA6, 0xC8, 0x00,
+    0x00, 0x47, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x80, 0x00, 0x00, 0x39, 0x14,
+    0x20, 0x02, 0x22, 0x24, 0x00, 0x08, 0xAE, 0xA8, 0x60, 0x04, 0x28, 0x99, 0x70, 0x07, 0x75, 0xD1, 0x04, 0x0F, 0xB3,
+    0x33, 0xD0, 0x00, 0xAE, 0xBE, 0xA4, 0x25, 0x15, 0x20, 0xA0, 0x02, 0x61, 0x0C, 0x02, 0x20, 0x42, 0x08, 0x20, 0x2C,
+    0x30, 0x14, 0x02, 0x02, 0x28, 0x82, 0x00, 0x03, 0xAC, 0xC1, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x08, 0x12, 0x00, 0x08, 0x00, 0x28, 0x00, 0x0A, 0xCF, 0xEE, 0x20, 0x0B, 0x62, 0x2E, 0x20, 0x02, 0x10, 0x82,
+    0x40, 0x01, 0x44, 0xE4, 0x40, 0x03, 0x00, 0x0E, 0x00, 0x8D, 0xEA, 0xAC, 0x00, 0x02, 0x10, 0x0A, 0x00, 0x01, 0xE0,
+    0x24, 0x00, 0x0C, 0x21, 0x02, 0x00, 0x09, 0x42, 0x21, 0x00, 0x00, 0xCC, 0xF4, 0x40, 0x02, 0xBF, 0xD4, 0x40, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x44, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x44, 0x40,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x40, 0x00, 0x0C, 0xCC, 0xC4, 0x40, 0x00, 0x0C, 0xC0, 0x00, 0x00, 0x02, 0xA0,
+    0x40, 0x00, 0x0C, 0xC0, 0x00, 0x04, 0xCE, 0x64, 0x40, 0x02, 0x08, 0x80, 0x00, 0x00, 0x90, 0x00, 0x40, 0x28, 0xA8,
+    0x80, 0x00, 0x08, 0x01, 0x04, 0x00, 0x0A, 0x88, 0x80, 0x00, 0x04, 0x44, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x54, 0x44, 0x00,
+    0xEE, 0xFE, 0xE0, 0x00, 0x09, 0x3B, 0x3F, 0x00, 0x21, 0xD8, 0x20, 0x00, 0x00, 0x54, 0x4F, 0x00, 0x18, 0x58, 0x20,
+    0x00, 0x00, 0x01, 0x86, 0x00, 0xC6, 0x7E, 0x40, 0x00, 0x00, 0xEF, 0x66, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x80, 0x04, 0x00, 0x00, 0xC0, 0x20, 0x00, 0xAA, 0xAA, 0xEA, 0x20, 0xEF, 0xFF, 0xFF, 0x00, 0x80,
+    0x44, 0x19, 0x30, 0x00, 0x49, 0x24, 0x00, 0xC5, 0x35, 0x1B, 0x10, 0x00, 0x4B, 0x24, 0x00, 0x01, 0x35, 0xA0, 0x00,
+    0x8C, 0xA9, 0xAC, 0x80, 0x00, 0x2C, 0x00, 0x00, 0x04, 0x21, 0xA4, 0x00, 0x2A, 0x84, 0x00, 0x00, 0x73, 0x11, 0xF1,
+    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x11, 0x19, 0x00, 0x00, 0x40, 0x00, 0x00, 0x8F, 0xEE,
+    0xEF, 0xE0, 0x0B, 0x76, 0x66, 0xD0, 0x1A, 0x00, 0x0B, 0x40, 0x4C, 0x40, 0x02, 0xD0, 0x28, 0x00, 0x1A, 0x40, 0x01,
+    0xD0, 0x2C, 0x10, 0x00, 0x00, 0x38, 0x40, 0x00, 0x40, 0x28, 0x10, 0x00, 0x01, 0xA0, 0x40, 0x00, 0x42, 0x83, 0x00,
+    0x05, 0xFE, 0x44, 0x40, 0x03, 0xFD, 0x54, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x99, 0x9B,
+    0x00, 0x00, 0x10, 0x20, 0x00, 0x07, 0x26, 0x21, 0x40, 0x2A, 0xFE, 0xEE, 0xA0, 0x8D, 0x8C, 0xA9, 0xC0, 0x00, 0x10,
+    0x20, 0x80, 0x32, 0x33, 0xB3, 0x60, 0x00, 0x19, 0x28, 0x00, 0x00, 0x00, 0xA1, 0x40, 0x00, 0x10, 0xB1, 0x00, 0x00,
+    0x08, 0x34, 0x00, 0x00, 0x1A, 0x08, 0x00, 0x05, 0xF7, 0x40, 0x00, 0x8E, 0xF4, 0x44, 0xC0, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x08, 0x14, 0x02, 0x80, 0x00, 0x04, 0x00, 0x00, 0x1D, 0x11, 0xDB, 0x00, 0xDD, 0xFD, 0xDD,
+    0xD0, 0x0C, 0x88, 0x07, 0x00, 0x02, 0x06, 0x00, 0x90, 0x48, 0x00, 0x34, 0x00, 0x2C, 0x04, 0x2C, 0x10, 0x48, 0x11,
+    0x21, 0x40, 0x04, 0x84, 0x83, 0x40, 0x59, 0x03, 0x00, 0x50, 0x40, 0x0C, 0x10, 0x60, 0x42, 0xA9, 0x88, 0xC0, 0x40,
+    0x15, 0x80, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x02, 0x00, 0x40, 0x08, 0x98, 0x88, 0x80,
+    0x08, 0xF9, 0x98, 0xC0, 0x06, 0x77, 0x75, 0x50, 0x02, 0x0C, 0x05, 0x00, 0x19, 0x98, 0xA8, 0xD0, 0x0B, 0x99, 0xCA,
+    0x80, 0x04, 0x54, 0x65, 0xC0, 0x20, 0x08, 0x50, 0x20, 0x00, 0x10, 0x20, 0xC0, 0x31, 0x1C, 0x04, 0x20, 0x00, 0x01,
+    0x28, 0x40, 0x26, 0x63, 0xBB, 0xE0, 0x26, 0xEF, 0xE6, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x02, 0x01, 0x00, 0xC8, 0xC0, 0x00, 0x00, 0x0F, 0x8A, 0x89, 0x80, 0xC3, 0xF3, 0x11, 0x30, 0x0F, 0x02, 0x01, 0x80,
+    0xC9, 0xC0, 0x00, 0x30, 0x0F, 0x02, 0x05, 0xA0, 0x00, 0x00, 0x00, 0x30, 0x0E, 0x02, 0x05, 0xA0, 0x00, 0x00, 0x00,
+    0x30, 0x0E, 0x02, 0x52, 0x80, 0x00, 0x00, 0x03, 0x00, 0x2C, 0xDF, 0xA8, 0x80, 0x02, 0x33, 0x30, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x88, 0x00, 0x01, 0x02, 0x80, 0x00, 0x03, 0xFF, 0xF7, 0x00, 0x0F,
+    0x26, 0xE4, 0x72, 0xCC, 0x38, 0x00, 0x40, 0x0C, 0x38, 0x99, 0x00, 0x03, 0x0A, 0x31, 0x50, 0x0C, 0xB1, 0x82, 0x80,
+    0x03, 0x28, 0x06, 0x00, 0x87, 0x88, 0x2A, 0xA0, 0x01, 0x05, 0xC2, 0x00, 0x85, 0x82, 0xC2, 0x80, 0x10, 0x00, 0x39,
+    0x10, 0x08, 0x51, 0xBF, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x04, 0x00, 0x48, 0x9D,
+    0xCC, 0x40, 0xC9, 0xE6, 0x7F, 0x40, 0x40, 0x00, 0x94, 0x00, 0x5B, 0x21, 0x0C, 0xB0, 0x48, 0xAE, 0xCC, 0x40, 0xE1,
+    0x30, 0x0C, 0x30, 0x43, 0x01, 0xA4, 0x00, 0xE1, 0x24, 0x5D, 0x30, 0x78, 0x8C, 0xD6, 0x10, 0xF1, 0x60, 0x94, 0x70,
+    0xD0, 0x40, 0x9C, 0x70, 0x0B, 0x8C, 0x53, 0x00, 0x0C, 0x9D, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x01, 0x39, 0x50, 0x00, 0x00, 0x88, 0xF0, 0x00, 0x2E, 0xAF, 0xC6, 0x00, 0x03, 0x01, 0x77, 0x60, 0x04, 0xF0,
+    0x41, 0x60, 0x03, 0x92, 0xF8, 0x12, 0x0F, 0xBD, 0x91, 0x40, 0x1B, 0x28, 0x60, 0x92, 0x70, 0xF4, 0x01, 0xF0, 0x0A,
+    0xD4, 0x65, 0x82, 0x53, 0xE0, 0x01, 0xE0, 0x04, 0x10, 0x68, 0x60, 0x04, 0x2A, 0xBE, 0x00, 0x00, 0x4F, 0x80, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x3A, 0xEE, 0x00, 0xC8, 0xC0, 0x00, 0x00, 0x0D, 0x84, 0xA5,
+    0x00, 0xC1, 0xC2, 0x11, 0x00, 0x45, 0x0E, 0x27, 0x00, 0xD9, 0xC3, 0x00, 0x10, 0x07, 0xF8, 0x8D, 0x20, 0x01, 0x30,
+    0x00, 0x10, 0xAC, 0x02, 0x25, 0xA0, 0x01, 0x22, 0x00, 0x10, 0x44, 0x20, 0x16, 0xA0, 0x13, 0x02, 0x00, 0x30, 0x04,
+    0x1B, 0xAA, 0x40, 0x21, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
 };
 
-#define	gDPSetPrimColorMod(pkt, m, l, rgba)				\
-_DW({									\
-	Gfx *_g = (Gfx *)(pkt);						\
-									\
-	_g->words.w0 =	(_SHIFTL(G_SETPRIMCOLOR, 24, 8) | 		\
-			 _SHIFTL(m, 8, 8) | _SHIFTL(l, 0, 8));		\
-	_g->words.w1 =  (rgba);		\
-})
+#define gDPSetPrimColorMod(pkt, m, l, rgba)                                                    \
+    _DW({                                                                                      \
+        Gfx* _g = (Gfx*)(pkt);                                                                 \
+                                                                                               \
+        _g->words.w0 = (_SHIFTL(G_SETPRIMCOLOR, 24, 8) | _SHIFTL(m, 8, 8) | _SHIFTL(l, 0, 8)); \
+        _g->words.w1 = (rgba);                                                                 \
+    })
 
 #ifdef NON_MATCHING
-void GfxPrint_InitDlist(GfxPrint* this)
-{
-    u32 palette;
-    u32 tile;
+// regalloc and minor ordering differences
+void GfxPrint_InitDlist(GfxPrint* this) {
+    s32 width = 16;
+    s32 height = 256;
+    s32 i;
 
     gDPPipeSync(this->dlist++);
-    gDPSetOtherMode(this->dlist++, 0xECF0, 0x504244);
-    gDPSetCombineLERP(this->dlist++, K5, K5, 0, TEXEL0, 0, 0, 0, TEXEL0, K5, K5, 0, TEXEL0, 0, 0, 0, TEXEL0);
-    gDPLoadTextureBlock(this->dlist++, sGfxPrintFontData, G_IM_FMT_CI, G_IM_SIZ_4b, 16, 256, 0, 0, 0, 0, 0, 0, 0); //? missmatch here
-    gDPLoadTLUT(this->dlist++, 64, 0x100, sGfxPrintFontTLUT);
+    gDPSetOtherMode(this->dlist++,
+                    G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_IA16 | G_TL_TILE |
+                        G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                    G_AC_NONE | G_ZS_PRIM | G_RM_XLU_SURF | G_RM_XLU_SURF2);
+    gDPSetCombineMode(this->dlist++, G_CC_DECALRGBA, G_CC_DECALRGBA);
+
+    gDPSetTextureImage(this->dlist++, G_IM_FMT_CI, G_IM_SIZ_4b_LOAD_BLOCK, 1, sGfxPrintFontData);
+    gDPSetTile(this->dlist++, G_IM_FMT_CI, G_IM_SIZ_4b_LOAD_BLOCK, 0, 0, G_TX_LOADTILE, 0, G_TX_NOMIRROR | G_TX_WRAP,
+               G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+    gDPLoadSync(this->dlist++);
+    gDPLoadBlock(this->dlist++, G_TX_LOADTILE, 0, 0, (((width) * (height) + G_IM_SIZ_4b_INCR) >> G_IM_SIZ_4b_SHIFT) - 1,
+                 CALC_DXT(width, G_IM_SIZ_4b_BYTES));
+    gDPPipeSync(this->dlist++);
+    gDPSetTile(this->dlist++, G_IM_FMT_CI, G_IM_SIZ_4b, 1, 0, G_TX_RENDERTILE, 0, G_TX_NOMIRROR | G_TX_WRAP,
+               G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+    gDPSetTileSize(this->dlist++, G_TX_RENDERTILE, 0, 0, ((width)-1) << G_TEXTURE_IMAGE_FRAC,
+                   ((height)-1) << G_TEXTURE_IMAGE_FRAC);
 
-    tile = 2;
-    palette = 1;
-    do
-    {
-        gDPSetTile(this->dlist++, G_IM_FMT_CI, G_IM_SIZ_4b, 1, 0x0, tile, palette++, G_TX_NOMIRROR | G_TX_CLAMP, 0, 0, G_TX_NOMIRROR | G_TX_CLAMP, 0, 0);
-        gDPSetTileSize(this->dlist++, tile, 0, 0, 15, 255);
-        tile+=2;
+    gDPLoadTLUT(this->dlist++, 64, 256, sGfxPrintFontTLUT);
 
-    } while (palette < 4);
+    for (i = 1; i < 4; i++) {
+        gDPSetTile(this->dlist++, G_IM_FMT_CI, G_IM_SIZ_4b, 1, 0, i * 2, i, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK,
+                   G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+        gDPSetTileSize(this->dlist++, i * 2, 0, 0, 60, 1020);
+    }
 
     gDPSetPrimColorMod(this->dlist++, 0, 0, *(u32*)&this->color);
-    gDPLoadTextureTile(this->dlist++, sGfxPrintUnkData, G_IM_FMT_CI, G_IM_SIZ_8b, 1, 0, 0, 0, 0, 7, 0, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, 1, 3, 0, 0);
-    gDPLoadTLUT(this->dlist++, 16, 0x140, sGfxPrintUnkTLUT);
-
-    tile = 3;
-    do
-    {
-        gDPSetTile(this->dlist++, G_IM_FMT_CI, G_IM_SIZ_4b, tile, 0x0, G_TX_RENDERTILE, 4, G_TX_NOMIRROR | G_TX_WRAP, 3, 0, G_TX_NOMIRROR | G_TX_WRAP, 1, 0);
-        gDPSetTileSize(this->dlist++, tile, 0, 0, 1, 7);
-        tile += 2;
-    } while (tile != 9);
+
+    gDPSetTextureImage(this->dlist++, G_IM_FMT_CI, G_IM_SIZ_8b, 1, sGfxPrintUnkData);
+    gDPSetTile(this->dlist++, G_IM_FMT_CI, G_IM_SIZ_8b, 1, 0, G_TX_LOADTILE, 0, G_TX_NOMIRROR | G_TX_WRAP, 3,
+               G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, 1, G_TX_NOLOD);
+    gDPLoadSync(this->dlist++);
+    gDPLoadTile(this->dlist++, G_TX_LOADTILE, 0, 0, 2, 28);
+    gDPPipeSync(this->dlist++);
+    gDPSetTile(this->dlist++, G_IM_FMT_CI, G_IM_SIZ_8b, 1, 0, 1, 4, G_TX_NOMIRROR | G_TX_WRAP, 3, G_TX_NOLOD,
+               G_TX_NOMIRROR | G_TX_WRAP, 1, G_TX_NOLOD);
+    gDPSetTileSize(this->dlist++, 1, 0, 0, 4, 28);
+
+    gDPLoadTLUT(this->dlist++, 16, 320, sGfxPrintUnkTLUT);
+
+    for (i = 1; i < 4; i++) {
+        gDPSetTile(this->dlist++, G_IM_FMT_CI, G_IM_SIZ_4b, 1, 0, i * 2 + 1, 4, G_TX_NOMIRROR | G_TX_WRAP, 3,
+                   G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, 1, G_TX_NOLOD);
+        gDPSetTileSize(this->dlist++, i * 2 + 1, 0, 0, 4, 28);
+    }
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/gfxprint/GfxPrint_InitDlist.s")
 #endif
 
-
-void GfxPrint_SetColor(GfxPrint* this, u32 r, u32 g, u32 b, u32 a)
-{
+void GfxPrint_SetColor(GfxPrint* this, u32 r, u32 g, u32 b, u32 a) {
     this->color.r = r;
     this->color.g = g;
     this->color.b = b;
@@ -162,193 +207,141 @@ void GfxPrint_SetColor(GfxPrint* this, u32 r, u32 g, u32 b, u32 a)
     gDPSetPrimColorMod(this->dlist++, 0, 0, *(u32*)&this->color);
 }
 
-
-void GfxPrint_SetPosPx(GfxPrint* this, s32 x, s32 y)
-{
+void GfxPrint_SetPosPx(GfxPrint* this, s32 x, s32 y) {
     this->posX = this->baseX + (x << 2);
     this->posY = this->baseY + (y << 2);
 }
 
-void GfxPrint_SetPos(GfxPrint* this, s32 x, s32 y)
-{
+void GfxPrint_SetPos(GfxPrint* this, s32 x, s32 y) {
     GfxPrint_SetPosPx(this, x << 3, y << 3);
 }
 
-void GfxPrint_SetBasePosPx(GfxPrint* this, s32 x, s32 y)
-{
+void GfxPrint_SetBasePosPx(GfxPrint* this, s32 x, s32 y) {
     this->baseX = x << 2;
     this->baseY = y << 2;
 }
 
-//close from matching
 #ifdef NON_MATCHING
-void GfxPrint_PrintCharImpl(GfxPrint* this, u8 c)
-{
-    u32 test;
-    u32 test2;
-
-    if (this->flag & GFXPRINT_UPDATE_MODE)
-    {
+// regalloc and ordering differences
+void GfxPrint_PrintCharImpl(GfxPrint* this, u8 c) {
+    if (this->flag & GFXPRINT_UPDATE_MODE) {
         this->flag &= ~GFXPRINT_UPDATE_MODE;
+
         gDPPipeSync(this->dlist++);
-        if (this->flag & GFXPRINT_USE_RGBA16)
-        {
+        if (this->flag & GFXPRINT_USE_RGBA16) {
             gDPSetTextureLUT(this->dlist++, G_TT_RGBA16);
             gDPSetCycleType(this->dlist++, G_CYC_2CYCLE);
             gDPSetRenderMode(this->dlist++, G_RM_OPA_CI, G_RM_XLU_SURF2);
-            gDPSetCombineLERP(this->dlist++, TEXEL0, K5, TEXEL1, COMBINED_ALPHA, TEXEL0, 0, TEXEL1, 0, K5, K5, 0, COMBINED, 0, 0, 0, COMBINED);
-        }
-        else
-        {
+            gDPSetCombineMode(this->dlist++, G_CC_INTERFERENCE, G_CC_PASS2);
+        } else {
             gDPSetTextureLUT(this->dlist++, G_TT_IA16);
             gDPSetCycleType(this->dlist++, G_CYC_1CYCLE);
             gDPSetRenderMode(this->dlist++, G_RM_XLU_SURF, G_RM_XLU_SURF2);
-            gDPSetCombineLERP(this->dlist++, TEXEL0, K5, PRIMITIVE, COMBINED_ALPHA, 0, 0, 0, TEXEL0, TEXEL0, K5, PRIMITIVE, COMBINED_ALPHA, 0, 0, 0, TEXEL0);
+            gDPSetCombineMode(this->dlist++, G_CC_MODULATEIDECALA_PRIM, G_CC_MODULATEIDECALA_PRIM);
         }
     }
 
-    test = (c & 4) << 6;
-    test2 = (c >> 3) << 8;
-    if (this->flag & GFXPRINT_FLAG4)
-    {
+    if (this->flag & GFXPRINT_FLAG4) {
         gDPSetPrimColorMod(this->dlist++, 0, 0, 0);
 
-        if (this->flag & GFXPRINT_FLAG64)
-            gSPTextureRectangle(this->dlist++, (this->posX+4)<<1, (this->posY+4)<<1, (this->posX+0x24)<<1, (this->posY+0x24)<<1, c<<1, test, test2, 512, 512); //c*2 ?
-        else
-            gSPTextureRectangle(this->dlist++, this->posX+4, this->posY+4, this->posX+0x24, this->posY+0x24, c<<1, test, test2, 1024, 1024);
+        if (this->flag & GFXPRINT_FLAG64) {
+            gSPTextureRectangle(this->dlist++, (this->posX + 4) << 1, (this->posY + 4) << 1, (this->posX + 4 + 32) << 1,
+                                (this->posY + 4 + 32) << 1, c * 2, (u16)(c & 4) * 64, (u16)(c >> 3) * 256, 512, 512);
+        } else {
+            gSPTextureRectangle(this->dlist++, this->posX + 4, this->posY + 4, this->posX + 4 + 32, this->posY + 4 + 32,
+                                c * 2, (u16)(c & 4) * 64, (u16)(c >> 3) * 256, 1024, 1024);
+        }
 
         gDPSetPrimColorMod(this->dlist++, 0, 0, *(u32*)&this->color);
     }
-    if (this->flag & GFXPRINT_FLAG64)
-        gSPTextureRectangle(this->dlist++, (this->posX)<<1, (this->posY)<<1, (this->posX + 0x20)<<1, (this->posY + 0x20)<<1, c << 1, test, test2, 512, 512);
-    else
-        gSPTextureRectangle(this->dlist++, this->posX, this->posY, this->posX + 0x20, this->posY + 0x20, c << 1, test, test2, 1024, 1024);
 
-    this->posX += 0x20;
+    if (this->flag & GFXPRINT_FLAG64) {
+        gSPTextureRectangle(this->dlist++, (this->posX) << 1, (this->posY) << 1, (this->posX + 32) << 1,
+                            (this->posY + 32) << 1, c * 2, (u16)(c & 4) * 64, (u16)(c >> 3) * 256, 512, 512);
+    } else {
+        gSPTextureRectangle(this->dlist++, this->posX, this->posY, this->posX + 32, this->posY + 32, c * 2,
+                            (u16)(c & 4) * 64, (u16)(c >> 3) * 256, 1024, 1024);
+    }
+
+    this->posX += 32;
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/gfxprint/GfxPrint_PrintCharImpl.s")
 #endif
 
+void GfxPrint_PrintChar(GfxPrint* this, u8 c) {
+    u8 charParam = c;
 
-#ifdef NON_MATCHING
-void GfxPrint_PrintChar(GfxPrint *this, char c)
-{
-    if (c == ' ')
+    if (c == ' ') {
         this->posX += 0x20;
-    else if (c > 0x20 && c < 0x7f)
-        GfxPrint_PrintCharImpl(this, c);
-    else if (c >= 0xa0 && c < 0xe0)
-    {
-        u8 charParam = c;
-        if ((this->flag & GFXPRINT_FLAG1) != 0)
-        {
-            if (c < 0xc0)
+    } else if (c > 0x20 && c < 0x7F) {
+        GfxPrint_PrintCharImpl(this, charParam);
+    } else if (c >= 0xA0 && c < 0xE0) {
+        if (this->flag & GFXPRINT_FLAG1) {
+            if (c < 0xC0) {
                 charParam = c - 0x20;
-            else
+            } else {
                 charParam = c + 0x20;
+            }
         }
         GfxPrint_PrintCharImpl(this, charParam);
-    }
-    else
-    {
-        switch(c)
-        {
+    } else {
+        switch (c) {
             case 0:
-                return;
-            case 1:
-            case 2:
-            case 3:
-            case 4:
-            case 5:
-            case 6:
-            case 7:
-            case 8:
-                return;
-            //tab
-            case 9:
-            {
-                u32 uVar1;
-                do {
-                    GfxPrint_PrintCharImpl(this, 0x20);
-                    uVar1 = this->posX - this->baseX;
-                    if (uVar1 < 0 && uVar1 != 0)
-                        uVar1 -= 0x100;
-                } while (uVar1 != 0);
-                return;
-            }
-            //line feed
-            case 0xa:
-            {
+                break;
+            case '\n':
                 this->posY += 0x20;
+            case '\r':
                 this->posX = this->baseX;
-                return;
-            }
-            /*
-            case 0xb:
-            case 0xc:
-                return;
-                */
-            //carriage return
-            case 0xd:
-            {
-                this->posX = this->baseX;
-                return;
-            }
-            case 0x8a:
-                this->flag &= ~GFXPRINT_USE_RGBA16;
-                this->flag |= GFXPRINT_UPDATE_MODE;
-                return;
-            case 0x8b:
+                break;
+            case '\t':
+                do {
+                    GfxPrint_PrintCharImpl(this, 0x20);
+                } while ((this->posX - this->baseX) % 256);
+                break;
+            case 0x8D:
+                this->flag |= GFXPRINT_FLAG1;
+                break;
+            case 0x8C:
+                this->flag &= ~GFXPRINT_FLAG1;
+                break;
+            case 0x8B:
                 this->flag |= GFXPRINT_USE_RGBA16;
                 this->flag |= GFXPRINT_UPDATE_MODE;
-                return;
-            case 0x8c:
-                this->flag &= ~GFXPRINT_FLAG1;
-                return;
-            case 0x8d:
-                this->flag |= GFXPRINT_FLAG1;
-                return;
-            case 0x8e:
+                break;
+            case 0x8A:
+                this->flag &= ~GFXPRINT_USE_RGBA16;
+                this->flag |= GFXPRINT_UPDATE_MODE;
+                break;
+            case 0x8E:
             default:
-                return;
+                break;
         }
-
     }
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/gfxprint/GfxPrint_PrintChar.s")
-#endif
 
-
-
-void GfxPrint_PrintStringWithSize(GfxPrint* this, const void* buffer, size_t charSize, size_t charCount)
-{
+void GfxPrint_PrintStringWithSize(GfxPrint* this, const void* buffer, size_t charSize, size_t charCount) {
     const char* str = (const char*)buffer;
     size_t count = charSize * charCount;
 
-    while (count)
-    {
+    while (count) {
         GfxPrint_PrintChar(this, *str++);
         count--;
     }
 }
 
-void GfxPrint_PrintString(GfxPrint* this, const char* str)
-{
-    while (*str)
+void GfxPrint_PrintString(GfxPrint* this, const char* str) {
+    while (*str) {
         GfxPrint_PrintChar(this, *(str++));
+    }
 }
 
-GfxPrint* GfxPrint_Callback(GfxPrint* this, const char* str, size_t size)
-{
+GfxPrint* GfxPrint_Callback(GfxPrint* this, const char* str, size_t size) {
     GfxPrint_PrintStringWithSize(this, str, sizeof(char), size);
     return this;
 }
 
-void GfxPrint_Ctor(GfxPrint* this)
-{
+void GfxPrint_Ctor(GfxPrint* this) {
     this->flag &= ~GFXPRINT_OPEN;
 
     this->callback = &GfxPrint_Callback;
@@ -364,31 +357,27 @@ void GfxPrint_Ctor(GfxPrint* this)
     this->flag |= GFXPRINT_FLAG4;
     this->flag |= GFXPRINT_UPDATE_MODE;
 
-    if ((D_801755F0 & GFXPRINT_FLAG64))
+    if ((D_801755F0 & GFXPRINT_FLAG64)) {
         this->flag |= GFXPRINT_FLAG64; //? dsdx/dtdy
-    else
+    } else {
         this->flag &= ~GFXPRINT_FLAG64;
+    }
 }
 
-void GfxPrint_Dtor(GfxPrint* this)
-{
-
+void GfxPrint_Dtor(GfxPrint* this) {
 }
 
-void GfxPrint_Open(GfxPrint* this, Gfx* dlist)
-{
-    if (!(this->flag & GFXPRINT_OPEN))
-    {
+void GfxPrint_Open(GfxPrint* this, Gfx* dlist) {
+    if (!(this->flag & GFXPRINT_OPEN)) {
         this->flag |= GFXPRINT_OPEN;
         this->dlist = dlist;
         GfxPrint_InitDlist(this);
-    }
-    else
+    } else {
         osSyncPrintf("gfxprint_open:２重オープンです\n");
+    }
 }
 
-Gfx* GfxPrint_Close(GfxPrint* this)
-{
+Gfx* GfxPrint_Close(GfxPrint* this) {
     Gfx* ret;
 
     this->flag &= ~GFXPRINT_OPEN;
@@ -398,15 +387,13 @@ Gfx* GfxPrint_Close(GfxPrint* this)
     return ret;
 }
 
-void GfxPrint_VPrintf(GfxPrint *this, const char *fmt, va_list args)
-{
+void GfxPrint_VPrintf(GfxPrint* this, const char* fmt, va_list args) {
     func_800FF340(&this->callback, fmt, args);
 }
 
-void GfxPrint_Printf(GfxPrint* this, const char* fmt, ...)
-{
+void GfxPrint_Printf(GfxPrint* this, const char* fmt, ...) {
     va_list args;
     va_start(args, fmt);
 
     GfxPrint_VPrintf(this, fmt, args);
-}
\ No newline at end of file
+}
diff --git a/src/code/graph.c b/src/code/graph.c
new file mode 100644
index 000000000..fb3d80e06
--- /dev/null
+++ b/src/code/graph.c
@@ -0,0 +1,526 @@
+#include <global.h>
+#include <ultra64/hardware.h>
+#include <sched.h>
+#include <vt.h>
+#include <PR/os_cont.h>
+
+#define GFXPOOL_HEAD_MAGIC 0x1234
+#define GFXPOOL_TAIL_MAGIC 0x5678
+
+OSTime sGraphUpdateTime;
+OSTime sGraphSetTaskTime;
+FaultClient sGraphFaultClient;
+CfbInfo sGraphCfbInfos[3];
+FaultClient sGraphUcodeFaultClient;
+
+UCodeInfo D_8012D230[3] = {
+    { 1, D_80155F50 }, { 2, NULL }, { 3, D_801120C0 + 0xFB0 }, // D_80113070
+};
+
+UCodeInfo D_8012D248[3] = {
+    { 1, D_80155F50 }, { 2, NULL }, { 3, D_801120C0 + 0xFB0 }, // D_80113070
+};
+
+void Graph_FaultClient() {
+    void* nextFb;
+    void* newFb;
+
+    nextFb = osViGetNextFramebuffer();
+    newFb = ((u32)SysCfb_GetFbPtr(0) != (u32)nextFb) ? SysCfb_GetFbPtr(0) : SysCfb_GetFbPtr(1);
+
+    osViSwapBuffer(newFb);
+    Fault_WaitForInput();
+    osViSwapBuffer(nextFb);
+}
+
+void Graph_DisassembleUCode(void* arg0) {
+    UCodeDisas disassembler;
+
+    if (HREG(80) == 7 && HREG(81) != 0) {
+        func_800D7F5C(&disassembler);
+        disassembler.enableLog = HREG(83);
+        func_800DAC80(&disassembler, 3, D_8012D230);
+        func_800DAC90(&disassembler, D_80155F50);
+        func_800D8400(&disassembler, arg0);
+        HREG(93) = disassembler.dlCnt;
+        HREG(84) = disassembler.tri2Cnt * 2 + disassembler.tri1Cnt + (disassembler.quadCnt * 2) + disassembler.lineCnt;
+        HREG(85) = disassembler.vtxCnt;
+        HREG(86) = disassembler.spvtxCnt;
+        HREG(87) = disassembler.tri1Cnt;
+        HREG(88) = disassembler.tri2Cnt;
+        HREG(89) = disassembler.quadCnt;
+        HREG(90) = disassembler.lineCnt;
+        HREG(91) = disassembler.syncErr;
+        HREG(92) = disassembler.loaducodeCnt;
+        if (HREG(82) == 1 || HREG(82) == 2) {
+            osSyncPrintf("vtx_cnt=%d\n", disassembler.vtxCnt);
+            osSyncPrintf("spvtx_cnt=%d\n", disassembler.spvtxCnt);
+            osSyncPrintf("tri1_cnt=%d\n", disassembler.tri1Cnt);
+            osSyncPrintf("tri2_cnt=%d\n", disassembler.tri2Cnt);
+            osSyncPrintf("quad_cnt=%d\n", disassembler.quadCnt);
+            osSyncPrintf("line_cnt=%d\n", disassembler.lineCnt);
+            osSyncPrintf("sync_err=%d\n", disassembler.syncErr);
+            osSyncPrintf("loaducode_cnt=%d\n", disassembler.loaducodeCnt);
+            osSyncPrintf("dl_depth=%d\n", disassembler.dlDepth);
+            osSyncPrintf("dl_cnt=%d\n", disassembler.dlCnt);
+        }
+        func_800D7FC4(&disassembler);
+    }
+}
+
+void Graph_UCodeFaultClient(void* arg0) {
+    UCodeDisas disassembler;
+
+    func_800D7F5C(&disassembler);
+    disassembler.enableLog = true;
+    func_800DAC80(&disassembler, 3, D_8012D248);
+    func_800DAC90(&disassembler, D_80155F50);
+    func_800D8400(&disassembler, arg0);
+    func_800D7FC4(&disassembler);
+}
+
+void* Graph_InitTHGA(GraphicsContext* gfxCtx) {
+    GfxPool* pool;
+
+    pool = &gGfxPools[gfxCtx->gfxPoolIdx & 1];
+
+    pool->headMagic = GFXPOOL_HEAD_MAGIC;
+    pool->tailMagic = GFXPOOL_TAIL_MAGIC;
+    THGA_Ct(&gfxCtx->polyOpa, pool->polyOpaBuffer, sizeof(pool->polyOpaBuffer));
+    THGA_Ct(&gfxCtx->polyXlu, pool->polyXluBuffer, sizeof(pool->polyXluBuffer));
+    THGA_Ct(&gfxCtx->overlay, pool->overlayBuffer, sizeof(pool->overlayBuffer));
+    THGA_Ct(&gfxCtx->work, pool->workBuffer, sizeof(pool->workBuffer));
+
+    gfxCtx->polyOpaBuffer = pool->polyOpaBuffer;
+    gfxCtx->polyXluBuffer = pool->polyXluBuffer;
+    gfxCtx->overlayBuffer = pool->overlayBuffer;
+    gfxCtx->workBuffer = pool->workBuffer;
+
+    gfxCtx->curFrameBuffer = (u16*)SysCfb_GetFbPtr(gfxCtx->fbIdx % 2);
+    gfxCtx->unk_014 = 0;
+}
+
+GameStateOverlay* Graph_GetNextGameState() {
+    void* gameStateInitFunc;
+
+    gameStateInitFunc = func_800C546C();
+    if (gameStateInitFunc == TitleSetup_Init) {
+        return &gGameStateOverlayTable[0];
+    }
+    if (gameStateInitFunc == func_80801E44) {
+        return &gGameStateOverlayTable[1];
+    }
+    if (gameStateInitFunc == Title_Init) {
+        return &gGameStateOverlayTable[2];
+    }
+    if (gameStateInitFunc == func_800BCA64) {
+        return &gGameStateOverlayTable[3];
+    }
+    if (gameStateInitFunc == Opening_Init) {
+        return &gGameStateOverlayTable[4];
+    }
+    if (gameStateInitFunc == func_80811A20) {
+        return &gGameStateOverlayTable[5];
+    }
+
+    LOG_ADDRESS("game_init_func", gameStateInitFunc, "../graph.c", 696);
+    return NULL;
+}
+
+void Graph_Init(GraphicsContext* gfxCtx) {
+    bzero(gfxCtx, sizeof(GraphicsContext));
+    gfxCtx->gfxPoolIdx = 0;
+    gfxCtx->fbIdx = 0;
+    gfxCtx->viMode = NULL;
+    gfxCtx->viFeatures = gViConfigFeatures;
+    gfxCtx->xScale = gViConfigXScale;
+    gfxCtx->yScale = gViConfigYScale;
+    osCreateMesgQueue(&gfxCtx->queue, gfxCtx->msgBuff, ARRAY_COUNT(gfxCtx->msgBuff));
+    func_800D31F0();
+    Fault_AddClient(&sGraphFaultClient, Graph_FaultClient, 0, 0);
+}
+
+void Graph_Destroy(GraphicsContext* gfxCtx) {
+    func_800D3210();
+    Fault_RemoveClient(&sGraphFaultClient);
+}
+
+// Close to matching, reordering at the end
+#ifdef NON_MATCHING
+void Graph_TaskSet00(GraphicsContext* gfxCtx) {
+    static u32 D_8012D260 = 0;
+    static s32 sGraphCfbInfoIdx = 0;
+
+    OSTimer timer;
+    OSMesg msg;
+    OSMesgQueue* mq;
+    u32 temp;
+    OSTime time;
+    OSTask_t* task;
+    Gfx* dispRefs[3];
+    OSScTask* scTask;
+    CfbInfo* cfb;
+
+    mq = &gfxCtx->queue;
+    task = &gfxCtx->task.list.t;
+    scTask = &gfxCtx->task;
+
+    D_8016A528 = osGetTime() - sGraphSetTaskTime - D_8016A558;
+
+    osSetTimer(&timer, 140625000, 0, mq, 666);
+
+    osRecvMesg(mq, &msg, OS_MESG_BLOCK);
+    osStopTimer(&timer);
+    if (msg == (OSMesg)666) {
+        osSyncPrintf(VT_FGCOL(RED));
+        osSyncPrintf("RCPが帰ってきませんでした。"); // "RCP did not return."
+        osSyncPrintf(VT_RST);
+        LogUtils_LogHexDump(&HW_REG(SP_MEM_ADDR_REG, u32), 0x20);
+        LogUtils_LogHexDump(&DPC_START_REG, 0x20);
+        LogUtils_LogHexDump(gGfxSPTaskYieldBuffer, sizeof(gGfxSPTaskYieldBuffer));
+
+        SREG(6) = -1;
+        if (D_8012D260) {
+            temp = D_8012D260;
+            HREG(80) = 7;
+            HREG(81) = 1;
+            HREG(82) = 2;
+            D_8012D260 = temp;
+            Graph_DisassembleUCode(temp);
+        }
+        Fault_AddHungupAndCrashImpl("RCP is HUNG UP!!", "Oh! MY GOD!!");
+    }
+    osRecvMesg(mq, &msg, OS_MESG_NOBLOCK);
+    D_8012D260 = gfxCtx->workBuffer;
+    if (gfxCtx->callback) {
+        gfxCtx->callback(gfxCtx, gfxCtx->callbackParam);
+    }
+
+    time = osGetTime();
+    if (D_8016A550) {
+        D_8016A558 = (D_8016A558 + time) - D_8016A550;
+        D_8016A550 = time;
+    }
+    D_8016A520 = D_8016A558;
+    D_8016A558 = 0;
+    sGraphSetTaskTime = osGetTime();
+
+    task->type = M_GFXTASK;
+    task->flags = OS_SC_DRAM_DLIST;
+    task->ucode_boot = SysUcode_GetUCodeBoot();
+    task->ucode_boot_size = SysUcode_GetUcodeBootSize();
+    task->ucode = SysUcode_GetUcode();
+    task->ucode_data = SysUcode_GetUcodeData();
+    task->ucode_size = 0x1000;
+    task->ucode_data_size = 0x800;
+    task->dram_stack = gGfxSPTaskStack;
+    task->dram_stack_size = sizeof(gGfxSPTaskStack);
+    task->output_buff = gGfxSPTaskOutputBuffer;
+    task->output_buff_size = gGfxSPTaskYieldBuffer; // ??
+    task->data_ptr = gfxCtx->workBuffer;
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../graph.c", 828);
+    task->data_size = (u32)gfxCtx->work.p - (u32)gfxCtx->workBuffer;
+    Graph_CloseDisps(dispRefs, gfxCtx, "../graph.c", 830);
+
+    task->yield_data_ptr = gGfxSPTaskYieldBuffer;
+    task->yield_data_size = sizeof(gGfxSPTaskYieldBuffer);
+
+    scTask->next = NULL;
+    scTask->flags = OS_SC_RCP_MASK | OS_SC_SWAPBUFFER | OS_SC_LAST_TASK;
+    if (SREG(33) & 1) {
+        SREG(33) &= ~1;
+        scTask->flags &= ~OS_SC_SWAPBUFFER;
+        gfxCtx->fbIdx--;
+    }
+
+    scTask->msg = NULL;
+    scTask->msgQ = mq;
+
+    cfb = sGraphCfbInfos + sGraphCfbInfoIdx++;
+    cfb->fb1 = gfxCtx->curFrameBuffer;
+    cfb->swapbuffer = gfxCtx->curFrameBuffer;
+    cfb->viMode = gfxCtx->viMode;
+    cfb->features = gfxCtx->viFeatures;
+    cfb->xScale = gfxCtx->xScale;
+    cfb->yScale = gfxCtx->yScale;
+    cfb->unk_10 = 0;
+    cfb->updateRate = R_UPDATE_RATE;
+
+    scTask->framebuffer = cfb;
+    sGraphCfbInfoIdx = sGraphCfbInfoIdx % ARRAY_COUNT(sGraphCfbInfos);
+    gfxCtx->schedMsgQ = &gSchedContext.cmdQ;
+
+    osSendMesg(&gSchedContext.cmdQ, scTask, OS_MESG_BLOCK);
+    func_800C95F8(&gSchedContext); // osScKickEntryMsg
+}
+#else
+u32 D_8012D260 = 0;
+u32 sGraphCfbInfoIdx = 0;
+#pragma GLOBAL_ASM("asm/non_matchings/code/graph/Graph_TaskSet00.s")
+#endif
+
+// Very close to matching, stack usage
+#ifdef NON_MATCHING
+void Graph_Update(GraphicsContext* gfxCtx, GameState* gameState) {
+    u32 problem;     // 0xC4 -> 0xD4
+    Gfx* dispRefs[5];  // 0xB0 -> 0xC0
+    Gfx* dispRefs2[9]; // 0x8C -> 0x9C
+    Gfx* dispRefs3[9]; // 0x68 -> 0x78
+    u64 time;
+    GfxPool* pool; // 0x4C -> 0x6C
+
+    gameState->unk_A0 = 0;
+    Graph_InitTHGA(gfxCtx);
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../graph.c", 966);
+    gDPNoOpString(gfxCtx->work.p++, "WORK_DISP 開始", 0);
+    gDPNoOpString(gfxCtx->polyOpa.p++, "POLY_OPA_DISP 開始", 0);
+    gDPNoOpString(gfxCtx->polyXlu.p++, "POLY_XLU_DISP 開始", 0);
+    gDPNoOpString(gfxCtx->overlay.p++, "OVERLAY_DISP 開始", 0);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../graph.c", 975);
+
+    func_800C4A98(gameState); // Game_ReqPadData
+    func_800C4AC8(gameState); // Game_SetGameFrame
+
+    Graph_OpenDisps(dispRefs2, gfxCtx, "../graph.c", 987);
+    gDPNoOpString(gfxCtx->work.p++, "WORK_DISP 終了", 0);
+    gDPNoOpString(gfxCtx->polyOpa.p++, "POLY_OPA_DISP 終了", 0);
+    gDPNoOpString(gfxCtx->polyXlu.p++, "POLY_XLU_DISP 終了", 0);
+    gDPNoOpString(gfxCtx->overlay.p++, "OVERLAY_DISP 終了", 0);
+    Graph_CloseDisps(dispRefs2, gfxCtx, "../graph.c", 996);
+
+    Graph_OpenDisps(dispRefs3, gfxCtx, "../graph.c", 999);
+    gSPBranchList(gfxCtx->work.p++, gfxCtx->polyOpaBuffer);
+    gSPBranchList(gfxCtx->polyOpa.p++, gfxCtx->polyXluBuffer);
+    gSPBranchList(gfxCtx->polyXlu.p++, gfxCtx->overlayBuffer);
+    gDPPipeSync(gfxCtx->overlay.p++);
+    gDPFullSync(gfxCtx->overlay.p++);
+    gSPEndDisplayList(gfxCtx->overlay.p++);
+    Graph_CloseDisps(dispRefs3, gfxCtx, "../graph.c", 1028);
+
+    if (HREG(80) == 10 && HREG(93) == 2) {
+        HREG(80) = 7;
+        HREG(81) = -1;
+        HREG(83) = HREG(92);
+    }
+    if (HREG(80) == 7 && HREG(81) != 0) {
+        if (HREG(82) == 3) {
+            Fault_AddClient(&sGraphUcodeFaultClient, Graph_UCodeFaultClient, gfxCtx->workBuffer, "do_count_fault");
+        }
+
+        Graph_DisassembleUCode(gfxCtx->workBuffer);
+
+        if (HREG(82) == 3) {
+            Fault_RemoveClient(&sGraphUcodeFaultClient);
+        }
+
+        if (HREG(81) < 0) {
+            LogUtils_LogHexDump(&HW_REG(SP_MEM_ADDR_REG, u32), 0x20);
+            LogUtils_LogHexDump(&DPC_START_REG, 0x20);
+        }
+
+        if (HREG(81) < 0) {
+            HREG(81) = 0;
+        }
+    }
+
+    problem = false;
+    pool = &gGfxPools[gfxCtx->gfxPoolIdx & 1];
+    if (pool->headMagic != GFXPOOL_HEAD_MAGIC) {
+        // BUG (?) : devs might've forgotten "problem = true;"
+        osSyncPrintf("%c", 7);
+        // Dynamic area head is destroyed
+        osSyncPrintf(VT_COL(RED, WHITE) "ダイナミック領域先頭が破壊されています\n" VT_RST);
+        Fault_AddHungupAndCrash("../graph.c", 1070);
+    }
+    if (pool->tailMagic != GFXPOOL_TAIL_MAGIC) {
+        problem = true;
+        osSyncPrintf("%c", 7);
+        // Dynamic region tail is destroyed
+        osSyncPrintf(VT_COL(RED, WHITE) "ダイナミック領域末尾が破壊されています\n" VT_RST);
+        Fault_AddHungupAndCrash("../graph.c", 1076);
+    }
+
+    if (THGA_IsCrash(&gfxCtx->polyOpa)) {
+        problem = true;
+        osSyncPrintf("%c", 7);
+        // Zelda 0 is dead
+        osSyncPrintf(VT_COL(RED, WHITE) "ゼルダ0は死んでしまった(graph_alloc is empty)\n" VT_RST);
+    }
+    if (THGA_IsCrash(&gfxCtx->polyXlu)) {
+        problem = true;
+        osSyncPrintf("%c", 7);
+        // Zelda 1 is dead
+        osSyncPrintf(VT_COL(RED, WHITE) "ゼルダ1は死んでしまった(graph_alloc is empty)\n" VT_RST);
+    }
+    if (THGA_IsCrash(&gfxCtx->overlay)) {
+        problem = true;
+        osSyncPrintf("%c", 7);
+        // Zelda 4 is dead
+        osSyncPrintf(VT_COL(RED, WHITE) "ゼルダ4は死んでしまった(graph_alloc is empty)\n" VT_RST);
+    }
+
+    if (!problem) {
+        Graph_TaskSet00(gfxCtx);
+        gfxCtx->gfxPoolIdx++;
+        gfxCtx->fbIdx++;
+    }
+
+    func_800F3054();
+    time = osGetTime();
+    D_8016A538 = D_8016A568;
+    D_8016A530 = D_8016A560;
+    D_8016A540 = D_8016A580;
+    D_8016A568 = 0;
+    D_8016A560 = 0;
+    D_8016A580 = 0;
+
+    if (sGraphUpdateTime != 0) {
+        D_8016A548 = time - sGraphUpdateTime;
+    }
+    sGraphUpdateTime = time;
+
+    if (D_8012DBC0 && (!~(gameState->input[0].padPressed | ~Z_TRIG)) &&
+        (!~(gameState->input[0].raw.pad | ~(L_TRIG | R_TRIG)))) {
+        gSaveContext.game_mode = 0;
+        SET_NEXT_GAMESTATE(gameState, func_80801E44, char[0x240]); // TODO : SelectContext
+        gameState->running = false;
+    }
+
+    if (D_8012DBC0 && PreNmiBuff_IsResetting(gAppNmiBufferPtr) && !gameState->unk_A0) {
+        // To reset mode
+        osSyncPrintf(VT_COL(YELLOW, BLACK) "PRE-NMIによりリセットモードに移行します\n" VT_RST);
+        SET_NEXT_GAMESTATE(gameState, PreNMI_Init, PreNMIContext);
+        gameState->running = false;
+    }
+}
+#else
+#pragma GLOBAL_ASM("asm/non_matchings/code/graph/Graph_Update.s")
+#endif
+
+void Graph_ThreadEntry(void* arg0) {
+    GraphicsContext gfxCtx;
+    GameState* gameState;
+    u32 size;
+    GameStateOverlay* nextOvl;
+    GameStateOverlay* ovl;
+    char faultMsg[0x50];
+
+    nextOvl = &gGameStateOverlayTable[0];
+
+    // Start graphic thread execution
+    osSyncPrintf("グラフィックスレッド実行開始\n");
+    Graph_Init(&gfxCtx);
+
+    while (nextOvl) {
+        ovl = nextOvl;
+        Overlay_LoadGameState(ovl);
+
+        size = ovl->instanceSize;
+        // Class size =%d bytes
+        osSyncPrintf("クラスサイズ＝%dバイト\n", size);
+
+        gameState = SystemArena_MallocDebug(size, "../graph.c", 1196);
+
+        if (!gameState) {
+            // Failure to secure
+            osSyncPrintf("確保失敗\n");
+
+            sprintf(faultMsg, "CLASS SIZE= %d bytes", size);
+            Fault_AddHungupAndCrashImpl("GAME CLASS MALLOC FAILED", faultMsg);
+        }
+        func_800C5080(gameState, ovl->init, &gfxCtx); // Game_Ct
+
+        while (func_800C547C(gameState)) // Game_IsGameStateRunning
+        {
+            Graph_Update(&gfxCtx, gameState);
+        }
+
+        nextOvl = Graph_GetNextGameState(gameState);
+        func_800C5360(gameState); // Game_Dt
+        SystemArena_FreeDebug(gameState, "../graph.c", 1227);
+        Overlay_FreeGameState(ovl);
+    }
+    Graph_Destroy(&gfxCtx);
+    // End of graphic thread execution
+    osSyncPrintf("グラフィックスレッド実行終了\n");
+}
+
+void* Graph_Alloc(GraphicsContext* gfxCtx, size_t size) {
+    TwoHeadGfxArena* thga = &gfxCtx->polyOpa;
+
+    if (HREG(59) == 1) {
+        osSyncPrintf("graph_alloc siz=%d thga size=%08x bufp=%08x head=%08x tail=%08x\n", size, thga->size, thga->bufp,
+                     thga->p, thga->d);
+    }
+    return THGA_AllocEnd(&gfxCtx->polyOpa, ALIGN16(size));
+}
+
+void* Graph_Alloc2(GraphicsContext* gfxCtx, size_t size) {
+    TwoHeadGfxArena* thga = &gfxCtx->polyOpa;
+
+    if (HREG(59) == 1) {
+        osSyncPrintf("graph_alloc siz=%d thga size=%08x bufp=%08x head=%08x tail=%08x\n", size, thga->size, thga->bufp,
+                     thga->p, thga->d);
+    }
+    return THGA_AllocEnd(&gfxCtx->polyOpa, ALIGN16(size));
+}
+
+void Graph_OpenDisps(Gfx** dispRefs, GraphicsContext* gfxCtx, const char* file, s32 line) {
+    if (HREG(80) == 7 && HREG(82) != 4) {
+        dispRefs[0] = gfxCtx->polyOpa.p;
+        dispRefs[1] = gfxCtx->polyXlu.p;
+        dispRefs[2] = gfxCtx->overlay.p;
+
+        gDPNoOpOpenDisp(gfxCtx->polyOpa.p++, file, line);
+        gDPNoOpOpenDisp(gfxCtx->polyXlu.p++, file, line);
+        gDPNoOpOpenDisp(gfxCtx->overlay.p++, file, line);
+    }
+}
+
+void Graph_CloseDisps(Gfx** dispRefs, GraphicsContext* gfxCtx, const char* file, s32 line) {
+    if (HREG(80) == 7 && HREG(82) != 4) {
+        if (dispRefs[0] + 1 == gfxCtx->polyOpa.p) {
+            gfxCtx->polyOpa.p = dispRefs[0];
+        } else {
+            gDPNoOpCloseDisp(gfxCtx->polyOpa.p++, file, line);
+        }
+
+        if (dispRefs[1] + 1 == gfxCtx->polyXlu.p) {
+            gfxCtx->polyXlu.p = dispRefs[1];
+        } else {
+            gDPNoOpCloseDisp(gfxCtx->polyXlu.p++, file, line);
+        }
+
+        if (dispRefs[2] + 1 == gfxCtx->overlay.p) {
+            gfxCtx->overlay.p = dispRefs[2];
+        } else {
+            gDPNoOpCloseDisp(gfxCtx->overlay.p++, file, line);
+        }
+    }
+}
+
+Gfx* Graph_GfxPlusOne(Gfx* gfx) {
+    return gfx + 1;
+}
+
+Gfx* Graph_BranchDlist(Gfx* gfx, Gfx* dst) {
+    gSPBranchList(gfx, dst);
+    return dst;
+}
+
+void* Graph_DlistAlloc(Gfx** gfx, u32 size) {
+    u8* ptr;
+    Gfx* dst;
+
+    size = ((size + 7) & ~7),
+
+    ptr = *gfx + 1;
+
+    dst = (Gfx*)(ptr + size);
+    gSPBranchList(*gfx, dst);
+
+    *gfx = dst;
+    return ptr;
+}
diff --git a/src/code/irqmgr.c b/src/code/irqmgr.c
index eb7eb780b..35be0e353 100644
--- a/src/code/irqmgr.c
+++ b/src/code/irqmgr.c
@@ -6,18 +6,17 @@ volatile OSTime sIrqMgrResetTime = 0;
 volatile OSTime sIrqMgrRetraceTime = 0;
 u32 sIrqMgrRetraceCount = 0;
 
-#define RETRACE_MSG     666
-#define PRE_NMI_MSG     669
-#define PRENMI450_MSG   671
-#define PRENMI480_MSG   672
-#define PRENMI500_MSG   673
-
-#define STATUS_IDLE      0
-#define STATUS_PRENMI    1
-#define STATUS_NMI       2
-
-void IrqMgr_AddClient(IrqMgr* this, IrqMgrClient* c, OSMesgQueue* msgQ)
-{
+#define RETRACE_MSG 666
+#define PRE_NMI_MSG 669
+#define PRENMI450_MSG 671
+#define PRENMI480_MSG 672
+#define PRENMI500_MSG 673
+
+#define STATUS_IDLE 0
+#define STATUS_PRENMI 1
+#define STATUS_NMI 2
+
+void IrqMgr_AddClient(IrqMgr* this, IrqMgrClient* c, OSMesgQueue* msgQ) {
     u32 prevMask;
 
     LogUtils_CheckNullPointer("this", this, "../irqmgr.c", 96);
@@ -32,15 +31,16 @@ void IrqMgr_AddClient(IrqMgr* this, IrqMgrClient* c, OSMesgQueue* msgQ)
 
     osSetIntMask(prevMask);
 
-    if (this->resetStatus > STATUS_IDLE)
-        osSendMesg(c->queue, (OSMesg)&this->prenmiMsg, OS_MESG_NOBLOCK);
+    if (this->resetStatus > STATUS_IDLE) {
+        osSendMesg(c->queue, (OSMesg) & this->prenmiMsg, OS_MESG_NOBLOCK);
+    }
 
-    if (this->resetStatus >= STATUS_NMI)
-        osSendMesg(c->queue, (OSMesg)&this->nmiMsg, OS_MESG_NOBLOCK);
+    if (this->resetStatus >= STATUS_NMI) {
+        osSendMesg(c->queue, (OSMesg) & this->nmiMsg, OS_MESG_NOBLOCK);
+    }
 }
 
-void IrqMgr_RemoveClient(IrqMgr* this, IrqMgrClient* c)
-{
+void IrqMgr_RemoveClient(IrqMgr* this, IrqMgrClient* c) {
     IrqMgrClient* iter;
     IrqMgrClient* lastIter;
     u32 prevMask;
@@ -50,17 +50,16 @@ void IrqMgr_RemoveClient(IrqMgr* this, IrqMgrClient* c)
 
     LogUtils_CheckNullPointer("this", this, "../irqmgr.c", 129);
     LogUtils_CheckNullPointer("c", c, "../irqmgr.c", 130);
-    
+
     prevMask = osSetIntMask(1);
 
-    while (iter)
-    {
-        if (iter == c)
-        {
-            if (lastIter)
+    while (iter) {
+        if (iter == c) {
+            if (lastIter) {
                 lastIter->prev = c->prev;
-            else
+            } else {
                 this->clients = c->prev;
+            }
             break;
         }
         lastIter = iter;
@@ -70,160 +69,150 @@ void IrqMgr_RemoveClient(IrqMgr* this, IrqMgrClient* c)
     osSetIntMask(prevMask);
 }
 
-void IrqMgr_SendMesgForClient(IrqMgr* this, OSMesg msg)
-{
+void IrqMgr_SendMesgForClient(IrqMgr* this, OSMesg msg) {
     IrqMgrClient* iter;
 
     iter = this->clients;
-    while(iter)
-    {
-        if (iter->queue->validCount >= iter->queue->msgCount)
-            //irqmgr_SendMesgForClient: Message queue is overflowing mq=%08x cnt=%d
-            osSyncPrintf(VT_COL(RED, WHITE) "irqmgr_SendMesgForClient:メッセージキューがあふれています mq=%08x cnt=%d\n" VT_RST, iter->queue, iter->queue->validCount);
-        else
+    while (iter) {
+        if (iter->queue->validCount >= iter->queue->msgCount) {
+            // irqmgr_SendMesgForClient: Message queue is overflowing mq=%08x cnt=%d
+            osSyncPrintf(
+                VT_COL(RED, WHITE) "irqmgr_SendMesgForClient:メッセージキューがあふれています mq=%08x cnt=%d\n" VT_RST,
+                iter->queue, iter->queue->validCount);
+        } else {
             osSendMesg(iter->queue, msg, OS_MESG_NOBLOCK);
-            
+        }
+
         iter = iter->prev;
     }
 }
 
-void IrqMgr_JamMesgForClient(IrqMgr* this, OSMesg msg)
-{
+void IrqMgr_JamMesgForClient(IrqMgr* this, OSMesg msg) {
     IrqMgrClient* iter;
 
     iter = this->clients;
-    while(iter)
-    {
-        if (iter->queue->validCount >= iter->queue->msgCount)
-            //irqmgr_JamMesgForClient: Message queue is overflowing mq=%08x cnt=%d
-            osSyncPrintf(VT_COL(RED, WHITE) "irqmgr_JamMesgForClient:メッセージキューがあふれています mq=%08x cnt=%d\n" VT_RST, iter->queue, iter->queue->validCount);
-        else
-            //mistake? the function's name suggests it would use osJamMesg
+    while (iter) {
+        if (iter->queue->validCount >= iter->queue->msgCount) {
+            // irqmgr_JamMesgForClient: Message queue is overflowing mq=%08x cnt=%d
+            osSyncPrintf(
+                VT_COL(RED, WHITE) "irqmgr_JamMesgForClient:メッセージキューがあふれています mq=%08x cnt=%d\n" VT_RST,
+                iter->queue, iter->queue->validCount);
+        } else {
+            // mistake? the function's name suggests it would use osJamMesg
             osSendMesg(iter->queue, msg, OS_MESG_NOBLOCK);
-            
+        }
+
         iter = iter->prev;
     }
 }
 
-void IrqMgr_HandlePreNMI(IrqMgr *this)
-{
-    u64 temp = STATUS_PRENMI; //required to match
+void IrqMgr_HandlePreNMI(IrqMgr* this) {
+    u64 temp = STATUS_PRENMI; // required to match
     gIrqMgrResetStatus = temp;
     this->resetStatus = STATUS_PRENMI;
 
     sIrqMgrResetTime = this->resetTime = osGetTime();
     osSetTimer(&this->timer, OS_USEC_TO_CYCLES(450000), 0ull, &this->queue, (OSMesg)PRENMI450_MSG);
-    IrqMgr_JamMesgForClient(this, (OSMesg)&this->prenmiMsg);
+    IrqMgr_JamMesgForClient(this, (OSMesg) & this->prenmiMsg);
 }
 
-void IrqMgr_CheckStack()
-{
-    osSyncPrintf("irqmgr.c: PRENMIから0.5秒経過\n"); //0.5 seconds after PRENMI
-    if (StackCheck_Check(NULL) == 0) 
-    {
-        osSyncPrintf("スタックは大丈夫みたいです\n"); //The stack looks ok
-    }
-    else
-    { 
+void IrqMgr_CheckStack() {
+    osSyncPrintf("irqmgr.c: PRENMIから0.5秒経過\n"); // 0.5 seconds after PRENMI
+    if (StackCheck_Check(NULL) == 0) {
+        osSyncPrintf("スタックは大丈夫みたいです\n"); // The stack looks ok
+    } else {
         osSyncPrintf("%c", 7);
         osSyncPrintf(VT_FGCOL(RED));
-        osSyncPrintf("スタックがオーバーフローしたか危険な状態です\n"); //Stack overflow or dangerous
-        osSyncPrintf("早々にスタックサイズを増やすか、スタックを消費しないようにしてください\n"); //Increase stack size early or don't consume stack
+        osSyncPrintf("スタックがオーバーフローしたか危険な状態です\n"); // Stack overflow or dangerous
+        osSyncPrintf(
+            "早々にスタックサイズを増やすか、スタックを消費しないようにしてください\n"); // Increase stack size early or
+                                                                                         // don't consume stack
         osSyncPrintf(VT_RST);
     }
 }
 
-void IrqMgr_HandlePRENMI450(IrqMgr* this)
-{
-    u64 temp = STATUS_NMI; //required to match
+void IrqMgr_HandlePRENMI450(IrqMgr* this) {
+    u64 temp = STATUS_NMI; // required to match
     gIrqMgrResetStatus = temp;
     this->resetStatus = STATUS_NMI;
     osSetTimer(&this->timer, OS_USEC_TO_CYCLES(30000), 0ull, &this->queue, (OSMesg)PRENMI480_MSG);
-    IrqMgr_SendMesgForClient(this, (OSMesg)&this->nmiMsg);
+    IrqMgr_SendMesgForClient(this, (OSMesg) & this->nmiMsg);
 }
 
-void IrqMgr_HandlePRENMI480(IrqMgr* this)
-{
+void IrqMgr_HandlePRENMI480(IrqMgr* this) {
     u32 ret;
     osSetTimer(&this->timer, OS_USEC_TO_CYCLES(20000), 0ull, &this->queue, (OSMesg)PRENMI500_MSG);
-    ret = func_801031F0(); //osAfterPreNMI
-    if (ret)
-    {
-        osSyncPrintf("osAfterPreNMIが %d を返しました！？\n", ret); //osAfterPreNMI returned %d !?
+    ret = func_801031F0(); // osAfterPreNMI
+    if (ret) {
+        osSyncPrintf("osAfterPreNMIが %d を返しました！？\n", ret); // osAfterPreNMI returned %d !?
         osSetTimer(&this->timer, OS_USEC_TO_CYCLES(1000), 0ull, &this->queue, (OSMesg)PRENMI480_MSG);
     }
 }
 
-void IrqMgr_HandlePRENMI500(IrqMgr* this)
-{
+void IrqMgr_HandlePRENMI500(IrqMgr* this) {
     IrqMgr_CheckStack();
 }
 
-void IrqMgr_HandleRetrace(IrqMgr* this)
-{
-    if (sIrqMgrRetraceTime == 0ull)
-    {
-        if (this->retraceTime == 0)
+void IrqMgr_HandleRetrace(IrqMgr* this) {
+    if (sIrqMgrRetraceTime == 0ull) {
+        if (this->retraceTime == 0) {
             this->retraceTime = osGetTime();
-        else
+        } else {
             sIrqMgrRetraceTime = osGetTime() - this->retraceTime;
+        }
     }
     sIrqMgrRetraceCount++;
-    IrqMgr_SendMesgForClient(this, (OSMesg)&this->retraceMsg);
+    IrqMgr_SendMesgForClient(this, (OSMesg) & this->retraceMsg);
 }
 
-void IrqMgr_ThreadEntry(void* arg0)
-{
+void IrqMgr_ThreadEntry(void* arg0) {
     OSMesg msg;
     IrqMgr* this;
     u8 exit;
 
     this = (IrqMgr*)arg0;
     msg = 0;
-    osSyncPrintf("ＩＲＱマネージャスレッド実行開始\n"); //Start IRQ manager thread execution
+    osSyncPrintf("ＩＲＱマネージャスレッド実行開始\n"); // Start IRQ manager thread execution
     exit = false;
 
-    while (!exit)
-    {
+    while (!exit) {
         osRecvMesg(&this->queue, &msg, OS_MESG_BLOCK);
-        switch ((u32)msg)
-        {
+        switch ((u32)msg) {
             case RETRACE_MSG:
                 IrqMgr_HandleRetrace(this);
                 break;
             case PRE_NMI_MSG:
                 osSyncPrintf("PRE_NMI_MSG\n");
-                osSyncPrintf("スケジューラ：PRE_NMIメッセージを受信\n"); //Scheduler: Receives PRE_NMI message
+                osSyncPrintf("スケジューラ：PRE_NMIメッセージを受信\n"); // Scheduler: Receives PRE_NMI message
                 IrqMgr_HandlePreNMI(this);
                 break;
             case PRENMI450_MSG:
                 osSyncPrintf("PRENMI450_MSG\n");
-                osSyncPrintf("スケジューラ：PRENMI450メッセージを受信\n"); //Scheduler: Receives PRENMI450 message
+                osSyncPrintf("スケジューラ：PRENMI450メッセージを受信\n"); // Scheduler: Receives PRENMI450 message
                 IrqMgr_HandlePRENMI450(this);
                 break;
             case PRENMI480_MSG:
                 osSyncPrintf("PRENMI480_MSG\n");
-                osSyncPrintf("スケジューラ：PRENMI480メッセージを受信\n"); //Scheduler: Receives PRENMI480 message
+                osSyncPrintf("スケジューラ：PRENMI480メッセージを受信\n"); // Scheduler: Receives PRENMI480 message
                 IrqMgr_HandlePRENMI480(this);
                 break;
             case PRENMI500_MSG:
                 osSyncPrintf("PRENMI500_MSG\n");
-                osSyncPrintf("スケジューラ：PRENMI500メッセージを受信\n"); //Scheduler: Receives PRENMI500 message
+                osSyncPrintf("スケジューラ：PRENMI500メッセージを受信\n"); // Scheduler: Receives PRENMI500 message
                 exit = true;
                 IrqMgr_HandlePRENMI500(this);
                 break;
             default:
-                osSyncPrintf("irqmgr.c:予期しないメッセージを受け取りました(%08x)\n", msg); //Unexpected message received
+                osSyncPrintf("irqmgr.c:予期しないメッセージを受け取りました(%08x)\n",
+                             msg); // Unexpected message received
                 break;
-
         }
     }
 
-    osSyncPrintf("ＩＲＱマネージャスレッド実行終了\n"); //End of IRQ manager thread execution
+    osSyncPrintf("ＩＲＱマネージャスレッド実行終了\n"); // End of IRQ manager thread execution
 }
 
-void IrqMgr_Create(IrqMgr* this, void* stack, OSPri pri, u8 retraceCount)
-{
+void IrqMgr_Create(IrqMgr* this, void* stack, OSPri pri, u8 retraceCount) {
     LogUtils_CheckNullPointer("this", this, "../irqmgr.c", 346);
     LogUtils_CheckNullPointer("stack", stack, "../irqmgr.c", 347);
     this->clients = NULL;
diff --git a/src/code/listalloc.c b/src/code/listalloc.c
index 20cc88e1c..b7d97281c 100644
--- a/src/code/listalloc.c
+++ b/src/code/listalloc.c
@@ -1,64 +1,66 @@
 #include <global.h>
 
-ListAlloc* ListAlloc_Init(ListAlloc* this)
-{
+ListAlloc* ListAlloc_Init(ListAlloc* this) {
     this->prev = NULL;
     this->next = NULL;
     return this;
 }
 
-void* ListAlloc_Alloc(ListAlloc* this, u32 size)
-{
+void* ListAlloc_Alloc(ListAlloc* this, u32 size) {
     ListAlloc* ptr;
     ListAlloc* next;
-    
+
     ptr = SystemArena_MallocDebug(size + sizeof(ListAlloc), "../listalloc.c", 40);
-    if (!ptr)
+    if (!ptr) {
         return NULL;
+    }
 
     next = this->next;
 
-    if (next)
+    if (next) {
         next->next = ptr;
-    
+    }
+
     ptr->prev = next;
     ptr->next = NULL;
     this->next = ptr;
 
-    if (!this->prev)
+    if (!this->prev) {
         this->prev = ptr;
+    }
 
     return (u8*)ptr + sizeof(ListAlloc);
 }
 
-void ListAlloc_Free(ListAlloc* this, void* data)
-{
+void ListAlloc_Free(ListAlloc* this, void* data) {
     ListAlloc* ptr;
 
     ptr = &((ListAlloc*)data)[-1];
 
-    if (ptr->prev)
+    if (ptr->prev) {
         ptr->prev->next = ptr->next;
+    }
 
-    if (ptr->next)
+    if (ptr->next) {
         ptr->next->prev = ptr->prev;
+    }
 
-    if (this->prev == ptr)
+    if (this->prev == ptr) {
         this->prev = ptr->next;
+    }
 
-    if (this->next == ptr)
+    if (this->next == ptr) {
         this->next = ptr->prev;
+    }
 
     SystemArena_FreeDebug(ptr, "../listalloc.c", 72);
 }
 
-void ListAlloc_FreeAll(ListAlloc* this)
-{
+void ListAlloc_FreeAll(ListAlloc* this) {
     ListAlloc* iter;
 
     iter = this->prev;
-    while (iter)
-    {
+    while (iter) {
         ListAlloc_Free(this, (u8*)iter + sizeof(ListAlloc));
         iter = this->prev;
     }
diff --git a/src/code/loadfragment2.c b/src/code/loadfragment2.c
index b47bae4c1..2a304bbeb 100644
--- a/src/code/loadfragment2.c
+++ b/src/code/loadfragment2.c
@@ -1,20 +1,18 @@
 #include <global.h>
 
-void *Overlay_AllocateAndLoad(u32 vRomStart, u32 vRomEnd, void *vRamStart, void *vRamEnd)
-{
-    void *allocatedVRamAddr;
+void* Overlay_AllocateAndLoad(u32 vRomStart, u32 vRomEnd, void* vRamStart, void* vRamEnd) {
+    void* allocatedVRamAddr;
 
     allocatedVRamAddr = SystemArena_MallocRDebug((s32)vRamEnd - (s32)vRamStart, "../loadfragment2.c", 31);
 
-    if(gOverlayLogSeverity >= 3)
-    {
-        osSyncPrintf("OVL:SPEC(%08x-%08x) REAL(%08x-%08x) OFFSET(%08x)\n", vRamStart, vRamEnd, allocatedVRamAddr, ((u32)vRamEnd - (u32)vRamStart) + (u32)allocatedVRamAddr, (u32)vRamStart - (u32)allocatedVRamAddr);
+    if (gOverlayLogSeverity >= 3) {
+        osSyncPrintf("OVL:SPEC(%08x-%08x) REAL(%08x-%08x) OFFSET(%08x)\n", vRamStart, vRamEnd, allocatedVRamAddr,
+                     ((u32)vRamEnd - (u32)vRamStart) + (u32)allocatedVRamAddr, (u32)vRamStart - (u32)allocatedVRamAddr);
     }
 
-    if(allocatedVRamAddr != NULL)
-    {
+    if (allocatedVRamAddr != NULL) {
         Overlay_Load(vRomStart, vRomEnd, vRamStart, vRamEnd, allocatedVRamAddr);
     }
 
     return allocatedVRamAddr;
-}
\ No newline at end of file
+}
diff --git a/src/code/logseverity.c b/src/code/logseverity.c
index b62552e1b..25bc68c46 100644
--- a/src/code/logseverity.c
+++ b/src/code/logseverity.c
@@ -1,3 +1,3 @@
 #include <global.h>
 
-s32 gOverlayLogSeverity = 2;
\ No newline at end of file
+s32 gOverlayLogSeverity = 2;
diff --git a/src/code/main.c b/src/code/main.c
index f69f62317..5e2b9a89e 100644
--- a/src/code/main.c
+++ b/src/code/main.c
@@ -7,7 +7,7 @@ u32 gScreenWidth = SCREEN_WIDTH;
 u32 gScreenHeight = SCREEN_HEIGHT;
 u32 gSystemHeapSize = 0;
 
-u8* gAppNmiBufferPtr;
+PreNmiBuff* gAppNmiBufferPtr;
 SchedContext gSchedContext;
 PadMgr gPadMgr;
 IrqMgr gIrqMgr;
@@ -23,21 +23,19 @@ StackEntry sSchedStackInfo;
 StackEntry sAudioStackInfo;
 StackEntry sPadMgrStackInfo;
 StackEntry sIrqMgrStackInfo;
-u8 gAudioMgr[0x298]; //type should be AudioMgr
+u8 gAudioMgr[0x298]; // type should be AudioMgr
 OSMesgQueue sSiIntMsgQ;
 OSMesg sSiIntMsgBuf[1];
 
-
-void Main_LogSystemHeap()
-{
+void Main_LogSystemHeap() {
     osSyncPrintf(VT_FGCOL(GREEN));
-    //System heap size% 08x (% dKB) Start address% 08x
-    osSyncPrintf("システムヒープサイズ %08x(%dKB) 開始アドレス %08x\n", gSystemHeapSize, gSystemHeapSize / 1024, gSystemHeap);
+    // System heap size% 08x (% dKB) Start address% 08x
+    osSyncPrintf("システムヒープサイズ %08x(%dKB) 開始アドレス %08x\n", gSystemHeapSize, gSystemHeapSize / 1024,
+                 gSystemHeap);
     osSyncPrintf(VT_RST);
 }
 
-void Main(void* arg0)
-{
+void Main(void* arg0) {
     IrqMgrClient irqClient;
     OSMesgQueue irqMgrMsgQ;
     OSMesg irqMgrMsgBuf[60];
@@ -45,27 +43,24 @@ void Main(void* arg0)
     u32 fb;
     s32 debugHeap;
     s32 debugHeapSize;
-    s16 *msg;
+    s16* msg;
 
-    osSyncPrintf("mainproc 実行開始\n"); //Start running
+    osSyncPrintf("mainproc 実行開始\n"); // Start running
     gScreenWidth = SCREEN_WIDTH;
     gScreenHeight = SCREEN_HEIGHT;
-    gAppNmiBufferPtr = osAppNmiBuffer;
-    func_8007BE60(gAppNmiBufferPtr);
+    gAppNmiBufferPtr = (PreNmiBuff*)osAppNmiBuffer;
+    PreNmiBuff_Init(gAppNmiBufferPtr);
     Fault_Start();
     SysCfb_Init(0);
     sysHeap = (u32)gSystemHeap;
     fb = SysCfb_GetFbPtr(0);
     gSystemHeapSize = (fb - sysHeap);
-    osSyncPrintf("システムヒープ初期化 %08x-%08x %08x\n", sysHeap, fb, gSystemHeapSize); //System heap initalization
-    SystemHeap_Init(sysHeap, gSystemHeapSize); //initializes the system heap
-    if (osMemSize >= 0x800000U)
-    {
+    osSyncPrintf("システムヒープ初期化 %08x-%08x %08x\n", sysHeap, fb, gSystemHeapSize); // System heap initalization
+    SystemHeap_Init(sysHeap, gSystemHeapSize);                                           // initializes the system heap
+    if (osMemSize >= 0x800000U) {
         debugHeap = SysCfb_GetFbEnd();
-        debugHeapSize = (s32) (0x80600000 - debugHeap);
-    }
-    else
-    {
+        debugHeapSize = (s32)(0x80600000 - debugHeap);
+    } else {
         debugHeapSize = 0x400;
         debugHeap = SystemArena_MallocDebug(debugHeapSize, "../main.c", 0x235);
     }
@@ -81,43 +76,42 @@ void Main(void* arg0)
     Main_LogSystemHeap();
 
     osCreateMesgQueue(&irqMgrMsgQ, irqMgrMsgBuf, 0x3c);
-    StackCheck_Init(&sIrqMgrStackInfo, sIrqMgrStack, sIrqMgrStack+sizeof(sIrqMgrStack), 0, 0x100, "irqmgr");
+    StackCheck_Init(&sIrqMgrStackInfo, sIrqMgrStack, sIrqMgrStack + sizeof(sIrqMgrStack), 0, 0x100, "irqmgr");
     IrqMgr_Create(&gIrqMgr, &sGraphStackInfo, 0x11, 1);
 
-    osSyncPrintf("タスクスケジューラの初期化\n"); //Initialize the task scheduler
-    StackCheck_Init(&sSchedStackInfo, sSchedStack, sSchedStack+sizeof(sSchedStack), 0, 0x100, "sched");
+    osSyncPrintf("タスクスケジューラの初期化\n"); // Initialize the task scheduler
+    StackCheck_Init(&sSchedStackInfo, sSchedStack, sSchedStack + sizeof(sSchedStack), 0, 0x100, "sched");
     func_800C9874(&gSchedContext, &sAudioStack, 0xf, D_80013960, 1, &gIrqMgr);
 
     IrqMgr_AddClient(&gIrqMgr, &irqClient, &irqMgrMsgQ);
 
-    StackCheck_Init(&sAudioStackInfo, sAudioStack, sAudioStack+sizeof(sAudioStack), 0, 0x100, "audio");
-    func_800C3FEC(&gAudioMgr, sAudioStack+sizeof(sAudioStack), 0xc, 0xa, &gSchedContext, &gIrqMgr);
+    StackCheck_Init(&sAudioStackInfo, sAudioStack, sAudioStack + sizeof(sAudioStack), 0, 0x100, "audio");
+    func_800C3FEC(&gAudioMgr, sAudioStack + sizeof(sAudioStack), 0xc, 0xa, &gSchedContext, &gIrqMgr);
 
-    StackCheck_Init(&sPadMgrStackInfo, sPadMgrStack, sPadMgrStack+sizeof(sPadMgrStack), 0, 0x100, "padmgr");
+    StackCheck_Init(&sPadMgrStackInfo, sPadMgrStack, sPadMgrStack + sizeof(sPadMgrStack), 0, 0x100, "padmgr");
     PadMgr_Init(&gPadMgr, &sSiIntMsgQ, &gIrqMgr, 7, 0xe, &sIrqMgrStack);
 
     func_800C3FC4(&gAudioMgr);
 
-    StackCheck_Init(&sGraphStackInfo, sGraphStack, sGraphStack+sizeof(sGraphStack), 0, 0x100, "graph");
-    osCreateThread(&sGraphThread, 4, Graph_ThreadEntry, arg0, sGraphStack+sizeof(sGraphStack), 0xb);
+    StackCheck_Init(&sGraphStackInfo, sGraphStack, sGraphStack + sizeof(sGraphStack), 0, 0x100, "graph");
+    osCreateThread(&sGraphThread, 4, Graph_ThreadEntry, arg0, sGraphStack + sizeof(sGraphStack), 0xb);
     osStartThread(&sGraphThread);
     osSetThreadPri(0, 0xf);
 
-    while (true)
-    {
+    while (true) {
         msg = NULL;
         osRecvMesg(&irqMgrMsgQ, &msg, OS_MESG_BLOCK);
-        if (msg == NULL)
+        if (msg == NULL) {
             break;
-        if (*msg == OS_SC_PRE_NMI_MSG)
-        {
-            osSyncPrintf("main.c: リセットされたみたいだよ\n"); //Looks like it's been reset
-            func_8007BED4(gAppNmiBufferPtr);
+        }
+        if (*msg == OS_SC_PRE_NMI_MSG) {
+            osSyncPrintf("main.c: リセットされたみたいだよ\n"); // Looks like it's been reset
+            PreNmiBuff_SetReset(gAppNmiBufferPtr);
         }
     }
 
-    osSyncPrintf("mainproc 後始末\n"); //Cleanup
+    osSyncPrintf("mainproc 後始末\n"); // Cleanup
     osDestroyThread(&sGraphThread);
     func_800FBFD8();
-    osSyncPrintf("mainproc 実行終了\n"); //End of execution
+    osSyncPrintf("mainproc 実行終了\n"); // End of execution
 }
diff --git a/src/code/padmgr.c b/src/code/padmgr.c
index 0c0201c63..dc3e9c472 100644
--- a/src/code/padmgr.c
+++ b/src/code/padmgr.c
@@ -1,130 +1,125 @@
 #include <ultra64.h>
 #include <global.h>
+#include <vt.h>
 
 #include <PR/os_cont.h>
 #include <ultra64/controller.h>
 #include <padmgr.h>
 
-OSMesgQueue* PadMgr_LockGetControllerQueue(PadMgr* padmgr)
-{
+s32 D_8012D280 = 1;
+
+OSMesgQueue* PadMgr_LockGetControllerQueue(PadMgr* padmgr) {
     OSMesgQueue* ctrlrqueue = NULL;
 
-    if (D_8012D280 > 2)
-        //EUC-JP: ロック待ち | Waiting for lock
-        osSyncPrintf("%2d %d serialMsgQロック待ち         %08x %08x          %08x\n", osGetThreadId(NULL), padmgr->queue1.validCount, padmgr, &padmgr->queue1, &ctrlrqueue);
+    if (D_8012D280 > 2) {
+        // EUC-JP: ロック待ち | Waiting for lock
+        osSyncPrintf("%2d %d serialMsgQロック待ち         %08x %08x          %08x\n", osGetThreadId(NULL),
+                     padmgr->queue1.validCount, padmgr, &padmgr->queue1, &ctrlrqueue);
+    }
 
     osRecvMesg(&padmgr->queue1, &ctrlrqueue, OS_MESG_BLOCK);
 
-    if (D_8012D280 > 2)
-        //EUC-JP: をロックしました | Locked
-        osSyncPrintf("%2d %d serialMsgQをロックしました                     %08x\n", osGetThreadId(NULL), padmgr->queue1.validCount, ctrlrqueue);
+    if (D_8012D280 > 2) {
+        // EUC-JP: をロックしました | Locked
+        osSyncPrintf("%2d %d serialMsgQをロックしました                     %08x\n", osGetThreadId(NULL),
+                     padmgr->queue1.validCount, ctrlrqueue);
+    }
 
     return ctrlrqueue;
 }
 
-void PadMgr_UnlockReleaseControllerQueue(PadMgr* padmgr, OSMesgQueue* ctrlrqueue)
-{
-    if (D_8012D280 > 2)
-        //EUC-JP: ロック解除します | Unlock
-        osSyncPrintf("%2d %d serialMsgQロック解除します   %08x %08x %08x\n", osGetThreadId(NULL), padmgr->queue1.validCount, padmgr, &padmgr->queue1, ctrlrqueue);
+void PadMgr_UnlockReleaseControllerQueue(PadMgr* padmgr, OSMesgQueue* ctrlrqueue) {
+    if (D_8012D280 > 2) {
+        // EUC-JP: ロック解除します | Unlock
+        osSyncPrintf("%2d %d serialMsgQロック解除します   %08x %08x %08x\n", osGetThreadId(NULL),
+                     padmgr->queue1.validCount, padmgr, &padmgr->queue1, ctrlrqueue);
+    }
 
     osSendMesg(&padmgr->queue1, ctrlrqueue, OS_MESG_BLOCK);
 
-    if (D_8012D280 > 2)
-        //EUC-JP: ロック解除しました | Unlocked
-        osSyncPrintf("%2d %d serialMsgQロック解除しました %08x %08x %08x\n", osGetThreadId(NULL), padmgr->queue1.validCount, padmgr, &padmgr->queue1, ctrlrqueue);
+    if (D_8012D280 > 2) {
+        // EUC-JP: ロック解除しました | Unlocked
+        osSyncPrintf("%2d %d serialMsgQロック解除しました %08x %08x %08x\n", osGetThreadId(NULL),
+                     padmgr->queue1.validCount, padmgr, &padmgr->queue1, ctrlrqueue);
+    }
 }
 
-void PadMgr_Lock2(PadMgr* padmgr)
-{
-    osRecvMesg(&padmgr->queue2, 0, OS_MESG_BLOCK);
+void PadMgr_Lock2(PadMgr* padmgr) {
+    osRecvMesg(&padmgr->queue2, NULL, OS_MESG_BLOCK);
 }
 
-void PadMgr_Unlock2(PadMgr* padmgr)
-{
-    osSendMesg(&padmgr->queue2, 0, OS_MESG_BLOCK);
+void PadMgr_Unlock2(PadMgr* padmgr) {
+    osSendMesg(&padmgr->queue2, NULL, OS_MESG_BLOCK);
 }
 
 #ifdef NON_MATCHING
-void func_800C740C(PadMgr* padmgr)
-{
+// regalloc and minor ordering differences
+void func_800C740C(PadMgr* padmgr) {
+    static u32 D_8012D284 = 0;
+    static u32 D_8016A4F0;
+    s32 temp;
     s32 var1;
     OSMesgQueue* ctrlrqueue;
     s32 var3;
     s32 var4;
     s32 i;
 
+    temp = 1;
     ctrlrqueue = PadMgr_LockGetControllerQueue(padmgr);
     var1 = 0;
 
-    for (i = 0; i < 4; i++)
-    {
-        if (padmgr->unk_2AA[i] != 0)
-        {
-            if (padmgr->pad_status[i].status & 1)
-            {
-                if (padmgr->unk_2AE[i] == 1)
-                {
-                    if (padmgr->unk_2B2[i] != 0)
-                    {
-                        if (padmgr->unk_2B6[i] < 3)
-                        {
-                            osSyncPrintf(D_80145894); //"\x1b[33m" (probably formatting/debugger interface)
-                            osSyncPrintf(D_8014589C, i + 1, D_801458B0); //"padmgr: %d[JPN]Con: ", "[JPN]Vibration pack jumble jumble"
-                            osSyncPrintf(D_801458CC); //"\x1b[m" (probably formatting/debugger interface)
-                            if (osSetVibration(&padmgr->unk_controller[i], 1) != 0)
-                            {
+    for (i = 0; i < 4; i++) {
+        if (padmgr->unk_2AA[i] != 0) {
+            if (padmgr->pad_status[i].status & 1) {
+                if (padmgr->unk_2AE[i] == temp) {
+                    if (padmgr->unk_2B2[i] != 0) {
+                        if (padmgr->unk_2B6[i] < 3) {
+                            osSyncPrintf(VT_FGCOL(YELLOW));
+                            osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パック ぶるぶるぶるぶる");
+                            osSyncPrintf(VT_RST);
+
+                            if (osSetVibration(&padmgr->unk_controller[i], temp) != 0) {
                                 padmgr->unk_2AE[i] = 0;
-                                osSyncPrintf(D_801458D0);
-                                osSyncPrintf(D_801458D8, i + 1, D_801458EC); //"A communication error has occurred with the vibraton pack"
-                                osSyncPrintf(D_80145914);
-                            }
-                            else
-                            {
+                                osSyncPrintf(VT_FGCOL(YELLOW));
+                                osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パックで通信エラーが発生しました");
+                                osSyncPrintf(VT_RST);
+                            } else {
                                 padmgr->unk_2B6[i] = 3;
                             }
+
                             var1 = 1;
                         }
-                    }
-                    else
-                    {
-                        if (padmgr->unk_2B6[i] != 0)
-                        {
-                            osSyncPrintf(D_80145918);
-                            osSyncPrintf(D_80145920, i + 1, D_80145934); //"Stop vibration pack"
-                            osSyncPrintf(D_80145944);
-                            if (osSetVibration(&padmgr->unk_controller[i], 0) != 0)
-                            {
+                    } else {
+                        if (padmgr->unk_2B6[i] != 0) {
+                            osSyncPrintf(VT_FGCOL(YELLOW));
+                            osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パック 停止");
+                            osSyncPrintf(VT_RST);
+
+                            if (osSetVibration(&padmgr->unk_controller[i], 0) != 0) {
                                 padmgr->unk_2AE[i] = 0;
-                                osSyncPrintf(D_80145948);
-                                osSyncPrintf(D_80145950, i + 1, D_80145964); //"A communication error has occurred with the vibration pack"
-                                osSyncPrintf(D_8014598C);
-                            }
-                            else
-                            {
+                                osSyncPrintf(VT_FGCOL(YELLOW));
+                                osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パックで通信エラーが発生しました");
+                                osSyncPrintf(VT_RST);
+                            } else {
                                 padmgr->unk_2B6[i]--;
                             }
+
                             var1 = 1;
                         }
                     }
                 }
-            }
-            else
-            {
-                if (padmgr->unk_2AE[i] != 0)
-                {
-                    if (padmgr->unk_2AE[i] == 1)
-                    {
-                        osSyncPrintf(D_80145990);
-                        osSyncPrintf(D_80145998, i + 1, D_801459AC); //"Vibration pack seems to be pulled out"
-                        osSyncPrintf(D_801459CC);
+            } else {
+                if (padmgr->unk_2AE[i] != 0) {
+                    if (padmgr->unk_2AE[i] == 1) {
+                        osSyncPrintf(VT_FGCOL(YELLOW));
+                        osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パックが抜かれたようです");
+                        osSyncPrintf(VT_RST);
                         padmgr->unk_2AE[i] = 0;
-                    }
-                    else
-                    {
-                        osSyncPrintf(D_801459D0);
-                        osSyncPrintf(D_80145A24);
-                        osSyncPrintf(D_801459D8, i + 1, D_801459EC); //"It seems that a controller pack that is not a vibration pack was pulled out"
+                    } else {
+                        osSyncPrintf(VT_FGCOL(YELLOW));
+                        osSyncPrintf("padmgr: %dコン: %s\n", i + 1,
+                                     "振動パックではないコントローラパックが抜かれたようです");
+                        osSyncPrintf(VT_RST);
                         padmgr->unk_2AE[i] = 0;
                     }
                 }
@@ -132,35 +127,26 @@ void func_800C740C(PadMgr* padmgr)
         }
     }
 
-    if (!var1)
-    {
+    if (!var1) {
         var3 = D_8016A4F0 % 4;
 
-        if ((padmgr->unk_2AA[var3] != 0) && (padmgr->pad_status[var3].status & 1) && (padmgr->unk_2AE[var3] != 1))
-        {
+        if ((padmgr->unk_2AA[var3] != 0) && (padmgr->pad_status[var3].status & 1) && (padmgr->unk_2AE[var3] != 1)) {
             var4 = osProbeVibrationPack(ctrlrqueue, &padmgr->unk_controller[var3], var3);
 
-            if (var4 == 0)
-            {
+            if (var4 == 0) {
                 padmgr->unk_2AE[var3] = 1;
                 osSetVibration(&padmgr->unk_controller[var3], 1);
                 osSetVibration(&padmgr->unk_controller[var3], 0);
-                osSyncPrintf(D_80145A28);
-                osSyncPrintf(D_80145A30, var3 + 1, D_80145A44); //"Recognized vibration pack"
-                osSyncPrintf(D_80145A60);
-            }
-            else if (var4 == 11)
-            {
+                osSyncPrintf(VT_FGCOL(YELLOW));
+                osSyncPrintf("padmgr: %dコン: %s\n", var3 + 1, "振動パックを認識しました");
+                osSyncPrintf(VT_RST);
+            } else if (var4 == 11) {
                 padmgr->unk_2AE[var3] = 2;
-            }
-            else if (var4 == 4)
-            {
-                LogUtils_LogThreadId(D_80145A64, 282);
-                ++D_8012D284;
-                osSyncPrintf(D_80145A70, D_8012D284); //"++errcnt = %d"
-                osSyncPrintf(D_80145A80);
-                osSyncPrintf(D_80145A88, var3 + 1, D_80145A9C); //"Controller pack communication error"
-                osSyncPrintf(D_80145ABC);
+            } else if (var4 == 4) {
+                LOG_NUM("++errcnt", ++D_8012D284, "../padmgr.c", 282);
+                osSyncPrintf(VT_FGCOL(YELLOW));
+                osSyncPrintf("padmgr: %dコン: %s\n", var3 + 1, "コントローラパックの通信エラー");
+                osSyncPrintf(VT_RST);
             }
         }
     }
@@ -169,27 +155,25 @@ void func_800C740C(PadMgr* padmgr)
     PadMgr_UnlockReleaseControllerQueue(padmgr, ctrlrqueue);
 }
 #else
+u32 D_8012D284 = 0;
+u32 D_8016A4F0;
 #pragma GLOBAL_ASM("asm/non_matchings/code/padmgr/func_800C740C.s")
 #endif
 
-//func_800A2300 in 1.0
-void func_800C7818(PadMgr* padmgr)
-{
+// func_800A2300 in 1.0
+void func_800C7818(PadMgr* padmgr) {
     s32 i;
     OSMesgQueue* ctrlrqueue;
 
     ctrlrqueue = PadMgr_LockGetControllerQueue(padmgr);
 
-    for (i = 0; i < 4; i++)
-    {
-        if (osProbeVibrationPack(ctrlrqueue, &padmgr->unk_controller[i], i) == 0)
-        {
-            if ((gFaultStruct.msgId == 0) && (padmgr->unk_45D != 0))
-            {
-                osSyncPrintf("\x1b[33m");
-                //EUC-JP: コン | 'Con'? , EUC-JP:  振動パック 停止 | Stop vibration pack
+    for (i = 0; i < 4; i++) {
+        if (osProbeVibrationPack(ctrlrqueue, &padmgr->unk_controller[i], i) == 0) {
+            if ((gFaultStruct.msgId == 0) && (padmgr->unk_45D != 0)) {
+                osSyncPrintf(VT_FGCOL(YELLOW));
+                // EUC-JP: コン | 'Con'? , EUC-JP:  振動パック 停止 | Stop vibration pack
                 osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パック 停止");
-                osSyncPrintf("\x1b[m");
+                osSyncPrintf(VT_RST);
             }
 
             osSetVibration(&padmgr->unk_controller[i], 0);
@@ -199,21 +183,19 @@ void func_800C7818(PadMgr* padmgr)
     PadMgr_UnlockReleaseControllerQueue(padmgr, ctrlrqueue);
 }
 
-void func_800C7928(PadMgr* padmgr)
-{
+void func_800C7928(PadMgr* padmgr) {
     padmgr->unk_45C = 3;
 }
 
-void func_800C7934(PadMgr* padmgr, u32 a1, u32 a2)
-{
+void func_800C7934(PadMgr* padmgr, u32 a1, u32 a2) {
     padmgr->unk_2B2[a1] = a2;
     padmgr->unk_45D = 0xF0;
 }
 
 #ifdef NON_MATCHING
-//func_800A23CC in 1.0
-void func_800C7948(PadMgr* padmgr, u8* a1)
-{
+// minor ordering difference
+// 800A23CC in 1.0
+void func_800C7948(PadMgr* padmgr, u8* a1) {
     padmgr->unk_2B2[0] = a1[0];
     padmgr->unk_2B2[1] = a1[1];
     padmgr->unk_2B2[2] = a1[2];
@@ -229,46 +211,45 @@ void func_800C7948(PadMgr* padmgr, u8* a1)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/padmgr/func_800C7C14.s")
 
-void func_800C7DD0(PadMgr* padmgr)
-{
+void func_800C7DD0(PadMgr* padmgr) {
     osSyncPrintf("padmgr_HandlePreNMI()\n");
     padmgr->unk_45E = 1;
     func_800C7928(padmgr);
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/padmgr/func_800C7E08.s")
-//void func_800C7E08(Input*, u32);
+// void func_800C7E08(Input*, u32);
 
-//800A2918 in 1.0
-void PadMgr_Run(PadMgr* padmgr)
-{
+// 800A2918 in 1.0
+void PadMgr_Run(PadMgr* padmgr) {
     s16* mesg;
     s32 bVar2;
 
     mesg = NULL;
-    //EUC-JP: コントローラスレッド実行開始 | Start of controller thread execution
+    // EUC-JP: コントローラスレッド実行開始 | Start of controller thread execution
     osSyncPrintf("コントローラスレッド実行開始\n");
     bVar2 = 0;
 
-    while (bVar2 == 0)
-    {
-        if ((D_8012D280 > 2) && (padmgr->queue3.validCount == 0))
-            //EUC-JP: コントローラスレッドイベント待ち | Waiting for controller thread event
-            osSyncPrintf("コントローラスレッドイベント待ち %lld\n" , (osGetTime() * 64) / 3000);
+    while (bVar2 == 0) {
+        if ((D_8012D280 > 2) && (padmgr->queue3.validCount == 0)) {
+            // EUC-JP: コントローラスレッドイベント待ち | Waiting for controller thread event
+            osSyncPrintf("コントローラスレッドイベント待ち %lld\n", (osGetTime() * 64) / 3000);
+        }
 
         osRecvMesg(&padmgr->queue3, &mesg, OS_MESG_BLOCK);
         LogUtils_CheckNullPointer("msg", mesg, "../padmgr.c", 563);
 
-        switch (*mesg)
-        {
+        switch (*mesg) {
             case OS_SC_RETRACE_MSG:
-                if (D_8012D280 > 2)
+                if (D_8012D280 > 2) {
                     osSyncPrintf("padmgr_HandleRetraceMsg START %lld\n", (osGetTime() * 64) / 3000);
+                }
 
                 func_800C7C14(padmgr);
 
-                if (D_8012D280 > 2)
+                if (D_8012D280 > 2) {
                     osSyncPrintf("padmgr_HandleRetraceMsg END   %lld\n", (osGetTime() * 64) / 3000);
+                }
 
                 break;
             case OS_SC_PRE_NMI_MSG:
@@ -281,14 +262,13 @@ void PadMgr_Run(PadMgr* padmgr)
     }
 
     IrqMgr_RemoveClient(padmgr->unk_78, &padmgr->unk_70);
-    //EUC-JP: コントローラスレッド実行終了 | Controller thread execution end
+    // EUC-JP: コントローラスレッド実行終了 | Controller thread execution end
     osSyncPrintf("コントローラスレッド実行終了\n");
 }
 
-//func_800A2A14 in 1.0
-void PadMgr_Init(PadMgr* padmgr, OSMesgQueue* ctrlrqueue, UNK_TYPE arg2, OSId id, OSPri priority, void* stack)
-{
-    //EUC-JP: パッドマネージャ作成 | Create pad manager
+// func_800A2A14 in 1.0
+void PadMgr_Init(PadMgr* padmgr, OSMesgQueue* ctrlrqueue, UNK_TYPE arg2, OSId id, OSPri priority, void* stack) {
+    // EUC-JP: パッドマネージャ作成 | Create pad manager
     osSyncPrintf("パッドマネージャ作成 padmgr_Create()\n");
     bzero(padmgr, sizeof(PadMgr));
     padmgr->unk_78 = arg2;
diff --git a/src/code/relocation.c b/src/code/relocation.c
index 6e429742c..80839b9d9 100644
--- a/src/code/relocation.c
+++ b/src/code/relocation.c
@@ -1,3 +1,3 @@
 #include <global.h>
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/relocation/Overlay_DoRelocation.s")
\ No newline at end of file
+#pragma GLOBAL_ASM("asm/non_matchings/code/relocation/Overlay_DoRelocation.s")
diff --git a/src/code/sched.c b/src/code/sched.c
index dcf38e22b..af971ff2e 100644
--- a/src/code/sched.c
+++ b/src/code/sched.c
@@ -4,14 +4,13 @@
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C82A0.s")
 
-void func_800C84E4(SchedContext* sc, UNK_TYPE arg1)
-{
-    if (sc->unk_24C != 0)
-    {
+void func_800C84E4(SchedContext* sc, UNK_TYPE arg1) {
+    if (sc->unk_24C != 0) {
         sc->unk_24C = 0;
 
-        if (gIrqMgrResetStatus == 0)
+        if (gIrqMgrResetStatus == 0) {
             ViConfig_UpdateVi(0);
+        }
     }
 
     func_800C82A0(arg1);
@@ -19,26 +18,25 @@ void func_800C84E4(SchedContext* sc, UNK_TYPE arg1)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C8534.s")
 
-void func_800C87CC(SchedContext* sc)
-{
+void func_800C87CC(SchedContext* sc) {
     ViConfig_UpdateVi(1);
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C87F0.s")
 
-void func_800C8910(SchedContext* sc)
-{
-    if (!(sc->curRSPTask->state & 0x10))
-    {
-        if (sc->curRSPTask->list.t.type == M_AUDTASK)
+void func_800C8910(SchedContext* sc) {
+    if (!(sc->curRSPTask->state & 0x10)) {
+        if (sc->curRSPTask->list.t.type == M_AUDTASK) {
             __assert("sc->curRSPTask->list.t.type != M_AUDTASK", "../sched.c", 496);
+        }
 
         sc->curRSPTask->state |= 0x10;
 
         osSpTaskYield();
 
-        if (D_8012D290 != 0)
+        if (D_8012D290 != 0) {
             osSyncPrintf("%08d:osSpTaskYield\n", (u32)((osGetTime() * 64) / 3000));
+        }
     }
 }
 
@@ -46,39 +44,37 @@ void func_800C8910(SchedContext* sc)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C8A94.s")
 
-typedef struct
-{
-    /* 0x00 */ char     unk_00[0x04];
-    /* 0x00 */ u32      unk_04;
-    /* 0x00 */ u32      unk_08;
+typedef struct {
+    /* 0x00 */ char unk_00[0x04];
+    /* 0x00 */ u32 unk_04;
+    /* 0x00 */ u32 unk_08;
     /* 0x0C */ UNK_TYPE unk_0C;
-    /* 0x10 */ char     unk_10[0x40];
+    /* 0x10 */ char unk_10[0x40];
     /* 0x50 */ OSMesgQueue* msgQ;
-    /* 0x54 */ OSMesg   msg;
+    /* 0x54 */ OSMesg msg;
 } struct_800C8C40;
 
-void func_800C8BC4(SchedContext* sc, struct_800C8C40* arg1)
-{
-    if (sc->pendingSwapBuf1 == 0)
-    {
+void func_800C8BC4(SchedContext* sc, struct_800C8C40* arg1) {
+    if (sc->pendingSwapBuf1 == 0) {
         sc->pendingSwapBuf1 = arg1->unk_0C;
 
         LogUtils_CheckValidPointer("sc->pending_swapbuffer1", sc->pendingSwapBuf1, "../sched.c", 618);
 
-        if ((sc->unk_240 == NULL) || (sc->unk_240->unk_12 < 1))
+        if ((sc->unk_240 == NULL) || (sc->unk_240->unk_12 < 1)) {
             func_800C84E4(sc, arg1->unk_0C);
+        }
     }
 }
 
-u32 func_800C8C40(SchedContext* sc, struct_800C8C40* arg1)
-{
-    if (!(arg1->unk_04 & 3))
-    {
-        if (arg1->msgQ != NULL)
+u32 func_800C8C40(SchedContext* sc, struct_800C8C40* arg1) {
+    if (!(arg1->unk_04 & 3)) {
+        if (arg1->msgQ != NULL) {
             osSendMesg(arg1->msgQ, arg1->msg, OS_MESG_BLOCK);
+        }
 
-        if (arg1->unk_08 & 0x40)
+        if (arg1->unk_08 & 0x40) {
             func_800C8BC4(sc, arg1);
+        }
 
         return 1;
     }
@@ -96,18 +92,17 @@ u32 func_800C8C40(SchedContext* sc, struct_800C8C40* arg1)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C94B4.s")
 
-void func_800C95F8(OSMesgQueue* mq)
-{
-    if (D_8012D290 != 0)
+void func_800C95F8(OSMesgQueue* mq) {
+    if (D_8012D290 != 0) {
         osSyncPrintf("osScKickEntryMsg\n");
+    }
 
     osSendMesg(mq, 670, OS_MESG_BLOCK);
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C9644.s")
 
-void func_800C9874(SchedContext* sc, void* stack, OSPri priority, UNK_TYPE arg3, UNK_TYPE arg4, UNK_TYPE arg5)
-{
+void func_800C9874(SchedContext* sc, void* stack, OSPri priority, UNK_TYPE arg3, UNK_TYPE arg4, UNK_TYPE arg5) {
     bzero(sc, sizeof(SchedContext));
     sc->unk_24C = 1;
     osCreateMesgQueue(&sc->interruptQ, sc->intBuf, 8);
diff --git a/src/code/speed_meter.c b/src/code/speed_meter.c
index 3c5cecf9c..ec5e93b07 100644
--- a/src/code/speed_meter.c
+++ b/src/code/speed_meter.c
@@ -1,36 +1,30 @@
 #include <ultra64.h>
 #include <global.h>
 
-typedef struct
-{
+typedef struct {
     /* 0x00 */ char unk_00[0x18];
-    /* 0x18 */ s32  unk_18;
-    /* 0x1C */ s32  unk_1C;
+    /* 0x18 */ s32 unk_18;
+    /* 0x1C */ s32 unk_1C;
 } struct_801664D0; // size = 0x20
 
 extern struct_801664D0 D_801664D0;
 
-void func_800C9940(struct_801664D0* arg0, u32 arg1, u32 arg2)
-{
+void func_800C9940(struct_801664D0* arg0, u32 arg1, u32 arg2) {
     LogUtils_CheckNullPointer("this", arg0, "../speed_meter.c", 181);
     arg0->unk_18 = arg1;
     arg0->unk_1C = arg2;
 }
 
-void func_800C9998(struct_801664D0* arg0)
-{
+void func_800C9998(struct_801664D0* arg0) {
     func_800C9940(arg0, 0x20, 0x16);
 }
 
-void func_800C99BC(struct_801664D0* arg0)
-{
-
+void func_800C99BC(struct_801664D0* arg0) {
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/speed_meter/func_800C99C4.s")
 
-typedef struct
-{
+typedef struct {
     /* 0x00 */ u32 unk_00;
     /* 0x04 */ u32 unk_04;
     /* 0x08 */ u16 unk_08;
@@ -41,8 +35,8 @@ typedef struct
     /* 0x18 */ u32 unk_18;
 } struct_800C9E08;
 
-void func_800C9E08(struct_800C9E08* arg0, u32 arg1, u32 arg2, u16 arg3, u16 arg4, u32 arg5, u32 arg6, u32 arg7, u32 arg8)
-{
+void func_800C9E08(struct_800C9E08* arg0, u32 arg1, u32 arg2, u16 arg3, u16 arg4, u32 arg5, u32 arg6, u32 arg7,
+                   u32 arg8) {
     arg0->unk_00 = arg1;
     arg0->unk_04 = arg2;
     arg0->unk_08 = arg3;
diff --git a/src/code/sys_cfb.c b/src/code/sys_cfb.c
index 182e53f4d..421037c38 100644
--- a/src/code/sys_cfb.c
+++ b/src/code/sys_cfb.c
@@ -1,66 +1,54 @@
 #include <global.h>
 
-volatile u32 sSysCfbFbPtr[2]; //may not be volatile but it currently gets SysCfb_Init closer from matching
+u32 sSysCfbFbPtr[2];
 u32 sSysCfbEnd;
 
-//small reaordering
-#ifdef NON_MATCHING
-void SysCfb_Init(s32 n64dd)
-{
-    if (osMemSize >= 0x800000U)        
-    {
-        //8MB or more memory is installed
+void SysCfb_Init(s32 n64dd) {
+    u32 screenSize;
+    u32 tmpFbEnd;
+    if (osMemSize >= 0x800000U) {
+        // 8MB or more memory is installed
         osSyncPrintf("８Ｍバイト以上のメモリが搭載されています\n");
-        if (n64dd == 1)
-        {
-            //RAM 8M mode (N64DD compatible)
+        tmpFbEnd = 0x8044BE80;
+        if (n64dd == 1) {
+            // RAM 8M mode (N64DD compatible)
             osSyncPrintf("RAM 8M mode (N64DD対応)\n");
             sSysCfbEnd = 0x805FB000;
-        }
-        else
-        {
-            //The margin for this version is% dK bytes
+        } else {
+            // The margin for this version is% dK bytes
             osSyncPrintf("このバージョンのマージンは %dK バイトです\n", (0x4BC00 / 1024));
-            sSysCfbEnd = 0x8044BE80;
+            sSysCfbEnd = tmpFbEnd;
         }
-    }
-    else if (osMemSize >= 0x400000U)
-    {
-        sSysCfbEnd = 0x80400000;
+    } else if (osMemSize >= 0x400000U) {
         osSyncPrintf("RAM4M mode\n");
-    }
-    else
-    {
+        sSysCfbEnd = 0x80400000;
+    } else {
         LogUtils_HungupThread("../sys_cfb.c", 0x162);
     }
 
+    screenSize = SCREEN_WIDTH * SCREEN_HEIGHT;
     sSysCfbEnd &= ~0x3f;
-    //The final address used by the system is% 08x
+    // The final address used by the system is% 08x
     osSyncPrintf("システムが使用する最終アドレスは %08x です\n", sSysCfbEnd);
-    sSysCfbFbPtr[0] = sSysCfbEnd - (SCREEN_WIDTH*SCREEN_HEIGHT*4);
-    sSysCfbFbPtr[1] = sSysCfbEnd - (SCREEN_WIDTH*SCREEN_HEIGHT*2);
-    //Frame buffer addresses are% 08x and% 08x
+    sSysCfbFbPtr[0] = sSysCfbEnd - (screenSize * 4);
+    sSysCfbFbPtr[1] = sSysCfbEnd - (screenSize * 2);
+    // Frame buffer addresses are% 08x and% 08x
     osSyncPrintf("フレームバッファのアドレスは %08x と %08x です\n", sSysCfbFbPtr[0], sSysCfbFbPtr[1]);
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_cfb/SysCfb_Init.s")
-#endif
 
-void SysCfb_Reset()
-{
+void SysCfb_Reset() {
     sSysCfbFbPtr[0] = 0;
     sSysCfbFbPtr[1] = 0;
     sSysCfbEnd = 0;
 }
 
-u32 SysCfb_GetFbPtr(s32 idx)
-{
-    if (idx < 2)
+u32 SysCfb_GetFbPtr(s32 idx) {
+    if (idx < 2) {
         return sSysCfbFbPtr[idx];
+    }
     return 0;
 }
 
-u32 SysCfb_GetFbEnd()
-{
+u32 SysCfb_GetFbEnd() {
     return sSysCfbEnd;
-}
\ No newline at end of file
+}
diff --git a/src/code/sys_matrix.c b/src/code/sys_matrix.c
index bd526cec7..c320a3286 100644
--- a/src/code/sys_matrix.c
+++ b/src/code/sys_matrix.c
@@ -1,96 +1,91 @@
 #include <ultra64.h>
 #include <global.h>
 
-Mtx gMtxClear =
-{
+// clang-format off
+Mtx gMtxClear = {
     65536,     0,     1,     0,
         0, 65536,     0,     1,
         0,     0,     0,     0,
         0,     0,     0,     0,
 };
-MtxF gMtxFClear =
-{
+
+MtxF gMtxFClear = {
     1.0f, 0.0f, 0.0f, 0.0f,
     0.0f, 1.0f, 0.0f, 0.0f,
     0.0f, 0.0f, 1.0f, 0.0f,
     0.0f, 0.0f, 0.0f, 1.0f,
 };
+// clang-format on
 
-MtxF* sMatrixStack; // "Matrix_stack"
+MtxF* sMatrixStack;   // "Matrix_stack"
 MtxF* sCurrentMatrix; // "Matrix_now"
 
-void Matrix_Init(GameState* gameState)
-{
+void Matrix_Init(GameState* gameState) {
     sCurrentMatrix = Game_Alloc(gameState, 20 * sizeof(MtxF), "../sys_matrix.c", 153);
     sMatrixStack = sCurrentMatrix;
 }
 
-void Matrix_Push(void)
-{
+void Matrix_Push(void) {
     Matrix_MtxFCopy(sCurrentMatrix + 1, sCurrentMatrix);
     sCurrentMatrix++;
 }
 
-void Matrix_Pull(void)
-{
+void Matrix_Pull(void) {
     sCurrentMatrix--;
-    if (sCurrentMatrix < sMatrixStack)
+    if (sCurrentMatrix < sMatrixStack) {
         __assert("Matrix_now >= Matrix_stack", "../sys_matrix.c", 176);
+    }
 }
 
-void Matrix_Get(MtxF* dest)
-{
+void Matrix_Get(MtxF* dest) {
     Matrix_MtxFCopy(dest, sCurrentMatrix);
 }
 
-void Matrix_Put(MtxF* src)
-{
+void Matrix_Put(MtxF* src) {
     Matrix_MtxFCopy(sCurrentMatrix, src);
 }
 
-MtxF* Matrix_GetCurrent(void)
-{
+MtxF* Matrix_GetCurrent(void) {
     return sCurrentMatrix;
 }
 
-void Matrix_Mult(MtxF* mf, u8 mode)
-{
+void Matrix_Mult(MtxF* mf, u8 mode) {
     MtxF* cmf = Matrix_GetCurrent();
 
-    if (mode == MTXMODE_APPLY)
+    if (mode == MTXMODE_APPLY) {
         func_800A6FA0(cmf, mf, cmf);
-    else
+    } else {
         Matrix_MtxFCopy(sCurrentMatrix, mf);
+    }
 }
 
-#ifdef NON_MATCHING
-// minor ordering and regalloc differences
-void Matrix_Translate(f32 x, f32 y, f32 z, u8 mode)
-{
+void Matrix_Translate(f32 x, f32 y, f32 z, u8 mode) {
     MtxF* cmf = sCurrentMatrix;
-
-    if (mode == MTXMODE_APPLY)
-    {
-        cmf->wx += cmf->xx * x + cmf->yx * y + cmf->zx * z;
-        cmf->wy += cmf->xy * x + cmf->yy * y + cmf->zy * z;
-        cmf->wz += cmf->xz * x + cmf->yz * y + cmf->zz * z;
-        cmf->ww += cmf->xw * x + cmf->yw * y + cmf->zw * z;
-    }
-    else
-    {
+    f32 tx;
+    f32 ty;
+
+    if (mode == MTXMODE_APPLY) {
+        tx = cmf->xx;
+        ty = cmf->yx;
+        cmf->wx += tx * x + ty * y + cmf->zx * z;
+        tx = cmf->xy;
+        ty = cmf->yy;
+        cmf->wy += tx * x + ty * y + cmf->zy * z;
+        tx = cmf->xz;
+        ty = cmf->yz;
+        cmf->wz += tx * x + ty * y + cmf->zz * z;
+        tx = cmf->xw;
+        ty = cmf->yw;
+        cmf->ww += tx * x + ty * y + cmf->zw * z;
+    } else {
         func_800A7A24(cmf, x, y, z);
     }
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_Translate.s")
-#endif
 
-void Matrix_Scale(f32 x, f32 y, f32 z, u8 mode)
-{
+void Matrix_Scale(f32 x, f32 y, f32 z, u8 mode) {
     MtxF* cmf = sCurrentMatrix;
 
-    if (mode == MTXMODE_APPLY)
-    {
+    if (mode == MTXMODE_APPLY) {
         cmf->xx *= x;
         cmf->xy *= x;
         cmf->xz *= x;
@@ -103,25 +98,20 @@ void Matrix_Scale(f32 x, f32 y, f32 z, u8 mode)
         cmf->xw *= x;
         cmf->yw *= y;
         cmf->zw *= z;
-    }
-    else
-    {
+    } else {
         func_800A76A4(cmf, x, y, z);
     }
 }
 
-void Matrix_RotateX(f32 x, u8 mode)
-{
+void Matrix_RotateX(f32 x, u8 mode) {
     MtxF* cmf;
     f32 sin;
     f32 cos;
     f32 temp1;
     f32 temp2;
 
-    if (mode == MTXMODE_APPLY)
-    {
-        if (x != 0)
-        {
+    if (mode == MTXMODE_APPLY) {
+        if (x != 0) {
             cmf = sCurrentMatrix;
 
             sin = sinf(x);
@@ -147,18 +137,13 @@ void Matrix_RotateX(f32 x, u8 mode)
             cmf->yw = temp1 * cos + temp2 * sin;
             cmf->zw = temp2 * cos - temp1 * sin;
         }
-    }
-    else
-    {
+    } else {
         cmf = sCurrentMatrix;
 
-        if (x != 0)
-        {
+        if (x != 0) {
             sin = sinf(x);
             cos = cosf(x);
-        }
-        else
-        {
+        } else {
             sin = 0.0f;
             cos = 1.0f;
         }
@@ -182,18 +167,15 @@ void Matrix_RotateX(f32 x, u8 mode)
     }
 }
 
-void Matrix_RotateY(f32 y, u8 mode)
-{
+void Matrix_RotateY(f32 y, u8 mode) {
     MtxF* cmf;
     f32 sin;
     f32 cos;
     f32 temp1;
     f32 temp2;
 
-    if (mode == MTXMODE_APPLY)
-    {
-        if (y != 0)
-        {
+    if (mode == MTXMODE_APPLY) {
+        if (y != 0) {
             cmf = sCurrentMatrix;
 
             sin = sinf(y);
@@ -219,18 +201,13 @@ void Matrix_RotateY(f32 y, u8 mode)
             cmf->xw = temp1 * cos - temp2 * sin;
             cmf->zw = temp1 * sin + temp2 * cos;
         }
-    }
-    else
-    {
+    } else {
         cmf = sCurrentMatrix;
 
-        if (y != 0)
-        {
+        if (y != 0) {
             sin = sinf(y);
             cos = cosf(y);
-        }
-        else
-        {
+        } else {
             sin = 0.0f;
             cos = 1.0f;
         }
@@ -254,18 +231,15 @@ void Matrix_RotateY(f32 y, u8 mode)
     }
 }
 
-void Matrix_RotateZ(f32 z, u8 mode)
-{
+void Matrix_RotateZ(f32 z, u8 mode) {
     MtxF* cmf;
     f32 sin;
     f32 cos;
     f32 temp1;
     f32 temp2;
 
-    if (mode == MTXMODE_APPLY)
-    {
-        if (z != 0)
-        {
+    if (mode == MTXMODE_APPLY) {
+        if (z != 0) {
             cmf = sCurrentMatrix;
 
             sin = sinf(z);
@@ -291,18 +265,13 @@ void Matrix_RotateZ(f32 z, u8 mode)
             cmf->xw = temp1 * cos + temp2 * sin;
             cmf->yw = temp2 * cos - temp1 * sin;
         }
-    }
-    else
-    {
+    } else {
         cmf = sCurrentMatrix;
 
-        if (z != 0)
-        {
+        if (z != 0) {
             sin = sinf(z);
             cos = cosf(z);
-        }
-        else
-        {
+        } else {
             sin = 0.0f;
             cos = 1.0f;
         }
@@ -326,16 +295,20 @@ void Matrix_RotateZ(f32 z, u8 mode)
     }
 }
 
-void Matrix_RotateXYZ(s16 x, s16 y, s16 z, u8 mode)
-{
+/*
+ * Rotates the top of the matrix stack by `z` degrees, then
+ * rotates that matrix by `y` degrees, then rotates that matrix
+ * by `x` degrees. (roll-pitch-yaw)
+ * Original Name: Matrix_RotateXYZ, changed to reflect rotation order.
+ */
+void Matrix_RotateZYX(s16 x, s16 y, s16 z, u8 mode) {
     MtxF* cmf = sCurrentMatrix;
     f32 temp1;
     f32 temp2;
     f32 sin;
     f32 cos;
 
-    if (mode == MTXMODE_APPLY)
-    {
+    if (mode == MTXMODE_APPLY) {
         sin = Math_Sins(z);
         cos = Math_Coss(z);
 
@@ -359,8 +332,7 @@ void Matrix_RotateXYZ(s16 x, s16 y, s16 z, u8 mode)
         cmf->xw = temp1 * cos + temp2 * sin;
         cmf->yw = temp2 * cos - temp1 * sin;
 
-        if (y != 0)
-        {
+        if (y != 0) {
             sin = Math_Sins(y);
             cos = Math_Coss(y);
 
@@ -385,8 +357,7 @@ void Matrix_RotateXYZ(s16 x, s16 y, s16 z, u8 mode)
             cmf->zw = temp1 * sin + temp2 * cos;
         }
 
-        if (x != 0)
-        {
+        if (x != 0) {
             sin = Math_Sins(x);
             cos = Math_Coss(x);
 
@@ -410,52 +381,52 @@ void Matrix_RotateXYZ(s16 x, s16 y, s16 z, u8 mode)
             cmf->yw = temp1 * cos + temp2 * sin;
             cmf->zw = temp2 * cos - temp1 * sin;
         }
-    }
-    else
-    {
+    } else {
         func_800A7704(cmf, x, y, z);
     }
 }
 
-void func_800D1340(Vec3f* arg0, Vec3s* arg1)
-{
+/*
+ * Translates the top of the matrix stack by `translation` units,
+ * then rotates that matrix by `rotation` in Z-Y-X order (roll-pitch-yaw)
+ */
+void Matrix_TranslateThenRotateZYX(Vec3f* translation, Vec3s* rotation) {
     MtxF* cmf = sCurrentMatrix;
     f32 sin;
     f32 cos;
     f32 temp1;
     f32 temp2;
 
-    sin = Math_Sins(arg1->z);
-    cos = Math_Coss(arg1->z);
+    sin = Math_Sins(rotation->z);
+    cos = Math_Coss(rotation->z);
 
     temp1 = cmf->xx;
     temp2 = cmf->yx;
-    cmf->wx += temp1 * arg0->x + temp2 * arg0->y + cmf->zx * arg0->z;
+    cmf->wx += temp1 * translation->x + temp2 * translation->y + cmf->zx * translation->z;
     cmf->xx = temp1 * cos + temp2 * sin;
     cmf->yx = temp2 * cos - temp1 * sin;
 
     temp1 = cmf->xy;
     temp2 = cmf->yy;
-    cmf->wy += temp1 * arg0->x + temp2 * arg0->y + cmf->zy * arg0->z;
+    cmf->wy += temp1 * translation->x + temp2 * translation->y + cmf->zy * translation->z;
     cmf->xy = temp1 * cos + temp2 * sin;
     cmf->yy = temp2 * cos - temp1 * sin;
 
     temp1 = cmf->xz;
     temp2 = cmf->yz;
-    cmf->wz += temp1 * arg0->x + temp2 * arg0->y + cmf->zz * arg0->z;
+    cmf->wz += temp1 * translation->x + temp2 * translation->y + cmf->zz * translation->z;
     cmf->xz = temp1 * cos + temp2 * sin;
     cmf->yz = temp2 * cos - temp1 * sin;
 
     temp1 = cmf->xw;
     temp2 = cmf->yw;
-    cmf->ww += temp1 * arg0->x + temp2 * arg0->y + cmf->zw * arg0->z;
+    cmf->ww += temp1 * translation->x + temp2 * translation->y + cmf->zw * translation->z;
     cmf->xw = temp1 * cos + temp2 * sin;
     cmf->yw = temp2 * cos - temp1 * sin;
 
-    if (arg1->y != 0)
-    {
-        sin = Math_Sins(arg1->y);
-        cos = Math_Coss(arg1->y);
+    if (rotation->y != 0) {
+        sin = Math_Sins(rotation->y);
+        cos = Math_Coss(rotation->y);
 
         temp1 = cmf->xx;
         temp2 = cmf->zx;
@@ -478,10 +449,9 @@ void func_800D1340(Vec3f* arg0, Vec3s* arg1)
         cmf->zw = temp1 * sin + temp2 * cos;
     }
 
-    if (arg1->x != 0)
-    {
-        sin = Math_Sins(arg1->x);
-        cos = Math_Coss(arg1->x);
+    if (rotation->x != 0) {
+        sin = Math_Sins(rotation->x);
+        cos = Math_Coss(rotation->x);
 
         temp1 = cmf->yx;
         temp2 = cmf->zx;
@@ -507,8 +477,7 @@ void func_800D1340(Vec3f* arg0, Vec3s* arg1)
 
 #ifdef NON_MATCHING
 // regalloc differences
-void func_800D1694(f32 x, f32 y, f32 z, Vec3s* vec)
-{
+void func_800D1694(f32 x, f32 y, f32 z, Vec3s* vec) {
     MtxF* cmf = sCurrentMatrix;
     f32 sp30;
     f32 sp2C;
@@ -528,8 +497,7 @@ void func_800D1694(f32 x, f32 y, f32 z, Vec3s* vec)
     cmf->zw = 0.0f;
     cmf->ww = 1.0f;
 
-    if (vec->x != 0)
-    {
+    if (vec->x != 0) {
         sp24 = Math_Sins(vec->x);
         sp28 = Math_Coss(vec->x);
 
@@ -539,9 +507,7 @@ void func_800D1694(f32 x, f32 y, f32 z, Vec3s* vec)
         cmf->yz = sp2C * sp24;
         cmf->zx = sp30 * sp28;
         cmf->yx = sp30 * sp24;
-    }
-    else
-    {
+    } else {
         cmf->zz = sp2C;
         cmf->zx = sp30;
         cmf->zy = 0.0f;
@@ -550,8 +516,7 @@ void func_800D1694(f32 x, f32 y, f32 z, Vec3s* vec)
         cmf->yy = 1.0f;
     }
 
-    if (vec->z != 0)
-    {
+    if (vec->z != 0) {
         sp24 = Math_Sins(vec->z);
         sp28 = Math_Coss(vec->z);
 
@@ -568,9 +533,7 @@ void func_800D1694(f32 x, f32 y, f32 z, Vec3s* vec)
         sp2C = cmf->yy;
         cmf->xy = sp2C * sp24;
         cmf->yy = sp2C * sp28;
-    }
-    else
-    {
+    } else {
         cmf->xy = 0.0f;
     }
 }
@@ -580,74 +543,73 @@ void func_800D1694(f32 x, f32 y, f32 z, Vec3s* vec)
 
 #ifdef NON_MATCHING
 // mostly regalloc differences
-Mtx* Matrix_MtxFToMtx(MtxF* src, Mtx* dest)
-{
+Mtx* Matrix_MtxFToMtx(MtxF* src, Mtx* dest) {
     u16* m1 = (u16*)&dest->m[0][0];
     u16* m2 = (u16*)&dest->m[2][0];
     s32 temp;
 
     temp = src->xx * 65536.0f;
-    m1[0] = (temp >> 0x10) & 0xFFFF;;
+    m1[0] = (temp >> 0x10) & 0xFFFF;
     m2[0] = temp & 0xFFFF;
 
     temp = src->xy * 65536.0f;
-    m1[1] = (temp >> 0x10) & 0xFFFF;;
+    m1[1] = (temp >> 0x10) & 0xFFFF;
     m2[1] = temp & 0xFFFF;
 
     temp = src->xz * 65536.0f;
-    m1[2] = (temp >> 0x10) & 0xFFFF;;
+    m1[2] = (temp >> 0x10) & 0xFFFF;
     m2[2] = temp & 0xFFFF;
 
     temp = src->xw * 65536.0f;
-    m1[3] = (temp >> 0x10) & 0xFFFF;;
+    m1[3] = (temp >> 0x10) & 0xFFFF;
     m2[3] = temp & 0xFFFF;
 
     temp = src->yx * 65536.0f;
-    m1[4] = (temp >> 0x10) & 0xFFFF;;
+    m1[4] = (temp >> 0x10) & 0xFFFF;
     m2[4] = temp & 0xFFFF;
 
     temp = src->yy * 65536.0f;
-    m1[5] = (temp >> 0x10) & 0xFFFF;;
+    m1[5] = (temp >> 0x10) & 0xFFFF;
     m2[5] = temp & 0xFFFF;
 
     temp = src->yz * 65536.0f;
-    m1[6] = (temp >> 0x10) & 0xFFFF;;
+    m1[6] = (temp >> 0x10) & 0xFFFF;
     m2[6] = temp & 0xFFFF;
 
     temp = src->yw * 65536.0f;
-    m1[7] = (temp >> 0x10) & 0xFFFF;;
+    m1[7] = (temp >> 0x10) & 0xFFFF;
     m2[7] = temp & 0xFFFF;
 
     temp = src->zx * 65536.0f;
-    m1[8] = (temp >> 0x10) & 0xFFFF;;
+    m1[8] = (temp >> 0x10) & 0xFFFF;
     m2[8] = temp & 0xFFFF;
 
     temp = src->zy * 65536.0f;
-    m1[9] = (temp >> 0x10) & 0xFFFF;;
+    m1[9] = (temp >> 0x10) & 0xFFFF;
     m2[9] = temp & 0xFFFF;
 
     temp = src->zz * 65536.0f;
-    m1[10] = (temp >> 0x10) & 0xFFFF;;
+    m1[10] = (temp >> 0x10) & 0xFFFF;
     m2[10] = temp & 0xFFFF;
 
     temp = src->zw * 65536.0f;
-    m1[11] = (temp >> 0x10) & 0xFFFF;;
+    m1[11] = (temp >> 0x10) & 0xFFFF;
     m2[11] = temp & 0xFFFF;
 
     temp = src->wx * 65536.0f;
-    m1[12] = (temp >> 0x10) & 0xFFFF;;
+    m1[12] = (temp >> 0x10) & 0xFFFF;
     m2[12] = temp & 0xFFFF;
 
     temp = src->wy * 65536.0f;
-    m1[13] = (temp >> 0x10) & 0xFFFF;;
+    m1[13] = (temp >> 0x10) & 0xFFFF;
     m2[13] = temp & 0xFFFF;
 
     temp = src->wz * 65536.0f;
-    m1[14] = (temp >> 0x10) & 0xFFFF;;
+    m1[14] = (temp >> 0x10) & 0xFFFF;
     m2[14] = temp & 0xFFFF;
 
     temp = src->ww * 65536.0f;
-    m1[15] = (temp >> 0x10) & 0xFFFF;;
+    m1[15] = (temp >> 0x10) & 0xFFFF;
     m2[15] = temp & 0xFFFF;
 
     return dest;
@@ -656,23 +618,19 @@ Mtx* Matrix_MtxFToMtx(MtxF* src, Mtx* dest)
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_MtxFToMtx.s")
 #endif
 
-Mtx* Matrix_ToMtx(Mtx* dest, char* file, s32 line)
-{
+Mtx* Matrix_ToMtx(Mtx* dest, char* file, s32 line) {
     return Matrix_MtxFToMtx(Matrix_CheckFloats(sCurrentMatrix, file, line), dest);
 }
 
-Mtx* Matrix_NewMtx(GraphicsContext* gfxCtx, char* file, s32 line)
-{
+Mtx* Matrix_NewMtx(GraphicsContext* gfxCtx, char* file, s32 line) {
     return Matrix_ToMtx(Graph_Alloc(gfxCtx, sizeof(Mtx)), file, line);
 }
 
-Mtx* Matrix_MtxFToNewMtx(MtxF* src, GraphicsContext* gfxCtx)
-{
+Mtx* Matrix_MtxFToNewMtx(MtxF* src, GraphicsContext* gfxCtx) {
     return Matrix_MtxFToMtx(src, Graph_Alloc(gfxCtx, sizeof(Mtx)));
 }
 
-void Matrix_MultVec3f(Vec3f* src, Vec3f* dest)
-{
+void Matrix_MultVec3f(Vec3f* src, Vec3f* dest) {
     MtxF* cmf = sCurrentMatrix;
 
     dest->x = cmf->wx + (cmf->xx * src->x + cmf->yx * src->y + cmf->zx * src->z);
@@ -680,8 +638,7 @@ void Matrix_MultVec3f(Vec3f* src, Vec3f* dest)
     dest->z = cmf->wz + (cmf->xz * src->x + cmf->yz * src->y + cmf->zz * src->z);
 }
 
-void Matrix_MtxFCopy(MtxF* dest, MtxF* src)
-{
+void Matrix_MtxFCopy(MtxF* dest, MtxF* src) {
     dest->xx = src->xx;
     dest->xy = src->xy;
     dest->xz = src->xz;
@@ -716,8 +673,7 @@ void Matrix_MtxFCopy(MtxF* dest, MtxF* src)
     dest->ww = src->ww;
 }
 
-void Matrix_MtxToMtxF(Mtx* src, MtxF* dest)
-{
+void Matrix_MtxToMtxF(Mtx* src, MtxF* dest) {
     u16* m1 = (u16*)&src->m[0][0];
     u16* m2 = (u16*)&src->m[2][0];
 
@@ -739,15 +695,13 @@ void Matrix_MtxToMtxF(Mtx* src, MtxF* dest)
     dest->ww = ((m1[15] << 0x10) | m2[15]) * (1 / 65536.0f);
 }
 
-void Matrix_MultVec3fExt(Vec3f* src, Vec3f* dest, MtxF* mf)
-{
+void Matrix_MultVec3fExt(Vec3f* src, Vec3f* dest, MtxF* mf) {
     dest->x = mf->wx + (mf->xx * src->x + mf->yx * src->y + mf->zx * src->z);
     dest->y = mf->wy + (mf->xy * src->x + mf->yy * src->y + mf->zy * src->z);
     dest->z = mf->wz + (mf->xz * src->x + mf->yz * src->y + mf->zz * src->z);
 }
 
-void Matrix_Reverse(MtxF* mf)
-{
+void Matrix_Reverse(MtxF* mf) {
     f32 temp;
 
     temp = mf->xy;
@@ -764,8 +718,7 @@ void Matrix_Reverse(MtxF* mf)
 }
 
 #ifdef NON_MATCHING
-void func_800D1FD4(MtxF* mf)
-{
+void func_800D1FD4(MtxF* mf) {
     MtxF* cmf = sCurrentMatrix;
     f32 temp;
 
@@ -790,24 +743,24 @@ void func_800D1FD4(MtxF* mf)
 
 #ifdef NON_MATCHING
 // same differences as func_800D2264
-void func_800D20CC(MtxF* mf, Vec3s* vec, s32 flag)
-{
-    vec->x = func_800FD250(-mf->zy, sqrtf(SQ(mf->zx) + SQ(mf->zz))) * (32768 / M_PI);
+void func_800D20CC(MtxF* mf, Vec3s* vec, s32 flag) {
+    vec->x = Math_atan2f(-mf->zy, sqrtf(SQ(mf->zx) + SQ(mf->zz))) * (32768 / M_PI);
 
-    if ((vec->x == 0x4000) || (vec->x == -0x4000))
-    {
+    if ((vec->x == 0x4000) || (vec->x == -0x4000)) {
         vec->z = 0;
-        vec->y = func_800FD250(-mf->xz, mf->xx) * (32768 / M_PI);
+        vec->y = Math_atan2f(-mf->xz, mf->xx) * (32768 / M_PI);
         return;
     }
 
-    vec->y = func_800FD250(mf->zx, mf->zz) * (32768 / M_PI);
+    vec->y = Math_atan2f(mf->zx, mf->zz) * (32768 / M_PI);
 
-    if (!flag)
-        vec->z = func_800FD250(mf->xy, mf->yy) * (32768 / M_PI);
-    else
-        vec->z = func_800FD250(mf->xy / sqrtf(SQ(mf->xx) + SQ(mf->xz) + SQ(mf->xy)), 
-                               mf->yy / sqrtf(SQ(mf->yx) + SQ(mf->yz) + SQ(mf->yy))) * (32768 / M_PI);
+    if (!flag) {
+        vec->z = Math_atan2f(mf->xy, mf->yy) * (32768 / M_PI);
+    } else {
+        vec->z = Math_atan2f(mf->xy / sqrtf(SQ(mf->xx) + SQ(mf->xz) + SQ(mf->xy)),
+                             mf->yy / sqrtf(SQ(mf->yx) + SQ(mf->yz) + SQ(mf->yy))) *
+                 (32768 / M_PI);
+    }
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/func_800D20CC.s")
@@ -815,24 +768,24 @@ void func_800D20CC(MtxF* mf, Vec3s* vec, s32 flag)
 
 #ifdef NON_MATCHING
 // same differences as func_800D20CC
-void func_800D2264(MtxF* mf, Vec3s* vec, s32 flag)
-{
-    vec->y = func_800FD250(-mf->xz, sqrtf(SQ(mf->xx) + SQ(mf->xy))) * (32768 / M_PI);
+void func_800D2264(MtxF* mf, Vec3s* vec, s32 flag) {
+    vec->y = Math_atan2f(-mf->xz, sqrtf(SQ(mf->xx) + SQ(mf->xy))) * (32768 / M_PI);
 
-    if ((vec->y == 0x4000) || (vec->y == -0x4000))
-    {
+    if ((vec->y == 0x4000) || (vec->y == -0x4000)) {
         vec->x = 0;
-        vec->z = func_800FD250(-mf->yx, mf->yy) * (32768 / M_PI);
+        vec->z = Math_atan2f(-mf->yx, mf->yy) * (32768 / M_PI);
         return;
     }
 
-    vec->z = func_800FD250(mf->xy, mf->xx) * (32768 / M_PI);
+    vec->z = Math_atan2f(mf->xy, mf->xx) * (32768 / M_PI);
 
-    if (!flag)
-        vec->x = func_800FD250(mf->yz, mf->zz) * (32768 / M_PI);
-    else
-        vec->x = func_800FD250(mf->yz / sqrtf(SQ(mf->yx) + SQ(mf->yy) + SQ(mf->yz)), 
-                               mf->zz / sqrtf(SQ(mf->zx) + SQ(mf->zy) + SQ(mf->zz))) * (32768 / M_PI);
+    if (!flag) {
+        vec->x = Math_atan2f(mf->yz, mf->zz) * (32768 / M_PI);
+    } else {
+        vec->x = Math_atan2f(mf->yz / sqrtf(SQ(mf->yx) + SQ(mf->yy) + SQ(mf->yz)),
+                             mf->zz / sqrtf(SQ(mf->zx) + SQ(mf->zy) + SQ(mf->zz))) *
+                 (32768 / M_PI);
+    }
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/func_800D2264.s")
@@ -840,8 +793,7 @@ void func_800D2264(MtxF* mf, Vec3s* vec, s32 flag)
 
 #ifdef NON_MATCHING
 // regalloc differences
-void func_800D23FC(f32 f, Vec3f* vec, u8 mode)
-{
+void func_800D23FC(f32 f, Vec3f* vec, u8 mode) {
     MtxF* cmf;
     f32 sin;
     f32 cos;
@@ -851,10 +803,8 @@ void func_800D23FC(f32 f, Vec3f* vec, u8 mode)
     f32 temp3;
     f32 temp4;
 
-    if (mode == MTXMODE_APPLY)
-    {
-        if (f != 0)
-        {
+    if (mode == MTXMODE_APPLY) {
+        if (f != 0) {
             cmf = sCurrentMatrix;
 
             sin = sinf(f);
@@ -884,13 +834,10 @@ void func_800D23FC(f32 f, Vec3f* vec, u8 mode)
             cmf->yz = temp2 * cos + vec->y * temp4 + sin * (temp3 * vec->x - temp1 * vec->z);
             cmf->zz = temp3 * cos + vec->z * temp4 + sin * (temp1 * vec->y - temp2 * vec->x);
         }
-    }
-    else
-    {
+    } else {
         cmf = sCurrentMatrix;
 
-        if (f != 0)
-        {
+        if (f != 0) {
             sin = sinf(f);
             cos = cosf(f);
             rCos = 1.0f - cos;
@@ -921,9 +868,7 @@ void func_800D23FC(f32 f, Vec3f* vec, u8 mode)
             cmf->wy = 0.0f;
             cmf->wz = 0.0f;
             cmf->ww = 1.0f;
-        }
-        else
-        {
+        } else {
             cmf->xy = 0.0f;
             cmf->xz = 0.0f;
             cmf->xw = 0.0f;
@@ -947,17 +892,16 @@ void func_800D23FC(f32 f, Vec3f* vec, u8 mode)
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/func_800D23FC.s")
 #endif
 
-MtxF* Matrix_CheckFloats(MtxF* mf, char* file, s32 line)
-{
+MtxF* Matrix_CheckFloats(MtxF* mf, char* file, s32 line) {
     s32 i, j;
 
-    for (i = 0; i < 4; i++)
-    {
-        for (j = 0; j < 4; j++)
-        {
-            if (!(-32768.0f <= mf->mf[i][j]) || !(mf->mf[i][j] < 32768.0f))
-            {
-                osSyncPrintf("%s %d: [%s] =\n/ %12.6f %12.6f %12.6f %12.6f \\\n| %12.6f %12.6f %12.6f %12.6f |\n| %12.6f %12.6f %12.6f %12.6f |\n\\ %12.6f %12.6f %12.6f %12.6f /\n", file, line, "mf", mf->xx, mf->yx, mf->zx, mf->wx, mf->xy, mf->yy, mf->zy, mf->wy, mf->xz, mf->yz, mf->zz, mf->wz, mf->xw, mf->yw, mf->zw, mf->ww);
+    for (i = 0; i < 4; i++) {
+        for (j = 0; j < 4; j++) {
+            if (!(-32768.0f <= mf->mf[i][j]) || !(mf->mf[i][j] < 32768.0f)) {
+                osSyncPrintf("%s %d: [%s] =\n/ %12.6f %12.6f %12.6f %12.6f \\\n| %12.6f %12.6f %12.6f %12.6f |\n| "
+                             "%12.6f %12.6f %12.6f %12.6f |\n\\ %12.6f %12.6f %12.6f %12.6f /\n",
+                             file, line, "mf", mf->xx, mf->yx, mf->zx, mf->wx, mf->xy, mf->yy, mf->zy, mf->wy, mf->xz,
+                             mf->yz, mf->zz, mf->wz, mf->xw, mf->yw, mf->zw, mf->ww);
                 Fault_AddHungupAndCrash(file, line);
             }
         }
@@ -966,8 +910,7 @@ MtxF* Matrix_CheckFloats(MtxF* mf, char* file, s32 line)
     return mf;
 }
 
-void func_800D2A34(MtxF* mf, f32 arg1, f32 arg2, f32 arg3, f32 arg4)
-{
+void func_800D2A34(MtxF* mf, f32 arg1, f32 arg2, f32 arg3, f32 arg4) {
     mf->xy = 0.0f;
     mf->xz = 0.0f;
     mf->xw = 0.0f;
@@ -986,16 +929,14 @@ void func_800D2A34(MtxF* mf, f32 arg1, f32 arg2, f32 arg3, f32 arg4)
     mf->ww = 1.0f;
 }
 
-void func_800D2A98(Mtx* mtx, f32 arg1, f32 arg2, f32 arg3, f32 arg4)
-{
+void func_800D2A98(Mtx* mtx, f32 arg1, f32 arg2, f32 arg3, f32 arg4) {
     MtxF mf;
 
     func_800D2A34(&mf, arg1, arg2, arg3, arg4);
     func_801064E0(&mf, mtx);
 }
 
-void func_800D2AE4(Mtx* mtx, f32 arg1, f32 arg2, f32 arg3, f32 arg4)
-{
+void func_800D2AE4(Mtx* mtx, f32 arg1, f32 arg2, f32 arg3, f32 arg4) {
     u16* m1 = (u16*)&mtx->m[0][0];
     u16* m2 = (u16*)&mtx->m[2][0];
     u32 temp;
@@ -1047,8 +988,7 @@ void func_800D2AE4(Mtx* mtx, f32 arg1, f32 arg2, f32 arg3, f32 arg4)
     m2[15] = 0;
 }
 
-void func_800D2BD0(Mtx* mtx, f32 arg1, f32 arg2, f32 arg3, f32 arg4, f32 arg5, f32 arg6)
-{
+void func_800D2BD0(Mtx* mtx, f32 arg1, f32 arg2, f32 arg3, f32 arg4, f32 arg5, f32 arg6) {
     u16* m1 = (u16*)&mtx->m[0][0];
     u16* m2 = (u16*)&mtx->m[2][0];
     u32 temp;
@@ -1102,8 +1042,7 @@ void func_800D2BD0(Mtx* mtx, f32 arg1, f32 arg2, f32 arg3, f32 arg4, f32 arg5, f
 
 #ifdef NON_MATCHING
 // minor ordering and regalloc differences
-void func_800D2CEC(Mtx* mtx, f32 arg1, f32 arg2, f32 arg3, f32 arg4, f32 arg5, f32 arg6)
-{
+void func_800D2CEC(Mtx* mtx, f32 arg1, f32 arg2, f32 arg3, f32 arg4, f32 arg5, f32 arg6) {
     u16* m1 = (u16*)&mtx->m[0][0];
     u16* m2 = (u16*)&mtx->m[2][0];
     u32 temp;
diff --git a/src/code/sys_ucode.c b/src/code/sys_ucode.c
index f92a0d61e..f23c7239a 100644
--- a/src/code/sys_ucode.c
+++ b/src/code/sys_ucode.c
@@ -1,21 +1,17 @@
 #include <global.h>
 
-u32 func_800D2DF0()
-{
+u32 SysUcode_GetUCodeBoot() {
     return &D_80009320;
 }
 
-u32 func_800D2DFC()
-{
+u32 SysUcode_GetUcodeBootSize() {
     return (u32)&D_800093F0 - (u32)&D_80009320;
 }
 
-u32 func_800D2E14()
-{
+u32 SysUcode_GetUcode() {
     return D_8012DBA0;
 }
 
-u32 func_800D2E20()
-{
+u32 SysUcode_GetUcodeData() {
     return D_8012DBA4;
 }
diff --git a/src/code/system_malloc.c b/src/code/system_malloc.c
index d7c91bbf3..3c75b6065 100644
--- a/src/code/system_malloc.c
+++ b/src/code/system_malloc.c
@@ -1,131 +1,112 @@
 #include <global.h>
 
-#define LOG_SEVERITY_NOLOG          0
-#define LOG_SEVERITY_ERROR          2
-#define LOG_SEVERITY_VERBOSE        3
+#define LOG_SEVERITY_NOLOG 0
+#define LOG_SEVERITY_ERROR 2
+#define LOG_SEVERITY_VERBOSE 3
 
 s32 gSystemArenaLogSeverity = LOG_SEVERITY_NOLOG;
 Arena gSystemArena;
 
-void SystemArena_CheckPointer(void* ptr, u32 size, const char* name, const char* action)
-{
-    if (!ptr)
-    {
-        if (gSystemArenaLogSeverity >= LOG_SEVERITY_ERROR)
-        {
+void SystemArena_CheckPointer(void* ptr, u32 size, const char* name, const char* action) {
+    if (!ptr) {
+        if (gSystemArenaLogSeverity >= LOG_SEVERITY_ERROR) {
             //"%s: %u bytes %s failed\n"
             osSyncPrintf("%s: %u バイトの%sに失敗しました\n", name, size, action);
             __osDisplayArena(&gSystemArena);
             return;
         }
-    }
-    else if (gSystemArenaLogSeverity >= LOG_SEVERITY_VERBOSE)
-    {
+    } else if (gSystemArenaLogSeverity >= LOG_SEVERITY_VERBOSE) {
         //"%s: %u bytes %s succeeded\n"
         osSyncPrintf("%s: %u バイトの%sに成功しました\n", name, size, action);
     }
 }
 
-void* SystemArena_Malloc(u32 size)
-{
+void* SystemArena_Malloc(u32 size) {
     void* ptr;
     ptr = __osMalloc(&gSystemArena, size);
-    SystemArena_CheckPointer(ptr, size, "malloc", "確保"); //Secure
+    SystemArena_CheckPointer(ptr, size, "malloc", "確保"); // Secure
     return ptr;
 }
 
-void* SystemArena_MallocDebug(u32 size, const char* file, s32 line)
-{
+void* SystemArena_MallocDebug(u32 size, const char* file, s32 line) {
     void* ptr;
     ptr = __osMallocDebug(&gSystemArena, size, file, line);
-    SystemArena_CheckPointer(ptr, size, "malloc_DEBUG", "確保"); //Secure
+    SystemArena_CheckPointer(ptr, size, "malloc_DEBUG", "確保"); // Secure
     return ptr;
 }
 
-void* SystemArena_MallocR(u32 size)
-{
+void* SystemArena_MallocR(u32 size) {
     void* ptr;
     ptr = __osMallocR(&gSystemArena, size);
-    SystemArena_CheckPointer(ptr, size, "malloc_r", "確保"); //Secure
+    SystemArena_CheckPointer(ptr, size, "malloc_r", "確保"); // Secure
     return ptr;
 }
 
-void* SystemArena_MallocRDebug(u32 size, const char* file, s32 line)
-{
+void* SystemArena_MallocRDebug(u32 size, const char* file, s32 line) {
     void* ptr;
     ptr = __osMallocRDebug(&gSystemArena, size, file, line);
-    SystemArena_CheckPointer(ptr, size, "malloc_r_DEBUG", "確保"); //Secure
+    SystemArena_CheckPointer(ptr, size, "malloc_r_DEBUG", "確保"); // Secure
     return ptr;
 }
 
-void* SystemArena_Realloc(void* ptr, u32 newSize)
-{
+void* SystemArena_Realloc(void* ptr, u32 newSize) {
     ptr = __osRealloc(&gSystemArena, ptr, newSize);
     SystemArena_CheckPointer(ptr, newSize, "realloc", "再確保"); // Re-securing
     return ptr;
 }
 
-void* SystemArena_ReallocDebug(void* ptr, u32 newSize, const char* file, s32 line)
-{
+void* SystemArena_ReallocDebug(void* ptr, u32 newSize, const char* file, s32 line) {
     ptr = __osReallocDebug(&gSystemArena, ptr, newSize, file, line);
     SystemArena_CheckPointer(ptr, newSize, "realloc_DEBUG", "再確保"); // Re-securing
     return ptr;
 }
 
-void SystemArena_Free(void* ptr)
-{
+void SystemArena_Free(void* ptr) {
     __osFree(&gSystemArena, ptr);
 }
 
-void SystemArena_FreeDebug(void* ptr, const char* file, s32 line)
-{
+void SystemArena_FreeDebug(void* ptr, const char* file, s32 line) {
     __osFreeDebug(&gSystemArena, ptr, file, line);
 }
 
-void* SystemArena_Calloc(u32 num, u32 size)
-{
+void* SystemArena_Calloc(u32 num, u32 size) {
     void* ret;
     u32 n;
 
-    n = num*size;
+    n = num * size;
     ret = __osMalloc(&gSystemArena, n);
-    if (ret)
+    if (ret) {
         bzero(ret, n);
+    }
 
     SystemArena_CheckPointer(ret, n, "calloc", "確保");
     return ret;
 }
 
-void SystemArena_Display()
-{
-    //System heap display
+void SystemArena_Display() {
+    // System heap display
     osSyncPrintf("システムヒープ表示\n");
     __osDisplayArena(&gSystemArena);
 }
 
-void SystemArena_GetSizes(u32* outMaxFree, u32* outFree, u32* outAlloc)
-{
+void SystemArena_GetSizes(u32* outMaxFree, u32* outFree, u32* outAlloc) {
     ArenaImpl_GetSizes(&gSystemArena, outMaxFree, outFree, outAlloc);
 }
 
-void SystemArena_Check()
-{
+void SystemArena_Check() {
     __osCheckArena(&gSystemArena);
 }
 
-void SystemArena_Init(void* start, u32 size)
-{
+void SystemArena_Init(void* start, u32 size) {
     gSystemArenaLogSeverity = LOG_SEVERITY_NOLOG;
     __osMallocInit(&gSystemArena, start, size);
 }
 
-void SystemArena_Cleanup()
-{
+void SystemArena_Cleanup() {
     gSystemArenaLogSeverity = LOG_SEVERITY_NOLOG;
     __osMallocCleanup(&gSystemArena);
 }
 
-u8 SystemArena_IsInitalized()
-{
+u8 SystemArena_IsInitalized() {
     return __osMallocIsInitalized(&gSystemArena);
 }
diff --git a/src/code/title_setup.c b/src/code/title_setup.c
index 22ee8b181..827987d33 100644
--- a/src/code/title_setup.c
+++ b/src/code/title_setup.c
@@ -1,21 +1,17 @@
 #include <global.h>
 
-void TitleSetup_InitImpl(GameState* gameState)
-{
-    //Zelda common data initalization
+void TitleSetup_InitImpl(GameState* gameState) {
+    // Zelda common data initalization
     osSyncPrintf("ゼルダ共通データ初期化\n");
     SaveContext_Init();
     gameState->running = false;
-    gameState->init = func_80800878; gameState->size = sizeof(TitleContext);
+    SET_NEXT_GAMESTATE(gameState, Title_Init, TitleContext);
 }
 
-void TitleSetup_Destroy(GameState* gameState)
-{
-
+void TitleSetup_Destroy(GameState* gameState) {
 }
 
-void TitleSetup_Init(GameState* gameState)
-{
+void TitleSetup_Init(GameState* gameState) {
     gameState->destroy = TitleSetup_Destroy;
     TitleSetup_InitImpl(gameState);
-}
\ No newline at end of file
+}
diff --git a/src/code/z_DLF.c b/src/code/z_DLF.c
index 2117a771a..ab09cbac5 100644
--- a/src/code/z_DLF.c
+++ b/src/code/z_DLF.c
@@ -2,109 +2,110 @@
 #include <global.h>
 #include <vt.h>
 
-void Overlay_LoadGameState(GameStateOverlay* overlayEntry)
-{
-    if (overlayEntry->loadedRamAddr != NULL)
-    {
+void Overlay_LoadGameState(GameStateOverlay* overlayEntry) {
+    if (overlayEntry->loadedRamAddr != NULL) {
         // Translates to: "ALREADY LINKED"
         osSyncPrintf("既にリンクされています\n");
         return;
     }
 
-    if (overlayEntry->vramStart == 0)
+    if (overlayEntry->vramStart == 0) {
         overlayEntry->unk_28 = 0;
-    else
-    {
+    } else {
         overlayEntry->loadedRamAddr = Overlay_AllocateAndLoad(overlayEntry->vromStart, overlayEntry->vromEnd,
                                                               overlayEntry->vramStart, overlayEntry->vramEnd);
 
-        if (overlayEntry->loadedRamAddr == NULL)
-        {
+        if (overlayEntry->loadedRamAddr == NULL) {
             // Translates to: "LOADING FAILED"
             osSyncPrintf("ロードに失敗しました\n");
             return;
         }
 
         osSyncPrintf(VT_FGCOL(GREEN));
-        osSyncPrintf("OVL(d):Seg:%08x-%08x Ram:%08x-%08x Off:%08x %s\n",
-                     overlayEntry->vramStart, overlayEntry->vramEnd,
+        osSyncPrintf("OVL(d):Seg:%08x-%08x Ram:%08x-%08x Off:%08x %s\n", overlayEntry->vramStart, overlayEntry->vramEnd,
                      overlayEntry->loadedRamAddr,
                      (u32)overlayEntry->loadedRamAddr + (u32)overlayEntry->vramEnd - (u32)overlayEntry->vramStart,
-                     (u32)overlayEntry->vramStart - (u32)overlayEntry->loadedRamAddr,
-                      "");
+                     (u32)overlayEntry->vramStart - (u32)overlayEntry->loadedRamAddr, "");
         osSyncPrintf(VT_RST);
 
-        if (overlayEntry->unk_14 != NULL)
+        if (overlayEntry->unk_14 != NULL) {
             overlayEntry->unk_14 = (void*)((u32)overlayEntry->unk_14 -
                                            (s32)((u32)overlayEntry->vramStart - (u32)overlayEntry->loadedRamAddr));
-        else
+        } else {
             overlayEntry->unk_14 = NULL;
+        }
 
-        if (overlayEntry->init != NULL)
+        if (overlayEntry->init != NULL) {
             overlayEntry->init = (void*)((u32)overlayEntry->init -
                                          (s32)((u32)overlayEntry->vramStart - (u32)overlayEntry->loadedRamAddr));
-        else
+        } else {
             overlayEntry->init = NULL;
+        }
 
-        if (overlayEntry->destroy != NULL)
+        if (overlayEntry->destroy != NULL) {
             overlayEntry->destroy = (void*)((u32)overlayEntry->destroy -
                                             (s32)((u32)overlayEntry->vramStart - (u32)overlayEntry->loadedRamAddr));
-        else
+        } else {
             overlayEntry->destroy = NULL;
+        }
 
-        if (overlayEntry->unk_20 != NULL)
+        if (overlayEntry->unk_20 != NULL) {
             overlayEntry->unk_20 = (void*)((u32)overlayEntry->unk_20 -
                                            (s32)((u32)overlayEntry->vramStart - (u32)overlayEntry->loadedRamAddr));
-        else
+        } else {
             overlayEntry->unk_20 = NULL;
+        }
 
-        if (overlayEntry->unk_24 != NULL)
+        if (overlayEntry->unk_24 != NULL) {
             overlayEntry->unk_24 = (void*)((u32)overlayEntry->unk_24 -
                                            (s32)((u32)overlayEntry->vramStart - (u32)overlayEntry->loadedRamAddr));
-        else
+        } else {
             overlayEntry->unk_24 = NULL;
+        }
 
         overlayEntry->unk_28 = 0;
     }
 }
 
-void Overlay_FreeGameState(GameStateOverlay* overlayEntry)
-{
-    if (overlayEntry->loadedRamAddr != NULL)
-    {
+void Overlay_FreeGameState(GameStateOverlay* overlayEntry) {
+    if (overlayEntry->loadedRamAddr != NULL) {
         s32 temp = overlayEntry->unk_28 != 0 ? -1 : 0;
 
-        if (temp == 0)
-        {
-            if (overlayEntry->unk_14 != NULL)
+        if (temp == 0) {
+            if (overlayEntry->unk_14 != NULL) {
                 overlayEntry->unk_14 = (void*)((u32)overlayEntry->unk_14 +
                                                (s32)((u32)overlayEntry->vramStart - (u32)overlayEntry->loadedRamAddr));
-            else
+            } else {
                 overlayEntry->unk_14 = NULL;
+            }
 
-            if (overlayEntry->init != NULL)
+            if (overlayEntry->init != NULL) {
                 overlayEntry->init = (void*)((u32)overlayEntry->init +
                                              (s32)((u32)overlayEntry->vramStart - (u32)overlayEntry->loadedRamAddr));
-            else
+            } else {
                 overlayEntry->init = NULL;
+            }
 
-            if (overlayEntry->destroy != NULL)
+            if (overlayEntry->destroy != NULL) {
                 overlayEntry->destroy = (void*)((u32)overlayEntry->destroy +
                                                 (s32)((u32)overlayEntry->vramStart - (u32)overlayEntry->loadedRamAddr));
-            else
+            } else {
                 overlayEntry->destroy = NULL;
+            }
 
-            if (overlayEntry->unk_20 != NULL)
+            if (overlayEntry->unk_20 != NULL) {
                 overlayEntry->unk_20 = (void*)((u32)overlayEntry->unk_20 +
                                                (s32)((u32)overlayEntry->vramStart - (u32)overlayEntry->loadedRamAddr));
-            else
+            } else {
                 overlayEntry->unk_20 = NULL;
+            }
 
-            if (overlayEntry->unk_24 != NULL)
+            if (overlayEntry->unk_24 != NULL) {
                 overlayEntry->unk_24 = (void*)((u32)overlayEntry->unk_24 +
                                                (s32)((u32)overlayEntry->vramStart - (u32)overlayEntry->loadedRamAddr));
-            else
+            } else {
                 overlayEntry->unk_24 = NULL;
+            }
 
             SystemArena_FreeDebug(overlayEntry->loadedRamAddr, "../z_DLF.c", 149);
             overlayEntry->loadedRamAddr = NULL;
diff --git a/src/code/z_actor.c b/src/code/z_actor.c
index 3b6698c30..c6ca91721 100644
--- a/src/code/z_actor.c
+++ b/src/code/z_actor.c
@@ -2,115 +2,108 @@
 #include <global.h>
 #include <vt.h>
 
-void ActorShape_Init(ActorShape* shape, f32 arg1, void* shadowDrawFunc, f32 arg3)
-{
+void ActorShape_Init(ActorShape* shape, f32 arg1, void* shadowDrawFunc, f32 arg3) {
     shape->unk_08 = arg1;
     shape->shadowDrawFunc = shadowDrawFunc;
     shape->unk_10 = arg3;
     shape->unk_14 = -1;
 }
 
-void func_8002B200(Actor* actor, LightMapper* lightMapper, GlobalContext* globalCtx, u32 dlist, Color_RGBA8* color)
-{
+void func_8002B200(Actor* actor, LightMapper* lightMapper, GlobalContext* globalCtx, Gfx* dlist, Color_RGBA8* color) {
     f32 temp1;
     f32 temp2;
     MtxF sp60;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    if (actor->floorPoly != NULL)
-    {
+    if (actor->floorPoly != NULL) {
         temp1 = actor->posRot.pos.y - actor->unk_80;
 
-        if (temp1 >= -50.0f && temp1 < 500.0f)
-        {
+        if (temp1 >= -50.0f && temp1 < 500.0f) {
             gfxCtx = globalCtx->state.gfxCtx;
-            func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1553);
+            Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 1553);
 
-            gfxCtx->polyOpa.p = func_80093774(gfxCtx->polyOpa.p, 0x2C);
+            gfxCtx->polyOpa.p = Gfx_CallSetupDL(gfxCtx->polyOpa.p, 0x2C);
 
-            gDPSetCombineLERP(gfxCtx->polyOpa.p++,
-                              0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0,
-                              0, 0, 0, COMBINED, 0, 0, 0, COMBINED);
+            gDPSetCombineLERP(gfxCtx->polyOpa.p++, 0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0, 0, 0, 0, COMBINED, 0, 0,
+                              0, COMBINED);
 
             temp1 = (temp1 < 0.0f) ? 0.0f : ((temp1 > 150.0f) ? 150.0f : temp1);
             temp2 = 1.0f - (temp1 * (1.f / 350));
 
-            if (color != NULL)
+            if (color != NULL) {
                 gDPSetPrimColor(gfxCtx->polyOpa.p++, 0, 0, color->r, color->g, color->b,
                                 (u32)(actor->shape.unk_14 * temp2) & 0xFF);
-            else
-                gDPSetPrimColor(gfxCtx->polyOpa.p++, 0, 0, 0, 0, 0,
-                                (u32)(actor->shape.unk_14 * temp2) & 0xFF);
+            } else {
+                gDPSetPrimColor(gfxCtx->polyOpa.p++, 0, 0, 0, 0, 0, (u32)(actor->shape.unk_14 * temp2) & 0xFF);
+            }
 
             func_80038A28(actor->floorPoly, actor->posRot.pos.x, actor->unk_80, actor->posRot.pos.z, &sp60);
             Matrix_Put(&sp60);
 
-            if (dlist != (u32)&D_04049210)
+            if (dlist != D_04049210) {
                 Matrix_RotateY(actor->shape.rot.y * (M_PI / 32768), MTXMODE_APPLY);
+            }
 
             temp2 = (1.0f - (temp1 * (1.f / 350))) * actor->shape.unk_10;
             Matrix_Scale(actor->scale.x * temp2, 1.0f, actor->scale.z * temp2, MTXMODE_APPLY);
 
-            gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_actor.c", 1588), G_MTX_MODELVIEW | G_MTX_LOAD);
+            gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_actor.c", 1588),
+                      G_MTX_MODELVIEW | G_MTX_LOAD);
             gSPDisplayList(gfxCtx->polyOpa.p++, dlist);
 
-            func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1594);
+            Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 1594);
         }
     }
 }
 
-void ActorShadow_DrawFunc_Circle(Actor* actor, LightMapper* lightMapper, GlobalContext* globalCtx)
-{
+void ActorShadow_DrawFunc_Circle(Actor* actor, LightMapper* lightMapper, GlobalContext* globalCtx) {
     func_8002B200(actor, lightMapper, globalCtx, &D_04049210, NULL);
 }
 
 Color_RGBA8 D_80115F80 = { 0xFF, 0xFF, 0xFF, 0xFF };
 
-void ActorShadow_DrawFunc_WhiteCircle(Actor* actor, LightMapper* lightMapper, GlobalContext* globalCtx)
-{
+void ActorShadow_DrawFunc_WhiteCircle(Actor* actor, LightMapper* lightMapper, GlobalContext* globalCtx) {
     func_8002B200(actor, lightMapper, globalCtx, &D_04049210, &D_80115F80);
 }
 
-void ActorShadow_DrawFunc_Squiggly(Actor* actor, LightMapper* lightMapper, GlobalContext* globalCtx)
-{
+void ActorShadow_DrawFunc_Squiggly(Actor* actor, LightMapper* lightMapper, GlobalContext* globalCtx) {
     func_8002B200(actor, lightMapper, globalCtx, &D_04049AD0, NULL);
 }
 
-void func_8002B66C(GlobalContext* globalCtx, Light* light, MtxF* arg2, s32 arg3, f32 arg4, f32 arg5, f32 arg6)
-{
+void func_8002B66C(GlobalContext* globalCtx, Light* light, MtxF* arg2, s32 arg3, f32 arg4, f32 arg5, f32 arg6) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     f32 sp58;
-    Gfx* gfxArr[7];
+    Gfx* dispRefs[7];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1661);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 1661);
 
     gDPSetPrimColor(gfxCtx->polyOpa.p++, 0, 0, 0, 0, 0,
                     (u32)(((arg3 * 0.00005f) > 1.0f ? 1.0f : (arg3 * 0.00005f)) * arg4) & 0xFF);
 
-    sp58 = func_800FD250(light->l.dir[0], light->l.dir[2]);
+    sp58 = Math_atan2f(light->l.dir[0], light->l.dir[2]);
     arg6 *= (4.5f - (light->l.dir[1] * 0.035f));
     arg6 = (arg6 < 1.0f) ? 1.0f : arg6;
     Matrix_Put(arg2);
     Matrix_RotateY(sp58, MTXMODE_APPLY);
     Matrix_Scale(arg5, 1.0f, arg5 * arg6, MTXMODE_APPLY);
 
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_actor.c", 1687), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_actor.c", 1687),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, &D_04048180);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1693);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 1693);
 }
 
 #ifdef NON_MATCHING
-// this function still needs a lot of work
-void ActorShadow_DrawFunc_Teardrop(Actor* actor, LightMapper* lightMapper, GlobalContext* globalCtx)
-{
+// saved register, stack usage and minor ordering differences
+void ActorShadow_DrawFunc_Teardrop(Actor* actor, LightMapper* lightMapper, GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx;
     MtxF spE8;
-    Vec2f spE0;
-    s32 index;
+    f32 spE0[2];
+    s32 i;
     f32* spAC;
-    Gfx* gfxArr[7];
+    Gfx* dispRefs[4];
     f32 temp_10;
     u8 temp_14;
     f32 temp_f0;
@@ -129,32 +122,29 @@ void ActorShadow_DrawFunc_Teardrop(Actor* actor, LightMapper* lightMapper, Globa
 
     temp_f20 = actor->posRot.pos.y - actor->unk_80;
 
-    if (temp_f20 > 20.0f)
-    {
+    if (temp_f20 > 20.0f) {
         temp_10 = actor->shape.unk_10;
-        actor->shape.unk_10 *= 0.3f;
         temp_14 = actor->shape.unk_14;
+        actor->shape.unk_10 *= 0.3f;
         actor->shape.unk_14 *= ((temp_f20 - 20.0f) * 0.02f) > 1.0f ? 1.0f : ((temp_f20 - 20.0f) * 0.02f);
         ActorShadow_DrawFunc_Circle(actor, lightMapper, globalCtx);
         actor->shape.unk_10 = temp_10;
         actor->shape.unk_14 = temp_14;
     }
 
-    if (temp_f20 < 200.0f)
-    {
-        spAC = &spE0.x;
-        gfxCtx = globalCtx->state.gfxCtx;
-        temp_s6 = lightMapper->numLights - 2;
+    if (temp_f20 < 200.0f) {
+        phi_s7 = &actor->unk_CC[0];
+        spAC = &spE0[0];
+        temp_s6 = lightMapper->numLights;
+        temp_s6 -= 2;
 
-        func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1741);
+        gfxCtx = globalCtx->state.gfxCtx;
+        Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 1741);
 
-        gfxCtx->polyOpa.p = func_80093774(gfxCtx->polyOpa.p, 0x2C);
+        gfxCtx->polyOpa.p = Gfx_CallSetupDL(gfxCtx->polyOpa.p, 0x2C);
         actor->shape.unk_15 = 0;
 
-        phi_s7 = &actor->unk_CC;
-
-        for (index = 0; index < 2; index++)
-        {
+        for (i = 0; i < 2; i++) {
             phi_s7->y += 50.0f;
             *spAC = func_800BFCB8(globalCtx, &spE8, phi_s7);
             phi_s7->y -= 50.0f;
@@ -163,33 +153,32 @@ void ActorShadow_DrawFunc_Teardrop(Actor* actor, LightMapper* lightMapper, Globa
 
             phi_f2 = phi_s7->y - *spAC;
 
-            if ((phi_f2 >= -1.0f) && (phi_f2 < 500.0f))
-            {
+            if ((phi_f2 >= -1.0f) && (phi_f2 < 500.0f)) {
                 phi_s0 = lightMapper->lights;
 
-                if (phi_f2 <= 0.0f)
+                if (phi_f2 <= 0.0f) {
                     actor->shape.unk_15++;
+                }
 
-                if (30.0f < phi_f2)
+                if (30.0f < phi_f2) {
                     phi_f2 = 30.0f;
+                }
 
-                temp_f24 = actor->shape.unk_14 * (1.0f - (phi_f2 * (1.f / 30)));
+                temp_f24 = actor->shape.unk_14 * (1.0f - (phi_f2 * (1.0f / 30)));
 
-                if (30.0f < phi_f2)
+                if (30.0f < phi_f2) {
                     phi_f2 = 30.0f;
+                }
 
-                temp_f20_2 = 1.0f - (phi_f2 * (1.f / 70));
+                temp_f20_2 = 1.0f - (phi_f2 * (1.0f / 70));
                 temp_f22_2 = (actor->shape.unk_10 * temp_f20_2) * actor->scale.x;
 
                 phi_s2 = 0;
 
-                for (phi_s1 = 0; phi_s1 < temp_s6; phi_s1++)
-                {
-                    if (phi_s0->l.dir[1] > 0)
-                    {
+                for (phi_s1 = 0; phi_s1 < temp_s6; phi_s1++) {
+                    if (phi_s0->l.dir[1] > 0) {
                         temp_lo = ABS(phi_s0->l.dir[1]) * ((phi_s0->l.col[0] + phi_s0->l.col[1]) + phi_s0->l.col[2]);
-                        if (temp_lo > 0)
-                        {
+                        if (temp_lo > 0) {
                             func_8002B66C(globalCtx, phi_s0, &spE8, temp_lo, temp_f24, temp_f22_2, temp_f20_2);
                             phi_s2 += temp_lo;
                         }
@@ -197,13 +186,13 @@ void ActorShadow_DrawFunc_Teardrop(Actor* actor, LightMapper* lightMapper, Globa
                     phi_s0++;
                 }
 
-                for (phi_s1 = 0; phi_s1 < 2; phi_s1++)
-                {
-                    if (phi_s0->l.dir[1] > 0)
-                    {
-                        temp_a3 = (ABS(phi_s0->l.dir[1]) * ((phi_s0->l.col[0] + phi_s0->l.col[1]) + phi_s0->l.col[2])) - (phi_s2 * 8);
-                        if (temp_a3 > 0)
+                for (phi_s1 = 0; phi_s1 < 2; phi_s1++) {
+                    if (phi_s0->l.dir[1] > 0) {
+                        temp_a3 = (ABS(phi_s0->l.dir[1]) * ((phi_s0->l.col[0] + phi_s0->l.col[1]) + phi_s0->l.col[2])) -
+                                  (phi_s2 * 8);
+                        if (temp_a3 > 0) {
                             func_8002B66C(globalCtx, phi_s0, &spE8, temp_a3, temp_f24, temp_f22_2, temp_f20_2);
+                        }
                     }
                     phi_s0++;
                 }
@@ -213,46 +202,39 @@ void ActorShadow_DrawFunc_Teardrop(Actor* actor, LightMapper* lightMapper, Globa
             phi_s7++;
         }
 
-        if (!(actor->bgCheckFlags & 1))
+        if (!(actor->bgCheckFlags & 1)) {
             actor->shape.unk_15 = 0;
-        else if (actor->shape.unk_15 == 3)
-        {
-            temp_f0 = actor->unk_CC.y - actor->unk_D8.y;
-            if ((spE0.x + temp_f0) < (spE0.y - temp_f0))
-                actor->shape.unk_15 = 2;
-            else
-                actor->shape.unk_15 = 1;
+        } else if (actor->shape.unk_15 == 3) {
+            temp_f0 = actor->unk_CC[0].y - actor->unk_CC[1].y;
+            actor->shape.unk_15 = ((spE0[0] + temp_f0) < (spE0[1] - temp_f0)) ? 2 : 1;
         }
 
-        func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1831);
+        Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 1831);
     }
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_actor/ActorShadow_DrawFunc_Teardrop.s")
 #endif
 
-void func_8002BDB0(Actor* actor, s32 arg1, s32 arg2, UNK_PTR arg3, s32 arg4, UNK_PTR arg5)
-{
-    if (arg1 == arg2)
-        Matrix_MultVec3f(arg3, &actor->unk_CC);
-    else if (arg1 == arg4)
-        Matrix_MultVec3f(arg5, &actor->unk_D8);
+void func_8002BDB0(Actor* actor, s32 arg1, s32 arg2, UNK_PTR arg3, s32 arg4, UNK_PTR arg5) {
+    if (arg1 == arg2) {
+        Matrix_MultVec3f(arg3, &actor->unk_CC[0]);
+    } else if (arg1 == arg4) {
+        Matrix_MultVec3f(arg5, &actor->unk_CC[1]);
+    }
 }
 
-void func_8002BE04(GlobalContext* globalCtx, Vec3f* arg1, Vec3f* arg2, f32* arg3)
-{
+void func_8002BE04(GlobalContext* globalCtx, Vec3f* arg1, Vec3f* arg2, f32* arg3) {
     func_800A6E10(&globalCtx->mf_11D60, arg1, arg2, arg3);
     *arg3 = (*arg3 < 1.0f) ? 1.0f : (1.0f / *arg3);
 }
 
-typedef struct
-{
+typedef struct {
     /* 0x00 */ Color_RGBA8 inner;
     /* 0x04 */ Color_RGBA8 outer;
 } NaviColor; // size = 0x8
 
-NaviColor sNaviColorList[] =
-{
+NaviColor sNaviColorList[] = {
     { { 0x00, 0xFF, 0x00, 0xFF }, { 0x00, 0xFF, 0x00, 0x00 } },
     { { 0x00, 0xFF, 0x00, 0xFF }, { 0x00, 0xFF, 0x00, 0x00 } },
     { { 0xFF, 0xFF, 0xFF, 0xFF }, { 0x00, 0x00, 0xFF, 0x00 } },
@@ -269,21 +251,18 @@ NaviColor sNaviColorList[] =
 };
 
 // unused
-Gfx D_80115FF0[] =
-{
+Gfx D_80115FF0[] = {
     gsSPEndDisplayList(),
 };
 
-void func_8002BE64(TargetContext* targetCtx, s32 index, f32 arg2, f32 arg3, f32 arg4)
-{
+void func_8002BE64(TargetContext* targetCtx, s32 index, f32 arg2, f32 arg3, f32 arg4) {
     targetCtx->arr_50[index].pos.x = arg2;
     targetCtx->arr_50[index].pos.y = arg3;
     targetCtx->arr_50[index].pos.z = arg4;
     targetCtx->arr_50[index].unk_0C = targetCtx->unk_44;
 }
 
-void func_8002BE98(TargetContext* targetCtx, s32 actorType, GlobalContext* globalCtx)
-{
+void func_8002BE98(TargetContext* targetCtx, s32 actorType, GlobalContext* globalCtx) {
     TargetContextEntry* entry;
     NaviColor* naviColor;
     s32 i;
@@ -295,8 +274,7 @@ void func_8002BE98(TargetContext* targetCtx, s32 actorType, GlobalContext* globa
     naviColor = &sNaviColorList[actorType];
 
     entry = &targetCtx->arr_50[0];
-    for (i = 0; i < ARRAY_COUNT(targetCtx->arr_50); i++)
-    {
+    for (i = 0; i < ARRAY_COUNT(targetCtx->arr_50); i++) {
         func_8002BE64(targetCtx, i, 0.0f, 0.0f, 0.0f);
         entry->color.r = naviColor->inner.r;
         entry->color.g = naviColor->inner.g;
@@ -305,8 +283,7 @@ void func_8002BE98(TargetContext* targetCtx, s32 actorType, GlobalContext* globa
     }
 }
 
-void func_8002BF60(TargetContext* targetCtx, Actor* actor, s32 actorType, GlobalContext* globalCtx)
-{
+void func_8002BF60(TargetContext* targetCtx, Actor* actor, s32 actorType, GlobalContext* globalCtx) {
     NaviColor* naviColor = &sNaviColorList[actorType];
     targetCtx->naviRefPos.x = actor->posRot2.pos.x;
     targetCtx->naviRefPos.y = actor->posRot2.pos.y + (actor->unk_4C * actor->scale.y);
@@ -321,8 +298,7 @@ void func_8002BF60(TargetContext* targetCtx, Actor* actor, s32 actorType, Global
     targetCtx->naviOuter.a = naviColor->outer.a;
 }
 
-void func_8002C0C0(TargetContext* targetCtx, Actor* actor, GlobalContext* globalCtx)
-{
+void func_8002C0C0(TargetContext* targetCtx, Actor* actor, GlobalContext* globalCtx) {
     targetCtx->arrowPointedActor = NULL;
     targetCtx->targetedActor = NULL;
     targetCtx->unk_40 = 0.0f;
@@ -335,143 +311,133 @@ void func_8002C0C0(TargetContext* targetCtx, Actor* actor, GlobalContext* global
 }
 
 #ifdef NON_MATCHING
-// this function still needs some work
-void func_8002C124(TargetContext* targetCtx, GlobalContext* globalCtx)
-{
+// regalloc and minor ordering differences
+void func_8002C124(TargetContext* targetCtx, GlobalContext* globalCtx) {
     Actor* actor;
     Player* player;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[4];
+    TargetContextEntry* entry;
     s16 spCE;
+    f32 temp1;
     Vec3f spBC;
     s32 spB8;
     f32 spB4;
     s32 spB0;
     s32 spAC;
-    s32 i;
-    TargetContextEntry* entry;
-    f32 temp1;
     f32 var1;
     f32 var2;
-    Vec3f* vec;
+    s32 i;
 
+    actor = targetCtx->targetedActor;
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr,  globalCtx->state.gfxCtx, "../z_actor.c", 2029);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 2029);
 
-    if (targetCtx->unk_48 != 0)
-    {
+    if (targetCtx->unk_48 != 0) {
         player = PLAYER;
 
         spCE = 0xFF;
         var1 = 1.0f;
 
-        if (targetCtx->unk_4B != 0)
+        if (targetCtx->unk_4B != 0) {
             spB8 = 1;
-        else
+        } else {
             spB8 = 3;
+        }
 
-        if (targetCtx->targetedActor != NULL)
-        {
-            Math_Vec3f_Copy(&targetCtx->targetCenterPos, &targetCtx->targetedActor->posRot2.pos);
+        if (actor != NULL) {
+            Math_Vec3f_Copy(&targetCtx->targetCenterPos, &actor->posRot2.pos);
             var1 = (500.0f - targetCtx->unk_44) / 420.0f;
-        }
-        else
-        {
-            targetCtx->unk_48 -= 0x78;
-            if (targetCtx->unk_48 < 0)
+        } else {
+            targetCtx->unk_48 -= 120;
+            if (targetCtx->unk_48 < 0) {
                 targetCtx->unk_48 = 0;
+            }
             spCE = targetCtx->unk_48;
         }
 
         func_8002BE04(globalCtx, &targetCtx->targetCenterPos, &spBC, &spB4);
 
-        temp1 = ((spBC.x * spB4) * 160.0f) * var1;
-        spBC.x = (temp1 < -320.0f) ? -320.0f : ((temp1 > 320.0f) ? 320.0f : temp1);
+        temp1 = ((spBC.x * spB4) * 160) * var1;
+        spBC.x = (temp1 < -320) ? -320 : ((temp1 > 320) ? 320 : temp1);
 
-        temp1 = ((spBC.y * spB4) * 120.0f) * var1;
-        spBC.y = (temp1 < -240.0f) ? -240.0f : ((temp1 > 240.0f) ? 240.0f : temp1);
+        temp1 = ((spBC.y * spB4) * 120) * var1;
+        spBC.y = (temp1 < -240) ? -240 : ((temp1 > 240) ? 240 : temp1);
 
-        spBC.z *= var1;
+        spBC.z = spBC.z * var1;
 
         targetCtx->unk_4C--;
-        if (targetCtx->unk_4C < 0)
+        if (targetCtx->unk_4C < 0) {
             targetCtx->unk_4C = 2;
+        }
 
         func_8002BE64(targetCtx, targetCtx->unk_4C, spBC.x, spBC.y, spBC.z);
 
-        if ((!(player->stateFlags1 & 0x40)) || (targetCtx->targetedActor != player->unk_664))
-        {
-            gfxCtx->overlay.p = func_80093774(gfxCtx->overlay.p, 0x39);
+        if ((!(player->stateFlags1 & 0x40)) || (actor != player->unk_664)) {
+            gfxCtx->overlay.p = Gfx_CallSetupDL(gfxCtx->overlay.p, 0x39);
 
-            for (spB0 = 0, spAC = targetCtx->unk_4C; spB0 < spB8; spB0++)
-            {
+            for (spB0 = 0, spAC = targetCtx->unk_4C; spB0 < spB8; spB0++) {
                 entry = &targetCtx->arr_50[spAC];
 
-                if (entry->unk_0C < 500.0f)
-                {
-                    if (entry->unk_0C <= 120.0f)
+                if (entry->unk_0C < 500.0f) {
+                    if (entry->unk_0C <= 120.0f) {
                         var2 = 0.15f;
-                    else
+                    } else {
                         var2 = ((entry->unk_0C - 120.0f) * 0.001f) + 0.15f;
+                    }
 
                     Matrix_Translate(entry->pos.x, entry->pos.y, 0.0f, MTXMODE_NEW);
                     Matrix_Scale(var2, 0.15f, 1.0f, MTXMODE_APPLY);
 
-                    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                                    entry->color.r, entry->color.g, entry->color.b, (u8)spCE);
+                    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, entry->color.r, entry->color.g, entry->color.b,
+                                    (u8)spCE);
 
                     Matrix_RotateZ((targetCtx->unk_4B & 0x7F) * (M_PI / 64), MTXMODE_APPLY);
 
-                    for (i = 0; i < 4; i++)
-                    {
+                    for (i = 0; i < 4; i++) {
                         Matrix_RotateZ(M_PI / 2, MTXMODE_APPLY);
                         Matrix_Push();
                         Matrix_Translate(entry->unk_0C, entry->unk_0C, 0.0f, MTXMODE_APPLY);
-                        gSPMatrix(gfxCtx->overlay.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_actor.c", 2116), G_MTX_MODELVIEW | G_MTX_LOAD);
+                        gSPMatrix(gfxCtx->overlay.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_actor.c", 2116),
+                                  G_MTX_MODELVIEW | G_MTX_LOAD);
                         gSPDisplayList(gfxCtx->overlay.p++, &D_0404D450);
                         Matrix_Pull();
                     }
                 }
 
                 spCE = spCE - (0xFF / 3);
-                if (spCE < 0)
+                if (spCE < 0) {
                     spCE = 0;
+                }
                 spAC = (spAC + 1) % 3;
             }
         }
     }
 
     actor = targetCtx->unk_94;
-    if ((actor != NULL) && !(actor->flags & 0x8000000))
-    {
+    if ((actor != NULL) && !(actor->flags & 0x8000000)) {
         NaviColor* naviColor = &sNaviColorList[actor->type];
 
-        gfxCtx->polyXlu.p = func_80093774(gfxCtx->polyXlu.p, 0x7);
+        gfxCtx->polyXlu.p = Gfx_CallSetupDL(gfxCtx->polyXlu.p, 0x7);
 
-        Matrix_Translate(actor->posRot2.pos.x,
-                         actor->posRot2.pos.y + (actor->unk_4C * actor->scale.y) + 17.0f,
-                         actor->posRot2.pos.z,
-                         MTXMODE_NEW);
+        Matrix_Translate(actor->posRot2.pos.x, actor->posRot2.pos.y + (actor->unk_4C * actor->scale.y) + 17.0f,
+                         actor->posRot2.pos.z, MTXMODE_NEW);
         Matrix_RotateY((f32)((u16)(globalCtx->gameplayFrames * 3000)) * (M_PI / 32768), MTXMODE_APPLY);
-        Matrix_Scale((iREG(27) + 35) / 1000.0f,
-                     (iREG(28) + 60) / 1000.0f,
-                     (iREG(29) + 50) / 1000.0f,
-                     MTXMODE_APPLY);
-
-        gDPSetPrimColor(gfxCtx->polyXlu.p++, 0, 0,
-                        naviColor->inner.r, naviColor->inner.g, naviColor->inner.b, 0xFF);
-        gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_actor.c", 2153), G_MTX_MODELVIEW | G_MTX_LOAD);
+        Matrix_Scale((iREG(27) + 35) / 1000.0f, (iREG(28) + 60) / 1000.0f, (iREG(29) + 50) / 1000.0f, MTXMODE_APPLY);
+
+        gDPSetPrimColor(gfxCtx->polyXlu.p++, 0, 0, naviColor->inner.r, naviColor->inner.g, naviColor->inner.b, 0xFF);
+        gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_actor.c", 2153),
+                  G_MTX_MODELVIEW | G_MTX_LOAD);
         gSPDisplayList(gfxCtx->polyXlu.p++, &D_0400CB70);
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 2158);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 2158);
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_actor/func_8002C124.s")
 #endif
 
-void func_8002C7BC(TargetContext* targetCtx, Player* player, Actor* actorArg, GlobalContext* globalCtx)
-{
+void func_8002C7BC(TargetContext* targetCtx, Player* player, Actor* actorArg, GlobalContext* globalCtx) {
     s32 pad;
     Actor* unkActor;
     s32 actorType;
@@ -487,39 +453,37 @@ void func_8002C7BC(TargetContext* targetCtx, Player* player, Actor* actorArg, Gl
 
     unkActor = NULL;
 
-    if ((player->unk_664 != NULL) && (player->unk_84B[player->unk_846] == 2))
+    if ((player->unk_664 != NULL) && (player->unk_84B[player->unk_846] == 2)) {
         targetCtx->unk_94 = NULL;
-    else
-    {
+    } else {
         func_80032AF0(globalCtx, &globalCtx->actorCtx, &unkActor, player);
         targetCtx->unk_94 = unkActor;
     }
 
-    if (targetCtx->unk_8C != NULL)
-    {
+    if (targetCtx->unk_8C != NULL) {
         unkActor = targetCtx->unk_8C;
         targetCtx->unk_8C = NULL;
-    }
-    else if (actorArg != NULL)
+    } else if (actorArg != NULL) {
         unkActor = actorArg;
+    }
 
-    if (unkActor != NULL)
+    if (unkActor != NULL) {
         actorType = unkActor->type;
-    else
+    } else {
         actorType = player->actor.type;
+    }
 
-    if ((unkActor != targetCtx->arrowPointedActor) || (actorType != targetCtx->activeType))
-    {
+    if ((unkActor != targetCtx->arrowPointedActor) || (actorType != targetCtx->activeType)) {
         targetCtx->arrowPointedActor = unkActor;
         targetCtx->activeType = actorType;
         targetCtx->unk_40 = 1.0f;
     }
 
-    if (unkActor == NULL)
+    if (unkActor == NULL) {
         unkActor = &player->actor;
+    }
 
-    if (Math_ApproxF(&targetCtx->unk_40, 0.0f, 0.25f) == 0)
-    {
+    if (Math_ApproxF(&targetCtx->unk_40, 0.0f, 0.25f) == 0) {
         temp1 = 0.25f / targetCtx->unk_40;
         temp2 = unkActor->posRot.pos.x - targetCtx->naviRefPos.x;
         temp3 = (unkActor->posRot.pos.y + (unkActor->unk_4C * unkActor->scale.y)) - targetCtx->naviRefPos.y;
@@ -527,26 +491,25 @@ void func_8002C7BC(TargetContext* targetCtx, Player* player, Actor* actorArg, Gl
         targetCtx->naviRefPos.x += temp2 * temp1;
         targetCtx->naviRefPos.y += temp3 * temp1;
         targetCtx->naviRefPos.z += temp4 * temp1;
-    }
-    else
+    } else {
         func_8002BF60(targetCtx, unkActor, actorType, globalCtx);
+    }
 
-    if ((actorArg != NULL) && (targetCtx->unk_4B == 0))
-    {
+    if ((actorArg != NULL) && (targetCtx->unk_4B == 0)) {
         func_8002BE04(globalCtx, &actorArg->posRot2.pos, &sp50, &sp4C);
-        if (((sp50.z <= 0.0f) || (1.0f <= fabsf(sp50.x * sp4C))) || (1.0f <= fabsf(sp50.y * sp4C)))
+        if (((sp50.z <= 0.0f) || (1.0f <= fabsf(sp50.x * sp4C))) || (1.0f <= fabsf(sp50.y * sp4C))) {
             actorArg = NULL;
+        }
     }
 
-    if (actorArg != NULL)
-    {
-        if (actorArg != targetCtx->targetedActor)
-        {
+    if (actorArg != NULL) {
+        if (actorArg != targetCtx->targetedActor) {
             func_8002BE98(targetCtx, actorArg->type, globalCtx);
             targetCtx->targetedActor = actorArg;
 
-            if (actorArg->id == ACTOR_EN_BOOM)
+            if (actorArg->id == ACTOR_EN_BOOM) {
                 targetCtx->unk_48 = 0;
+            }
 
             lockOnSfxId = ((actorArg->flags & 5) == 5) ? NA_SE_SY_LOCK_ON : NA_SE_SY_LOCK_ON_HUMAN;
             func_80078884(lockOnSfxId);
@@ -556,21 +519,17 @@ void func_8002C7BC(TargetContext* targetCtx, Player* player, Actor* actorArg, Gl
         targetCtx->targetCenterPos.y = actorArg->posRot.pos.y - (actorArg->shape.unk_08 * actorArg->scale.y);
         targetCtx->targetCenterPos.z = actorArg->posRot.pos.z;
 
-        if (targetCtx->unk_4B == 0)
-        {
+        if (targetCtx->unk_4B == 0) {
             temp5 = (500.0f - targetCtx->unk_44) * 3.0f;
             temp6 = (temp5 < 30.0f) ? 30.0f : ((100.0f < temp5) ? 100.0f : temp5);
-            if (Math_ApproxF(&targetCtx->unk_44, 80.0f, temp6) != 0)
+            if (Math_ApproxF(&targetCtx->unk_44, 80.0f, temp6) != 0) {
                 targetCtx->unk_4B++;
-        }
-        else
-        {
+            }
+        } else {
             targetCtx->unk_4B = (targetCtx->unk_4B + 3) | 0x80;
             targetCtx->unk_44 = 120.0f;
         }
-    }
-    else
-    {
+    } else {
         targetCtx->targetedActor = NULL;
         Math_ApproxF(&targetCtx->unk_44, 500.0f, 80.0f);
     }
@@ -579,166 +538,155 @@ void func_8002C7BC(TargetContext* targetCtx, Player* player, Actor* actorArg, Gl
 /**
  * Tests if current scene switch flag is set.
  */
-s32 Flags_GetSwitch(GlobalContext* globalCtx, s32 flag)
-{
-    if (flag < 0x20)
+s32 Flags_GetSwitch(GlobalContext* globalCtx, s32 flag) {
+    if (flag < 0x20) {
         return globalCtx->actorCtx.flags.swch & (1 << flag);
-    else
+    } else {
         return globalCtx->actorCtx.flags.tempSwch & (1 << flag);
+    }
 }
 
 /**
  * Sets current scene switch flag.
  */
-void Flags_SetSwitch(GlobalContext* globalCtx, s32 flag)
-{
-    if (flag < 0x20)
+void Flags_SetSwitch(GlobalContext* globalCtx, s32 flag) {
+    if (flag < 0x20) {
         globalCtx->actorCtx.flags.swch |= (1 << flag);
-    else
+    } else {
         globalCtx->actorCtx.flags.tempSwch |= (1 << flag);
+    }
 }
 
 /**
  * Unsets current scene switch flag.
  */
-void Flags_UnsetSwitch(GlobalContext* globalCtx, s32 flag)
-{
-    if (flag < 0x20)
+void Flags_UnsetSwitch(GlobalContext* globalCtx, s32 flag) {
+    if (flag < 0x20) {
         globalCtx->actorCtx.flags.swch &= ~(1 << flag);
-    else
+    } else {
         globalCtx->actorCtx.flags.tempSwch &= ~(1 << flag);
+    }
 }
 
 /**
  * Tests if current scene unknown flag is set.
  */
-s32 Flags_GetUnknown(GlobalContext* globalCtx, s32 flag)
-{
-    if (flag < 0x20)
+s32 Flags_GetUnknown(GlobalContext* globalCtx, s32 flag) {
+    if (flag < 0x20) {
         return globalCtx->actorCtx.flags.unk0 & (1 << flag);
-    else
+    } else {
         return globalCtx->actorCtx.flags.unk1 & (1 << flag);
+    }
 }
 
 /**
  * Sets current scene unknown flag.
  */
-void Flags_SetUnknown(GlobalContext* globalCtx, s32 flag)
-{
-    if (flag < 0x20)
+void Flags_SetUnknown(GlobalContext* globalCtx, s32 flag) {
+    if (flag < 0x20) {
         globalCtx->actorCtx.flags.unk0 |= (1 << flag);
-    else
+    } else {
         globalCtx->actorCtx.flags.unk1 |= (1 << flag);
+    }
 }
 
 /**
  * Unsets current scene unknown flag.
  */
-void Flags_UnsetUnknown(GlobalContext* globalCtx, s32 flag)
-{
-    if (flag < 0x20)
+void Flags_UnsetUnknown(GlobalContext* globalCtx, s32 flag) {
+    if (flag < 0x20) {
         globalCtx->actorCtx.flags.unk0 &= ~(1 << flag);
-    else
+    } else {
         globalCtx->actorCtx.flags.unk1 &= ~(1 << flag);
+    }
 }
 
 /**
  * Tests if current scene chest flag is set.
  */
-s32 Flags_GetTreasure(GlobalContext* globalCtx, s32 flag)
-{
+s32 Flags_GetTreasure(GlobalContext* globalCtx, s32 flag) {
     return globalCtx->actorCtx.flags.chest & (1 << flag);
 }
 
 /**
  * Sets current scene chest flag.
  */
-void Flags_SetTreasure(GlobalContext* globalCtx, s32 flag)
-{
+void Flags_SetTreasure(GlobalContext* globalCtx, s32 flag) {
     globalCtx->actorCtx.flags.chest |= (1 << flag);
 }
 
 /**
  * Tests if current scene clear flag is set.
  */
-s32 Flags_GetClear(GlobalContext* globalCtx, s32 flag)
-{
+s32 Flags_GetClear(GlobalContext* globalCtx, s32 flag) {
     return globalCtx->actorCtx.flags.clear & (1 << flag);
 }
 
 /**
  * Sets current scene clear flag.
  */
-void Flags_SetClear(GlobalContext* globalCtx, s32 flag)
-{
+void Flags_SetClear(GlobalContext* globalCtx, s32 flag) {
     globalCtx->actorCtx.flags.clear |= (1 << flag);
 }
 
 /**
  * Unsets current scene clear flag.
  */
-void Flags_UnsetClear(GlobalContext* globalCtx, s32 flag)
-{
+void Flags_UnsetClear(GlobalContext* globalCtx, s32 flag) {
     globalCtx->actorCtx.flags.clear &= ~(1 << flag);
 }
 
 /**
  * Tests if current scene temp clear flag is set.
  */
-s32 Flags_GetTempClear(GlobalContext* globalCtx, s32 flag)
-{
+s32 Flags_GetTempClear(GlobalContext* globalCtx, s32 flag) {
     return globalCtx->actorCtx.flags.tempClear & (1 << flag);
 }
 
 /**
  * Sets current scene temp clear flag.
  */
-void Flags_SetTempClear(GlobalContext* globalCtx, s32 flag)
-{
+void Flags_SetTempClear(GlobalContext* globalCtx, s32 flag) {
     globalCtx->actorCtx.flags.tempClear |= 1 << flag;
 }
 
 /**
  * Unsets current scene temp clear flag.
  */
-void Flags_UnsetTempClear(GlobalContext* globalCtx, s32 flag)
-{
+void Flags_UnsetTempClear(GlobalContext* globalCtx, s32 flag) {
     globalCtx->actorCtx.flags.tempClear &= ~(1 << flag);
 }
 
 /**
  * Tests if current scene collectible flag is set.
  */
-s32 Flags_GetCollectible(GlobalContext* globalCtx, s32 flag)
-{
-    if (flag < 0x20)
+s32 Flags_GetCollectible(GlobalContext* globalCtx, s32 flag) {
+    if (flag < 0x20) {
         return globalCtx->actorCtx.flags.collect & (1 << flag);
-    else
+    } else {
         return globalCtx->actorCtx.flags.tempCollect & (1 << flag);
+    }
 }
 
 /**
  * Sets current scene collectible flag.
  */
-void Flags_SetCollectible(GlobalContext* globalCtx, s32 flag)
-{
-    if (flag != 0)
-    {
-        if (flag < 0x20)
+void Flags_SetCollectible(GlobalContext* globalCtx, s32 flag) {
+    if (flag != 0) {
+        if (flag < 0x20) {
             globalCtx->actorCtx.flags.collect |= 1 << flag;
-        else
+        } else {
             globalCtx->actorCtx.flags.tempCollect |= 1 << flag;
+        }
     }
 }
 
-void func_8002CDE4(GlobalContext* globalCtx, TitleCardContext* titleCtx)
-{
+void func_8002CDE4(GlobalContext* globalCtx, TitleCardContext* titleCtx) {
     titleCtx->delayA = titleCtx->delayB = titleCtx->unk_E = titleCtx->unk_C = 0;
 }
 
-void TitleCard_InitBossName(GlobalContext* globalCtx, TitleCardContext* titleCtx, u32 texture,
-                            s16 arg3, s16 arg4, u8 arg5, u8 arg6)
-{
+void TitleCard_InitBossName(GlobalContext* globalCtx, TitleCardContext* titleCtx, u32 texture, s16 arg3, s16 arg4,
+                            u8 arg5, u8 arg6) {
     titleCtx->texture = texture;
     titleCtx->unk_4 = arg3;
     titleCtx->unk_6 = arg4;
@@ -748,14 +696,14 @@ void TitleCard_InitBossName(GlobalContext* globalCtx, TitleCardContext* titleCtx
     titleCtx->delayB = 0;
 }
 
-void TitleCard_InitPlaceName(GlobalContext* globalCtx, TitleCardContext* titleCtx, u32 texture,
-                             s32 arg3, s32 arg4, s32 arg5, s32 arg6, s32 arg7)
-{
+void TitleCard_InitPlaceName(GlobalContext* globalCtx, TitleCardContext* titleCtx, u32 texture, s32 arg3, s32 arg4,
+                             s32 arg5, s32 arg6, s32 arg7) {
     Scene* loadedScene = globalCtx->loadedScene;
     u32 size = loadedScene->titleVromEnd - loadedScene->titleVromStart;
 
-    if ((size != 0) && (size <= 0x3000))
+    if ((size != 0) && (size <= 0x3000)) {
         DmaMgr_SendRequest1(texture, loadedScene->titleVromStart, size, "../z_actor.c", 2765);
+    }
 
     titleCtx->texture = texture;
     titleCtx->unk_4 = arg3;
@@ -766,41 +714,31 @@ void TitleCard_InitPlaceName(GlobalContext* globalCtx, TitleCardContext* titleCt
     titleCtx->delayB = arg7;
 }
 
-void TitleCard_Update(GlobalContext* globalCtx, TitleCardContext* titleCtx)
-{
-    if (DECR(titleCtx->delayB) == 0)
-    {
-        if (DECR(titleCtx->delayA) == 0)
-        {
+void TitleCard_Update(GlobalContext* globalCtx, TitleCardContext* titleCtx) {
+    if (DECR(titleCtx->delayB) == 0) {
+        if (DECR(titleCtx->delayA) == 0) {
             Math_ApproxS(&titleCtx->unk_C, 0, 30);
             Math_ApproxS(&titleCtx->unk_E, 0, 70);
-        }
-        else
-        {
+        } else {
             Math_ApproxS(&titleCtx->unk_C, 255, 10);
             Math_ApproxS(&titleCtx->unk_E, 255, 20);
         }
     }
 }
 
-#ifdef NON_MATCHING
-// major ordering and stack usage differences
-void TitleCard_Draw(GlobalContext* globalCtx, TitleCardContext* titleCtx)
-{
+void TitleCard_Draw(GlobalContext* globalCtx, TitleCardContext* titleCtx) {
     s32 spCC;
     s32 spC8;
     s32 unk1;
     s32 spC0;
-    s32 unk2;
+    s32 sp38;
     s32 spB8;
     s32 spB4;
     s32 spB0;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
-    s32 sp38;
+    Gfx* dispRefs[4];
 
-    if (titleCtx->unk_C != 0)
-    {
+    if (titleCtx->unk_C != 0) {
         spCC = titleCtx->unk_8;
         spC8 = titleCtx->unk_9;
         spC0 = (titleCtx->unk_4 * 4) - (spCC * 2);
@@ -808,66 +746,43 @@ void TitleCard_Draw(GlobalContext* globalCtx, TitleCardContext* titleCtx)
         sp38 = spCC * 2;
 
         gfxCtx = globalCtx->state.gfxCtx;
-
-        func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 2824);
+        Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 2824);
 
         spB0 = spCC * spC8 * gSaveContext.language;
-
         spC8 = (spCC * spC8 > 0x1000) ? 0x1000 / spCC : spC8;
+        spB4 = spB8 + (spC8 * 4);
 
-        spB4 = (spC8 * 4) + spB8;
+        if (1) {} // Necessary to match
 
         gfxCtx->overlay.p = func_80093808(gfxCtx->overlay.p);
 
-        gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                        (u8)titleCtx->unk_E, (u8)titleCtx->unk_E,
-                        (u8)titleCtx->unk_E, (u8)titleCtx->unk_C);
+        gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, (u8)titleCtx->unk_E, (u8)titleCtx->unk_E, (u8)titleCtx->unk_E,
+                        (u8)titleCtx->unk_C);
 
-        gDPLoadTextureBlock(gfxCtx->overlay.p++,
-                            titleCtx->texture + spB0,
-                            G_IM_FMT_IA,
-                            G_IM_SIZ_8b,
-                            spCC, spC8,
-                            0,
-                            G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP,
-                            G_TX_NOMASK, G_TX_NOMASK,
-                            G_TX_NOLOD, G_TX_NOLOD);
+        gDPLoadTextureBlock(gfxCtx->overlay.p++, titleCtx->texture + spB0, G_IM_FMT_IA, G_IM_SIZ_8b, spCC, spC8, 0,
+                            G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
+                            G_TX_NOLOD);
 
-        gSPTextureRectangle(gfxCtx->overlay.p++, spC0, spB8,
-                            ((sp38 * 2) + spC0) - 4, spB8 - 1, G_TX_RENDERTILE,
-                            0, 0, 1024, 1024);
+        gSPTextureRectangle(gfxCtx->overlay.p++, spC0, spB8, ((sp38 * 2) + spC0) - 4, spB8 + (spC8 * 4) - 1,
+                            G_TX_RENDERTILE, 0, 0, 1024, 1024);
 
         spC8 = titleCtx->unk_9 - spC8;
 
-        if (spC8 > 0)
-        {
-            gDPLoadTextureBlock(gfxCtx->overlay.p++,
-                                titleCtx->texture + spB0 + 0x1000,
-                                G_IM_FMT_IA,
-                                G_IM_SIZ_8b,
-                                spCC, spC8,
-                                0,
-                                G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP,
-                                G_TX_NOMASK, G_TX_NOMASK,
+        if (spC8 > 0) {
+            gDPLoadTextureBlock(gfxCtx->overlay.p++, titleCtx->texture + spB0 + 0x1000, G_IM_FMT_IA, G_IM_SIZ_8b, spCC,
+                                spC8, 0, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
                                 G_TX_NOLOD, G_TX_NOLOD);
 
-            gSPTextureRectangle(gfxCtx->overlay.p++, spC0, spB4,
-                                ((sp38 * 2) + spC0) - 4, spB4 - 1, G_TX_RENDERTILE,
-                                0, 0, 1024, 1024);
+            gSPTextureRectangle(gfxCtx->overlay.p++, spC0, spB4, ((sp38 * 2) + spC0) - 4, spB4 + (spC8 * 4) - 1,
+                                G_TX_RENDERTILE, 0, 0, 1024, 1024);
         }
 
-        func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 2880);
+        Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 2880);
     }
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_actor/TitleCard_Draw.s")
-#endif
 
-s32 func_8002D53C(GlobalContext* globalCtx, TitleCardContext* titleCtx)
-{
-    if ((globalCtx->actorCtx.titleCtx.delayB != 0) ||
-        (globalCtx->actorCtx.titleCtx.unk_C != 0))
-    {
+s32 func_8002D53C(GlobalContext* globalCtx, TitleCardContext* titleCtx) {
+    if ((globalCtx->actorCtx.titleCtx.delayB != 0) || (globalCtx->actorCtx.titleCtx.unk_C != 0)) {
         titleCtx->delayA = 0;
         titleCtx->delayB = 0;
         return 0;
@@ -876,20 +791,17 @@ s32 func_8002D53C(GlobalContext* globalCtx, TitleCardContext* titleCtx)
     return 1;
 }
 
-void Actor_Kill(Actor* actor)
-{
+void Actor_Kill(Actor* actor) {
     actor->draw = NULL;
     actor->update = NULL;
     actor->flags &= ~0x1;
 }
 
-void Actor_InitPosRot(Actor* actor)
-{
+void Actor_InitPosRot(Actor* actor) {
     actor->posRot = actor->initPosRot;
 }
 
-void Actor_SetHeight(Actor* actor, f32 offset)
-{
+void Actor_SetHeight(Actor* actor, f32 offset) {
     actor->posRot2.pos.x = actor->posRot.pos.x;
     actor->posRot2.pos.y = actor->posRot.pos.y + offset;
     actor->posRot2.pos.z = actor->posRot.pos.z;
@@ -899,30 +811,25 @@ void Actor_SetHeight(Actor* actor, f32 offset)
     actor->posRot2.rot.z = actor->posRot.rot.z;
 }
 
-void func_8002D5F4(Actor* actor)
-{
+void func_8002D5F4(Actor* actor) {
     actor->posRot.rot = actor->shape.rot;
 }
 
-void func_8002D610(Actor* actor)
-{
+void func_8002D610(Actor* actor) {
     actor->shape.rot = actor->posRot.rot;
 }
 
-void Actor_SetScale(Actor* actor, f32 scale)
-{
+void Actor_SetScale(Actor* actor, f32 scale) {
     actor->scale.z = scale;
     actor->scale.y = scale;
     actor->scale.x = scale;
 }
 
-void Actor_SetObjectDependency(GlobalContext* globalCtx, Actor* actor)
-{
+void Actor_SetObjectDependency(GlobalContext* globalCtx, Actor* actor) {
     gSegments[6] = PHYSICAL_TO_VIRTUAL(globalCtx->objectCtx.status[actor->objBankIndex].segment);
 }
 
-void Actor_Init(Actor* actor, GlobalContext* globalCtx)
-{
+void Actor_Init(Actor* actor, GlobalContext* globalCtx) {
     Actor_InitPosRot(actor);
     func_8002D610(actor);
     Actor_SetHeight(actor, 0.0f);
@@ -938,26 +845,21 @@ void Actor_Init(Actor* actor, GlobalContext* globalCtx)
     func_80061E48(&actor->sub_98);
     actor->floorPolySource = 0x32;
     ActorShape_Init(&actor->shape, 0.0f, NULL, 0.0f);
-    if (Object_IsLoaded(&globalCtx->objectCtx, actor->objBankIndex))
-    {
+    if (Object_IsLoaded(&globalCtx->objectCtx, actor->objBankIndex)) {
         Actor_SetObjectDependency(globalCtx, actor);
         actor->init(actor, globalCtx);
         actor->init = NULL;
     }
 }
 
-void Actor_Destroy(Actor* actor, GlobalContext* globalCtx)
-{
+void Actor_Destroy(Actor* actor, GlobalContext* globalCtx) {
     ActorOverlay* overlayEntry;
     char* name;
 
-    if (actor->destroy != NULL)
-    {
+    if (actor->destroy != NULL) {
         actor->destroy(actor, globalCtx);
         actor->destroy = NULL;
-    }
-    else
-    {
+    } else {
         overlayEntry = actor->overlayEntry;
         name = overlayEntry->name != NULL ? overlayEntry->name : "";
 
@@ -966,111 +868,94 @@ void Actor_Destroy(Actor* actor, GlobalContext* globalCtx)
     }
 }
 
-void func_8002D7EC(Actor* actor)
-{
+void func_8002D7EC(Actor* actor) {
     f32 speedRate = R_UPDATE_RATE * 0.5f;
     actor->posRot.pos.x += (actor->velocity.x * speedRate) + actor->sub_98.displacement.x;
     actor->posRot.pos.y += (actor->velocity.y * speedRate) + actor->sub_98.displacement.y;
     actor->posRot.pos.z += (actor->velocity.z * speedRate) + actor->sub_98.displacement.z;
 }
 
-void func_8002D868(Actor* actor)
-{
+void func_8002D868(Actor* actor) {
     actor->velocity.x = Math_Sins(actor->posRot.rot.y) * actor->speedXZ;
     actor->velocity.z = Math_Coss(actor->posRot.rot.y) * actor->speedXZ;
 
     actor->velocity.y += actor->gravity;
-    if (actor->velocity.y < actor->minVelocityY)
+    if (actor->velocity.y < actor->minVelocityY) {
         actor->velocity.y = actor->minVelocityY;
+    }
 }
 
-void Actor_MoveForward(Actor* actor)
-{
+void Actor_MoveForward(Actor* actor) {
     func_8002D868(actor);
     func_8002D7EC(actor);
 }
 
-void func_8002D908(Actor* actor)
-{
+void func_8002D908(Actor* actor) {
     f32 sp24 = Math_Coss(actor->posRot.rot.x) * actor->speedXZ;
     actor->velocity.x = Math_Sins(actor->posRot.rot.y) * sp24;
     actor->velocity.y = Math_Sins(actor->posRot.rot.x) * actor->speedXZ;
     actor->velocity.z = Math_Coss(actor->posRot.rot.y) * sp24;
 }
 
-void func_8002D97C(Actor* actor)
-{
+void func_8002D97C(Actor* actor) {
     func_8002D908(actor);
     func_8002D7EC(actor);
 }
 
-void func_8002D9A4(Actor* actor, f32 arg1)
-{
+void func_8002D9A4(Actor* actor, f32 arg1) {
     actor->speedXZ = Math_Coss(actor->posRot.rot.x) * arg1;
     actor->velocity.y = -Math_Sins(actor->posRot.rot.x) * arg1;
 }
 
-void func_8002D9F8(Actor* actor, UNK_PTR arg1)
-{
+void func_8002D9F8(Actor* actor, UNK_PTR arg1) {
     Vec3f sp1C;
-    func_800A54FC(arg1, &sp1C, actor->shape.rot.y, actor);
+    func_800A54FC(arg1, &sp1C, actor->shape.rot.y);
     actor->posRot.pos.x += sp1C.x * actor->scale.x;
     actor->posRot.pos.y += sp1C.y * actor->scale.y;
     actor->posRot.pos.z += sp1C.z * actor->scale.z;
 }
 
-s16 func_8002DA78(Actor* actorA, Actor* actorB)
-{
+s16 func_8002DA78(Actor* actorA, Actor* actorB) {
     return Math_Vec3f_Yaw(&actorA->posRot.pos, &actorB->posRot.pos);
 }
 
-s16 func_8002DA9C(Actor* actorA, Actor* actorB)
-{
+s16 func_8002DA9C(Actor* actorA, Actor* actorB) {
     return Math_Vec3f_Yaw(&actorA->posRot2.pos, &actorB->posRot2.pos);
 }
 
-s16 func_8002DAC0(Actor* actor, Vec3f* arg1)
-{
+s16 func_8002DAC0(Actor* actor, Vec3f* arg1) {
     return Math_Vec3f_Yaw(&actor->posRot.pos, arg1);
 }
 
-s16 func_8002DAE0(Actor* actorA, Actor* actorB)
-{
+s16 func_8002DAE0(Actor* actorA, Actor* actorB) {
     return Math_Vec3f_Pitch(&actorA->posRot.pos, &actorB->posRot.pos);
 }
 
-s16 func_8002DB04(Actor* actorA, Actor* actorB)
-{
+s16 func_8002DB04(Actor* actorA, Actor* actorB) {
     return Math_Vec3f_Pitch(&actorA->posRot2.pos, &actorB->posRot2.pos);
 }
 
-s16 func_8002DB28(Actor* actor, Vec3f* arg1)
-{
+s16 func_8002DB28(Actor* actor, Vec3f* arg1) {
     return Math_Vec3f_Pitch(&actor->posRot.pos, arg1);
 }
 
-f32 func_8002DB48(Actor* actorA, Actor* actorB)
-{
+f32 func_8002DB48(Actor* actorA, Actor* actorB) {
     return Math_Vec3f_DistXYZ(&actorA->posRot.pos, &actorB->posRot.pos);
 }
 
-f32 func_8002DB6C(Actor* actor, Vec3f* arg1)
-{
+f32 func_8002DB6C(Actor* actor, Vec3f* arg1) {
     return Math_Vec3f_DistXYZ(&actor->posRot.pos, arg1);
 }
 
-f32 func_8002DB8C(Actor* actorA, Actor* actorB)
-{
+f32 func_8002DB8C(Actor* actorA, Actor* actorB) {
     return Math_Vec3f_DistXZ(&actorA->posRot.pos, &actorB->posRot.pos);
 }
 
-f32 func_8002DBB0(Actor* actor, Vec3f* arg1)
-{
+f32 func_8002DBB0(Actor* actor, Vec3f* arg1) {
     return Math_Vec3f_DistXZ(&actor->posRot.pos, arg1);
 }
 
-void func_8002DBD0(Actor* actor, Vec3f* result, Vec3f* arg2)
-{
+void func_8002DBD0(Actor* actor, Vec3f* result, Vec3f* arg2) {
     f32 cosRot2Y;
     f32 sinRot2Y;
     f32 deltaX;
@@ -1086,72 +971,64 @@ void func_8002DBD0(Actor* actor, Vec3f* result, Vec3f* arg2)
     result->y = arg2->y - actor->posRot.pos.y;
 }
 
-f32 Actor_HeightDiff(Actor* actorA, Actor* actorB)
-{
+f32 Actor_HeightDiff(Actor* actorA, Actor* actorB) {
     return actorB->posRot.pos.y - actorA->posRot.pos.y;
 }
 
-f32 func_8002DC84(Player* player)
-{
+f32 func_8002DC84(Player* player) {
     f32 offset = (player->stateFlags1 & 0x800000) ? 32.0f : 0.0f;
 
-    if (LINK_IS_ADULT)
+    if (LINK_IS_ADULT) {
         return offset + 68.0f;
-    else
+    } else {
         return offset + 44.0f;
+    }
 }
 
-f32 func_8002DCE4(Player* player)
-{
-    if (player->stateFlags1 & 0x800000)
+f32 func_8002DCE4(Player* player) {
+    if (player->stateFlags1 & 0x800000) {
         return 8.0f;
-    else if (player->stateFlags1 & 0x8000000)
+    } else if (player->stateFlags1 & 0x8000000) {
         return (R_RUN_SPEED_LIMIT / 100.0f) * 0.6f;
-    else
+    } else {
         return R_RUN_SPEED_LIMIT / 100.0f;
+    }
 }
 
-s32 func_8002DD6C(Player* player)
-{
+s32 func_8002DD6C(Player* player) {
     return player->stateFlags1 & 0x8;
 }
 
-s32 func_8002DD78(Player* player)
-{
+s32 func_8002DD78(Player* player) {
     return func_8002DD6C(player) && player->unk_834;
 }
 
-s32 func_8002DDA8(GlobalContext* globalCtx)
-{
+s32 func_8002DDA8(GlobalContext* globalCtx) {
     Player* player = PLAYER;
     return (player->stateFlags1 & 0x800) || func_8002DD78(player);
 }
 
-s32 func_8002DDE4(GlobalContext* globalCtx)
-{
+s32 func_8002DDE4(GlobalContext* globalCtx) {
     Player* player = PLAYER;
     return player->stateFlags2 & 0x8;
 }
 
-s32 func_8002DDF4(GlobalContext* globalCtx)
-{
+s32 func_8002DDF4(GlobalContext* globalCtx) {
     Player* player = PLAYER;
     return player->stateFlags2 & 0x1000;
 }
 
-typedef struct
-{
-    /* 0x000 */ Actor   actor;
-    /* 0x14C */ char    unk_14C[0xB4];
-    /* 0x200 */ Actor*  unk_200;
-    /* 0x204 */ f32     unk_204;
-    /* 0x208 */ f32     unk_208;
-    /* 0x20C */ f32     unk_20C;
-    /* 0x210 */ s16     unk_210;
+typedef struct {
+    /* 0x000 */ Actor actor;
+    /* 0x14C */ char unk_14C[0xB4];
+    /* 0x200 */ Actor* unk_200;
+    /* 0x204 */ f32 unk_204;
+    /* 0x208 */ f32 unk_208;
+    /* 0x20C */ f32 unk_20C;
+    /* 0x210 */ s16 unk_210;
 } ActorArmsHook;
 
-void func_8002DE04(GlobalContext* globalCtx, Actor* actorA, Actor* actorB)
-{
+void func_8002DE04(GlobalContext* globalCtx, Actor* actorA, Actor* actorB) {
     ActorArmsHook* hookActor;
 
     hookActor = (ActorArmsHook*)Actor_Find(&globalCtx->actorCtx, 0x0066, ACTORTYPE_ITEMACTION);
@@ -1163,31 +1040,27 @@ void func_8002DE04(GlobalContext* globalCtx, Actor* actorA, Actor* actorB)
     actorA->flags &= ~0x2000;
 }
 
-void func_8002DE74(GlobalContext* globalCtx, Player* player)
-{
-    if ((globalCtx->roomCtx.curRoom.unk_03 != 4) && func_800C0CB8(globalCtx))
+void func_8002DE74(GlobalContext* globalCtx, Player* player) {
+    if ((globalCtx->roomCtx.curRoom.unk_03 != 4) && func_800C0CB8(globalCtx)) {
         func_8005A77C(func_800C04A4(globalCtx, 0), 6);
+    }
 }
 
-void func_8002DECC(GlobalContext* globalCtx, Player* player, Actor* actor)
-{
+void func_8002DECC(GlobalContext* globalCtx, Player* player, Actor* actor) {
     player->rideActor = actor;
     player->stateFlags1 |= 0x800000;
     actor->attachedB = &player->actor;
 }
 
-s32 func_8002DEEC(Player* player)
-{
+s32 func_8002DEEC(Player* player) {
     return (player->stateFlags1 & 0x20000080) || player->action;
 }
 
-void func_8002DF18(GlobalContext* globalCtx, ActorContext* actorCtx)
-{
+void func_8002DF18(GlobalContext* globalCtx, ActorContext* actorCtx) {
     func_8006DC68(globalCtx, actorCtx);
 }
 
-u32 func_8002DF38(GlobalContext* globalCtx, Actor* actor, u8 newAction)
-{
+u32 func_8002DF38(GlobalContext* globalCtx, Actor* actor, u8 newAction) {
     Player* player = PLAYER;
     player->action = newAction;
     player->unk_448 = actor;
@@ -1196,8 +1069,7 @@ u32 func_8002DF38(GlobalContext* globalCtx, Actor* actor, u8 newAction)
     return 1;
 }
 
-s32 func_8002DF54(GlobalContext* globalCtx, Actor* actor, u8 arg2)
-{
+s32 func_8002DF54(GlobalContext* globalCtx, Actor* actor, u8 arg2) {
     Player* player = PLAYER;
     func_8002DF38(globalCtx, actor, arg2);
     player->unk_46A = 1;
@@ -1205,96 +1077,91 @@ s32 func_8002DF54(GlobalContext* globalCtx, Actor* actor, u8 arg2)
     return 1;
 }
 
-void func_8002DF90(DynaPolyActor* dynaActor)
-{
+void func_8002DF90(DynaPolyActor* dynaActor) {
     dynaActor->unk_154 = 0.0f;
     dynaActor->unk_150 = 0.0f;
 }
 
-void func_8002DFA4(DynaPolyActor* dynaActor, f32 arg1, s16 arg2)
-{
+void func_8002DFA4(DynaPolyActor* dynaActor, f32 arg1, s16 arg2) {
     dynaActor->unk_150 += arg1;
     dynaActor->unk_158 = arg2;
 }
 
-s32 func_8002DFC8(Actor* actor, s16 arg1, GlobalContext* globalCtx)
-{
+s32 func_8002DFC8(Actor* actor, s16 arg1, GlobalContext* globalCtx) {
     Player* player = PLAYER;
     s16 var = (s16)(actor->rotTowardsLinkY + 0x8000) - player->actor.shape.rot.y;
 
-    if (ABS(var) < arg1)
+    if (ABS(var) < arg1) {
         return 1;
+    }
 
     return 0;
 }
 
-s32 func_8002E020(Actor* actorA, Actor* actorB, s16 arg2)
-{
+s32 func_8002E020(Actor* actorA, Actor* actorB, s16 arg2) {
     s16 var = (s16)(func_8002DA78(actorA, actorB) + 0x8000) - actorB->shape.rot.y;
 
-    if (ABS(var) < arg2)
+    if (ABS(var) < arg2) {
         return 1;
+    }
 
     return 0;
 }
 
-s32 func_8002E084(Actor* actor, s16 arg1)
-{
+s32 func_8002E084(Actor* actor, s16 arg1) {
     s16 var = actor->rotTowardsLinkY - actor->shape.rot.y;
 
-    if (ABS(var) < arg1)
+    if (ABS(var) < arg1) {
         return 1;
+    }
 
     return 0;
 }
 
-s32 func_8002E0D0(Actor* actorA, Actor* actorB, s16 arg2)
-{
+s32 func_8002E0D0(Actor* actorA, Actor* actorB, s16 arg2) {
     s16 var = func_8002DA78(actorA, actorB) - actorA->shape.rot.y;
 
-    if (ABS(var) < arg2)
+    if (ABS(var) < arg2) {
         return 1;
+    }
 
     return 0;
 }
 
-s32 func_8002E12C(Actor* actor, f32 arg1, s16 arg2)
-{
+s32 func_8002E12C(Actor* actor, f32 arg1, s16 arg2) {
     s16 var = actor->rotTowardsLinkY - actor->shape.rot.y;
 
-    if (ABS(var) < arg2)
-    {
+    if (ABS(var) < arg2) {
         f32 xyzDistanceFromLink = sqrtf(SQ(actor->xzDistanceFromLink) + SQ(actor->yDistanceFromLink));
 
-        if (xyzDistanceFromLink < arg1)
+        if (xyzDistanceFromLink < arg1) {
             return 1;
+        }
     }
 
     return 0;
 }
 
-s32 func_8002E1A8(Actor* actorA, Actor* actorB, f32 arg2, s16 arg3)
-{
-    if (func_8002DB48(actorA, actorB) < arg2)
-    {
+s32 func_8002E1A8(Actor* actorA, Actor* actorB, f32 arg2, s16 arg3) {
+    if (func_8002DB48(actorA, actorB) < arg2) {
         s16 var = func_8002DA78(actorA, actorB) - actorA->shape.rot.y;
 
-        if (ABS(var) < arg3)
+        if (ABS(var) < arg3) {
             return 1;
+        }
     }
 
     return 0;
 }
 
-s32 func_8002E234(Actor* actor, f32 arg1, s32 arg2)
-{
-    if ((actor->bgCheckFlags & 0x1) && (arg1 < -11.0f))
-    {
+s32 func_8002E234(Actor* actor, f32 arg1, s32 arg2) {
+    if ((actor->bgCheckFlags & 0x1) && (arg1 < -11.0f)) {
         actor->bgCheckFlags &= ~0x1;
         actor->bgCheckFlags |= 0x4;
 
-        if ((actor->velocity.y < 0.0f) && (arg2 & 0x10))
+        if ((actor->velocity.y < 0.0f) && (arg2 & 0x10)) {
             actor->velocity.y = 0.0f;
+        }
 
         return 0;
     }
@@ -1305,8 +1172,7 @@ s32 func_8002E234(Actor* actor, f32 arg1, s32 arg2)
 UNK_TYPE D_8015BBA0;
 u32 D_8015BBA4;
 
-s32 func_8002E2AC(GlobalContext* globalCtx, Actor* actor, Vec3f* arg2, s32 arg3)
-{
+s32 func_8002E2AC(GlobalContext* globalCtx, Actor* actor, Vec3f* arg2, s32 arg3) {
     f32 sp34;
     u32 sp30;
 
@@ -1315,25 +1181,22 @@ s32 func_8002E2AC(GlobalContext* globalCtx, Actor* actor, Vec3f* arg2, s32 arg3)
     actor->unk_80 = func_8003CA0C(globalCtx, &globalCtx->colCtx, &actor->floorPoly, &sp30, actor, arg2);
     actor->bgCheckFlags &= ~0x0086;
 
-    if (actor->unk_80 <= -32000.0f)
+    if (actor->unk_80 <= -32000.0f) {
         return func_8002E234(actor, -32000.0f, arg3);
+    }
 
     sp34 = actor->unk_80 - actor->posRot.pos.y;
     actor->floorPolySource = sp30;
 
-    if (sp34 >= 0.0f)
-    {
+    if (sp34 >= 0.0f) {
         actor->bgCheckFlags |= 0x80;
 
-        if (actor->bgCheckFlags & 0x10)
-        {
-            if (sp30 != D_8015BBA4)
-            {
-                if (sp34 > 15.0f)
+        if (actor->bgCheckFlags & 0x10) {
+            if (sp30 != D_8015BBA4) {
+                if (sp34 > 15.0f) {
                     actor->bgCheckFlags |= 0x100;
-            }
-            else
-            {
+                }
+            } else {
                 actor->posRot.pos.x = actor->pos4.x;
                 actor->posRot.pos.z = actor->pos4.z;
             }
@@ -1341,23 +1204,22 @@ s32 func_8002E2AC(GlobalContext* globalCtx, Actor* actor, Vec3f* arg2, s32 arg3)
 
         actor->posRot.pos.y = actor->unk_80;
 
-        if (actor->velocity.y <= 0.0f)
-        {
-            if (!(actor->bgCheckFlags & 0x1))
+        if (actor->velocity.y <= 0.0f) {
+            if (!(actor->bgCheckFlags & 0x1)) {
                 actor->bgCheckFlags |= 0x2;
-            else if ((arg3 & 0x8) && (actor->gravity < 0.0f))
+            } else if ((arg3 & 0x8) && (actor->gravity < 0.0f)) {
                 actor->velocity.y = -4.0f;
-            else
+            } else {
                 actor->velocity.y = 0.0f;
+            }
 
             actor->bgCheckFlags |= 0x1;
             func_80043334(&globalCtx->colCtx, actor, actor->floorPolySource);
         }
-    }
-    else
-    {
-        if ((actor->bgCheckFlags & 0x1) && (sp34 >= -11.0f))
+    } else {
+        if ((actor->bgCheckFlags & 0x1) && (sp34 >= -11.0f)) {
             func_80043334(&globalCtx->colCtx, actor, actor->floorPolySource);
+        }
 
         return func_8002E234(actor, sp34, arg3);
     }
@@ -1365,8 +1227,7 @@ s32 func_8002E2AC(GlobalContext* globalCtx, Actor* actor, Vec3f* arg2, s32 arg3)
     return 1;
 }
 
-void func_8002E4B4(GlobalContext* globalCtx, Actor* actor, f32 arg2, f32 arg3, f32 arg4, s32 arg5)
-{
+void func_8002E4B4(GlobalContext* globalCtx, Actor* actor, f32 arg2, f32 arg3, f32 arg4, s32 arg5) {
     f32 sp74;
     s32 pad;
     Vec3f sp64;
@@ -1379,58 +1240,50 @@ void func_8002E4B4(GlobalContext* globalCtx, Actor* actor, f32 arg2, f32 arg3, f
 
     sp74 = actor->posRot.pos.y - actor->pos4.y;
 
-    if ((actor->floorPolySource != 0x32) && (actor->bgCheckFlags & 1))
+    if ((actor->floorPolySource != 0x32) && (actor->bgCheckFlags & 1)) {
         func_800433A4(&globalCtx->colCtx, actor->floorPolySource, actor);
+    }
 
-    if (arg5 & 1)
-    {
-        if ((!(arg5 & 0x80) && func_8003D52C(&globalCtx->colCtx, &sp64, &actor->posRot.pos,
-                                             &actor->pos4, arg3, &actor->wallPoly, &sp60, actor, arg2)) ||
-            ((arg5 & 0x80) && func_8003D594(&globalCtx->colCtx, &sp64, &actor->posRot.pos,
-                                            &actor->pos4, arg3, &actor->wallPoly, &sp60, actor, arg2)))
-        {
+    if (arg5 & 1) {
+        if ((!(arg5 & 0x80) && func_8003D52C(&globalCtx->colCtx, &sp64, &actor->posRot.pos, &actor->pos4, arg3,
+                                             &actor->wallPoly, &sp60, actor, arg2)) ||
+            ((arg5 & 0x80) && func_8003D594(&globalCtx->colCtx, &sp64, &actor->posRot.pos, &actor->pos4, arg3,
+                                            &actor->wallPoly, &sp60, actor, arg2))) {
             sp5C = actor->wallPoly;
             Math_Vec3f_Copy(&actor->posRot.pos, &sp64);
             actor->unk_7E = atan2s(sp5C->norm.z, sp5C->norm.x);
             actor->bgCheckFlags |= 8;
             actor->wallPolySource = sp60;
-        }
-        else
+        } else {
             actor->bgCheckFlags &= ~8;
+        }
     }
 
     sp64.x = actor->posRot.pos.x;
     sp64.z = actor->posRot.pos.z;
 
-    if (arg5 & 2)
-    {
+    if (arg5 & 2) {
         sp64.y = actor->pos4.y + 10.0f;
-        if (func_8003D7A0(&globalCtx->colCtx, &sp58, &sp64, (arg4 + sp74) - 10.0f, &D_8015BBA0, &D_8015BBA4, actor))
-        {
+        if (func_8003D7A0(&globalCtx->colCtx, &sp58, &sp64, (arg4 + sp74) - 10.0f, &D_8015BBA0, &D_8015BBA4, actor)) {
             actor->bgCheckFlags |= 0x10;
             actor->posRot.pos.y = (sp58 + sp74) - 10.0f;
-        }
-        else
+        } else {
             actor->bgCheckFlags &= ~0x10;
+        }
     }
 
-    if (arg5 & 4)
-    {
+    if (arg5 & 4) {
         sp64.y = actor->pos4.y;
         func_8002E2AC(globalCtx, actor, &sp64, arg5);
         sp50 = actor->posRot.pos.y;
-        if (func_8004213C(globalCtx, &globalCtx->colCtx, actor->posRot.pos.x, actor->posRot.pos.z, &sp50, &sp54))
-        {
+        if (func_8004213C(globalCtx, &globalCtx->colCtx, actor->posRot.pos.x, actor->posRot.pos.z, &sp50, &sp54)) {
             actor->unk_84 = sp50 - actor->posRot.pos.y;
-            if (actor->unk_84 < 0.0f)
+            if (actor->unk_84 < 0.0f) {
                 actor->bgCheckFlags &= ~0x60;
-            else
-            {
-                if (!(actor->bgCheckFlags & 0x20))
-                {
+            } else {
+                if (!(actor->bgCheckFlags & 0x20)) {
                     actor->bgCheckFlags |= 0x40;
-                    if (!(arg5 & 0x40))
-                    {
+                    if (!(arg5 & 0x40)) {
                         sp44.x = actor->posRot.pos.x;
                         sp44.y = sp50;
                         sp44.z = actor->posRot.pos.z;
@@ -1441,9 +1294,7 @@ void func_8002E4B4(GlobalContext* globalCtx, Actor* actor, f32 arg2, f32 arg3, f
                 }
                 actor->bgCheckFlags |= 0x20;
             }
-        }
-        else
-        {
+        } else {
             actor->bgCheckFlags &= ~0x60;
             actor->unk_84 = -32000.0f;
         }
@@ -1452,8 +1303,7 @@ void func_8002E4B4(GlobalContext* globalCtx, Actor* actor, f32 arg2, f32 arg3, f
 
 s32 D_8015BBA8[16];
 
-Gfx* func_8002E830(Vec3f* object, Vec3f* eye, Vec3f* lightDir, GraphicsContext* gfxCtx, Gfx* gfx, Hilite** hilite)
-{
+Gfx* func_8002E830(Vec3f* object, Vec3f* eye, Vec3f* lightDir, GraphicsContext* gfxCtx, Gfx* gfx, Hilite** hilite) {
     Gfx* lookAt;
     f32 correctedEyeX;
 
@@ -1463,20 +1313,15 @@ Gfx* func_8002E830(Vec3f* object, Vec3f* eye, Vec3f* lightDir, GraphicsContext*
 
     *hilite = Graph_Alloc(gfxCtx, sizeof(Hilite));
 
-    if (HREG(80) == 6)
+    if (HREG(80) == 6) {
         osSyncPrintf("z_actor.c 3529 eye=[%f(%f) %f %f] object=[%f %f %f] light_direction=[%f %f %f]\n",
-                     (f64)correctedEyeX, (f64)eye->x, (f64)eye->y, (f64)eye->z,
-                     (f64)object->x, (f64)object->y, (f64) object->z,
-                     (f64)lightDir->x, (f64)lightDir->y, (f64)lightDir->z);
+                     (f64)correctedEyeX, (f64)eye->x, (f64)eye->y, (f64)eye->z, (f64)object->x, (f64)object->y,
+                     (f64)object->z, (f64)lightDir->x, (f64)lightDir->y, (f64)lightDir->z);
+    }
 
     func_800ABE74(correctedEyeX, eye->y, eye->z);
-    func_80103A70(&D_8015BBA8, lookAt, *hilite,
-                  correctedEyeX, eye->y, eye->z,
-                  object->x, object->y, object->z,
-                  0.0f, 1.0f, 0.0f,
-                  lightDir->x, lightDir->y, lightDir->z,
-                  lightDir->x, lightDir->y, lightDir->z,
-                  0x10, 0x10);
+    func_80103A70(&D_8015BBA8, lookAt, *hilite, correctedEyeX, eye->y, eye->z, object->x, object->y, object->z, 0.0f,
+                  1.0f, 0.0f, lightDir->x, lightDir->y, lightDir->z, lightDir->x, lightDir->y, lightDir->z, 0x10, 0x10);
 
     gSPLookAt(gfx++, lookAt);
     gDPSetHilite1Tile(gfx++, 1, *hilite, 0x10, 0x10);
@@ -1484,73 +1329,69 @@ Gfx* func_8002E830(Vec3f* object, Vec3f* eye, Vec3f* lightDir, GraphicsContext*
     return gfx;
 }
 
-Hilite* func_8002EABC(Vec3f* object, Vec3f* eye, Vec3f* lightDir, GraphicsContext* gfxCtx)
-{
+Hilite* func_8002EABC(Vec3f* object, Vec3f* eye, Vec3f* lightDir, GraphicsContext* gfxCtx) {
     Hilite* hilite;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_actor.c", 4306);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_actor.c", 4306);
     gfxCtx->polyOpa.p = func_8002E830(object, eye, lightDir, gfxCtx, gfxCtx->polyOpa.p, &hilite);
-    func_800C6B54(gfxArr, gfxCtx, "../z_actor.c", 4313);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_actor.c", 4313);
 
     return hilite;
 }
 
-Hilite* func_8002EB44(Vec3f* object, Vec3f* eye, Vec3f* lightDir, GraphicsContext* gfxCtx)
-{
+Hilite* func_8002EB44(Vec3f* object, Vec3f* eye, Vec3f* lightDir, GraphicsContext* gfxCtx) {
     Hilite* hilite;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_actor.c", 4332);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_actor.c", 4332);
     gfxCtx->polyXlu.p = func_8002E830(object, eye, lightDir, gfxCtx, gfxCtx->polyXlu.p, &hilite);
-    func_800C6B54(gfxArr, gfxCtx, "../z_actor.c", 4339);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_actor.c", 4339);
 
     return hilite;
 }
 
-void func_8002EBCC(Actor* actor, GlobalContext* globalCtx, s32 flag)
-{
+void func_8002EBCC(Actor* actor, GlobalContext* globalCtx, s32 flag) {
     Hilite* hilite;
     Vec3f lightDir;
     Gfx* displayListHead;
     Gfx* displayList;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     lightDir.x = globalCtx->unk_10A4E;
     lightDir.y = globalCtx->unk_10A4F;
     lightDir.z = globalCtx->unk_10A50;
 
-    if (HREG(80) == 6)
-        osSyncPrintf("z_actor.c 3637 game_play->view.eye=[%f(%f) %f %f]\n",
-                     (f64)globalCtx->view.eye.x, (f64)globalCtx->view.eye.y, (f64)globalCtx->view.eye.z);
+    if (HREG(80) == 6) {
+        osSyncPrintf("z_actor.c 3637 game_play->view.eye=[%f(%f) %f %f]\n", (f64)globalCtx->view.eye.x,
+                     (f64)globalCtx->view.eye.y, (f64)globalCtx->view.eye.z);
+    }
 
     hilite = func_8002EABC(&actor->posRot.pos, &globalCtx->view.eye, &lightDir, globalCtx->state.gfxCtx);
 
-    if (flag != 0)
-    {
+    if (flag != 0) {
         displayList = Graph_Alloc(globalCtx->state.gfxCtx, 2 * sizeof(Gfx));
         displayListHead = displayList;
 
         gfxCtx = globalCtx->state.gfxCtx;
-        func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 4384);
+        Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 4384);
 
         gDPSetHilite1Tile(displayListHead++, 1, hilite, 0x10, 0x10);
         gSPEndDisplayList(displayListHead);
         gSPSegment(gfxCtx->polyOpa.p++, 0x07, displayList);
 
-        func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 4394);
+        Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 4394);
     }
 }
 
-void func_8002ED80(Actor* actor, GlobalContext* globalCtx, s32 flag)
-{
+void func_8002ED80(Actor* actor, GlobalContext* globalCtx, s32 flag) {
     Hilite* hilite;
     Vec3f lightDir;
     Gfx* displayListHead;
     Gfx* displayList;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     lightDir.x = globalCtx->unk_10A4E;
     lightDir.y = globalCtx->unk_10A4F;
@@ -1558,38 +1399,34 @@ void func_8002ED80(Actor* actor, GlobalContext* globalCtx, s32 flag)
 
     hilite = func_8002EB44(&actor->posRot.pos, &globalCtx->view.eye, &lightDir, globalCtx->state.gfxCtx);
 
-    if (flag != 0)
-    {
+    if (flag != 0) {
         displayList = Graph_Alloc(globalCtx->state.gfxCtx, 2 * sizeof(Gfx));
         displayListHead = displayList;
 
         gfxCtx = globalCtx->state.gfxCtx;
-        func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 4429);
+        Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 4429);
 
         gDPSetHilite1Tile(displayListHead++, 1, hilite, 0x10, 0x10);
         gSPEndDisplayList(displayListHead);
         gSPSegment(gfxCtx->polyXlu.p++, 0x07, displayList);
 
-        func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 4439);
+        Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 4439);
     }
 }
 
-PosRot* func_8002EEE4(PosRot* arg0, Actor* actor)
-{
+PosRot* func_8002EEE4(PosRot* arg0, Actor* actor) {
     *arg0 = actor->posRot2;
 
     return arg0;
 }
 
-PosRot* func_8002EF14(PosRot* arg0, Actor* actor)
-{
+PosRot* func_8002EF14(PosRot* arg0, Actor* actor) {
     *arg0 = actor->posRot;
 
     return arg0;
 }
 
-PosRot* func_8002EF44(PosRot* arg0, Actor* actor)
-{
+PosRot* func_8002EF44(PosRot* arg0, Actor* actor) {
     PosRot sp1C;
 
     Math_Vec3f_Copy(&sp1C.pos, &actor->posRot.pos);
@@ -1601,24 +1438,24 @@ PosRot* func_8002EF44(PosRot* arg0, Actor* actor)
 
 #ifdef NON_MATCHING
 // single regalloc difference
-f32 func_8002EFC0(Actor* actor, Player* player, s16 arg2)
-{
+f32 func_8002EFC0(Actor* actor, Player* player, s16 arg2) {
     s16 var;
     s16 abs_var;
 
     var = (s16)(actor->rotTowardsLinkY - 0x8000) - arg2;
     abs_var = ABS(var);
 
-    if (player->unk_664 != NULL)
-    {
-        if ((abs_var > 0x4000) || (actor->flags & 0x8000000))
+    if (player->unk_664 != NULL) {
+        if ((abs_var > 0x4000) || (actor->flags & 0x8000000)) {
             return FLT_MAX;
-        else
+        } else {
             return actor->waterSurfaceDist - actor->waterSurfaceDist * 0.8f * ((0x4000 - abs_var) * 3.0517578125e-05f);
+        }
     }
 
-    if (abs_var > 0x2AAA)
+    if (abs_var > 0x2AAA) {
         return FLT_MAX;
+    }
 
     return actor->waterSurfaceDist;
 }
@@ -1627,48 +1464,38 @@ extern f32 func_8002EFC0(Actor* actor, Player* player, s16 arg2);
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_actor/func_8002EFC0.s")
 #endif
 
-typedef struct
-{
+typedef struct {
     f32 unk_0, unk_4;
 } struct_80115FF8; // size = 0x8
 
-struct_80115FF8 D_80115FF8[] =
-{
-    {    4900.0f,        0.5f },
-    {   28900.0f,  0.6666667f },
-    {   78400.0f,       0.05f },
-    {  122500.0f,  0.6666667f },
-    {  490000.0f,  0.6666667f },
-    { 1000000.0f,  0.6666667f },
-    {   10000.0f, 0.94905096f },
-    {   19600.0f, 0.85714287f },
-    {   57600.0f, 0.41666666f },
-    {   78400.0f,      0.001f },
+struct_80115FF8 D_80115FF8[] = {
+    { 4900.0f, 0.5f },         { 28900.0f, 0.6666667f },   { 78400.0f, 0.05f },       { 122500.0f, 0.6666667f },
+    { 490000.0f, 0.6666667f }, { 1000000.0f, 0.6666667f }, { 10000.0f, 0.94905096f }, { 19600.0f, 0.85714287f },
+    { 57600.0f, 0.41666666f }, { 78400.0f, 0.001f },
 };
 
-u32 func_8002F090(Actor* actor, f32 arg1)
-{
+u32 func_8002F090(Actor* actor, f32 arg1) {
     return arg1 < D_80115FF8[actor->unk_1F].unk_0;
 }
 
-s32 func_8002F0C8(Actor* actor, Player* player, s32 flag)
-{
+s32 func_8002F0C8(Actor* actor, Player* player, s32 flag) {
     s16 var;
     s16 abs_var;
     f32 dist;
 
-    if ((actor->update == NULL) || !(actor->flags & 1))
+    if ((actor->update == NULL) || !(actor->flags & 1)) {
         return 1;
+    }
 
-    if (!flag)
-    {
+    if (!flag) {
         var = (s16)(actor->rotTowardsLinkY - 0x8000) - player->actor.shape.rot.y;
         abs_var = ABS(var);
 
-        if ((player->unk_664 == NULL) && (abs_var > 0x2AAA))
+        if ((player->unk_664 == NULL) && (abs_var > 0x2AAA)) {
             dist = FLT_MAX;
-        else
+        } else {
             dist = actor->waterSurfaceDist;
+        }
 
         return !func_8002F090(actor, D_80115FF8[actor->unk_1F].unk_4 * dist);
     }
@@ -1676,10 +1503,8 @@ s32 func_8002F0C8(Actor* actor, Player* player, s32 flag)
     return 0;
 }
 
-u32 func_8002F194(Actor* actor, GlobalContext* globalCtx)
-{
-    if (actor->flags & 0x100)
-    {
+u32 func_8002F194(Actor* actor, GlobalContext* globalCtx) {
+    if (actor->flags & 0x100) {
         actor->flags &= ~0x100;
         return 1;
     }
@@ -1687,18 +1512,16 @@ u32 func_8002F194(Actor* actor, GlobalContext* globalCtx)
     return 0;
 }
 
-s32 func_8002F1C4(Actor* actor, GlobalContext* globalCtx, f32 arg2, f32 arg3, u32 arg4)
-{
+s32 func_8002F1C4(Actor* actor, GlobalContext* globalCtx, f32 arg2, f32 arg3, u32 arg4) {
     Player* player = PLAYER;
 
     // This is convoluted but it seems like it must be a single if statement to match
-    if ((player->actor.flags & 0x100) ||
-        ((arg4 != 0) && func_8008E988(globalCtx)) ||
+    if ((player->actor.flags & 0x100) || ((arg4 != 0) && func_8008E988(globalCtx)) ||
         ((actor->unk_10C == 0) &&
-         ((arg3 < fabsf(actor->yDistanceFromLink)) ||
-          (player->unk_698 < actor->xzDistanceFromLink) ||
-          (arg2 < actor->xzDistanceFromLink))))
+         ((arg3 < fabsf(actor->yDistanceFromLink)) || (player->unk_698 < actor->xzDistanceFromLink) ||
+          (arg2 < actor->xzDistanceFromLink)))) {
         return 0;
+    }
 
     player->unk_694 = actor;
     player->unk_698 = actor->xzDistanceFromLink;
@@ -1707,38 +1530,33 @@ s32 func_8002F1C4(Actor* actor, GlobalContext* globalCtx, f32 arg2, f32 arg3, u3
     return 1;
 }
 
-s32 func_8002F298(Actor* actor, GlobalContext* globalCtx, f32 arg2, u32 arg3)
-{
+s32 func_8002F298(Actor* actor, GlobalContext* globalCtx, f32 arg2, u32 arg3) {
     return func_8002F1C4(actor, globalCtx, arg2, arg2, arg3);
 }
 
-s32 func_8002F2CC(Actor* actor, GlobalContext* globalCtx, f32 arg2)
-{
+s32 func_8002F2CC(Actor* actor, GlobalContext* globalCtx, f32 arg2) {
     return func_8002F298(actor, globalCtx, arg2, 0);
 }
 
-s32 func_8002F2F4(Actor* actor, GlobalContext* globalCtx)
-{
+s32 func_8002F2F4(Actor* actor, GlobalContext* globalCtx) {
     f32 var1 = 50.0f + actor->sub_98.unk_10;
     return func_8002F2CC(actor, globalCtx, var1);
 }
 
-u32 func_8002F334(Actor* actor, GlobalContext* globalCtx)
-{
-    if (func_8010BDBC(&globalCtx->msgCtx) == 2)
+u32 func_8002F334(Actor* actor, GlobalContext* globalCtx) {
+    if (func_8010BDBC(&globalCtx->msgCtx) == 2) {
         return 1;
-    else
+    } else {
         return 0;
+    }
 }
 
-s8 func_8002F368(GlobalContext* globalCtx)
-{
+s8 func_8002F368(GlobalContext* globalCtx) {
     Player* player = PLAYER;
     return player->exchangeItemId;
 }
 
-void func_8002F374(GlobalContext* globalCtx, Actor* actor, s16* arg2, s16* arg3)
-{
+void func_8002F374(GlobalContext* globalCtx, Actor* actor, s16* arg2, s16* arg3) {
     Vec3f sp1C;
     f32 sp18;
 
@@ -1747,31 +1565,26 @@ void func_8002F374(GlobalContext* globalCtx, Actor* actor, s16* arg2, s16* arg3)
     *arg3 = sp1C.y * sp18 * -120.0f + 120.0f;
 }
 
-u32 func_8002F410(Actor* actor, GlobalContext* globalCtx)
-{
-    if (actor->attachedA != NULL)
+u32 func_8002F410(Actor* actor, GlobalContext* globalCtx) {
+    if (actor->attachedA != NULL) {
         return 1;
-    else
+    } else {
         return 0;
+    }
 }
 
-s32 func_8002F434(Actor* actor, GlobalContext* globalCtx, s32 getItemId, f32 xzRange, f32 yRange)
-{
+s32 func_8002F434(Actor* actor, GlobalContext* globalCtx, s32 getItemId, f32 xzRange, f32 yRange) {
     Player* player = PLAYER;
     s16 var;
     s32 abs_var;
 
-    if (!(player->stateFlags1 & 0x3C7080) && func_8008F29C(player) < 0)
-    {
+    if (!(player->stateFlags1 & 0x3C7080) && func_8008F29C(player) < 0) {
         if ((((player->heldActor != NULL) || (actor == player->unk_694)) && (getItemId > 0) && (getItemId < 0x7E)) ||
-            (!(player->stateFlags1 & 0x20000800)))
-        {
-            if ((actor->xzDistanceFromLink < xzRange) && (fabsf(actor->yDistanceFromLink) < yRange))
-            {
+            (!(player->stateFlags1 & 0x20000800))) {
+            if ((actor->xzDistanceFromLink < xzRange) && (fabsf(actor->yDistanceFromLink) < yRange)) {
                 var = actor->rotTowardsLinkY - player->actor.shape.rot.y;
                 abs_var = ABS(var);
-                if ((getItemId != 0) || (player->getItemDirection < abs_var))
-                {
+                if ((getItemId != 0) || (player->getItemDirection < abs_var)) {
                     player->getItemId = getItemId;
                     player->interactRangeActor = actor;
                     player->getItemDirection = abs_var;
@@ -1784,30 +1597,26 @@ s32 func_8002F434(Actor* actor, GlobalContext* globalCtx, s32 getItemId, f32 xzR
     return 0;
 }
 
-void func_8002F554(Actor* actor, GlobalContext* globalCtx, s32 getItemId)
-{
+void func_8002F554(Actor* actor, GlobalContext* globalCtx, s32 getItemId) {
     func_8002F434(actor, globalCtx, getItemId, 50.0f, 10.0f);
 }
 
-void func_8002F580(Actor* actor, GlobalContext* globalCtx)
-{
+void func_8002F580(Actor* actor, GlobalContext* globalCtx) {
     func_8002F554(actor, globalCtx, 0);
 }
 
-u32 func_8002F5A0(Actor* actor, GlobalContext* globalCtx)
-{
-    if (actor->attachedA == NULL)
+u32 func_8002F5A0(Actor* actor, GlobalContext* globalCtx) {
+    if (actor->attachedA == NULL) {
         return 1;
-    else
+    } else {
         return 0;
+    }
 }
 
-void func_8002F5C4(Actor* actorA, Actor* actorB, GlobalContext* globalCtx)
-{
+void func_8002F5C4(Actor* actorA, Actor* actorB, GlobalContext* globalCtx) {
     Actor* actorAttachedA = actorA->attachedA;
 
-    if (actorAttachedA->id == ACTOR_PLAYER)
-    {
+    if (actorAttachedA->id == ACTOR_PLAYER) {
         Player* player = (Player*)actorAttachedA;
         player->heldActor = actorB;
         player->interactRangeActor = actorB;
@@ -1818,28 +1627,26 @@ void func_8002F5C4(Actor* actorA, Actor* actorB, GlobalContext* globalCtx)
     actorA->attachedA = NULL;
 }
 
-void func_8002F5F0(Actor* actor, GlobalContext* globalCtx)
-{
+void func_8002F5F0(Actor* actor, GlobalContext* globalCtx) {
     Player* player = PLAYER;
 
-    if (actor->waterSurfaceDist < player->unk_6A4)
+    if (actor->waterSurfaceDist < player->unk_6A4) {
         player->unk_6A4 = actor->waterSurfaceDist;
+    }
 }
 
-u32 func_8002F618(GlobalContext* globalCtx, Actor* actor)
-{
-    if (actor->attachedB != NULL)
+u32 func_8002F618(GlobalContext* globalCtx, Actor* actor) {
+    if (actor->attachedB != NULL) {
         return 1;
-    else
+    } else {
         return 0;
+    }
 }
 
-u32 func_8002F63C(GlobalContext* globalCtx, Actor* actor, s32 arg2)
-{
+u32 func_8002F63C(GlobalContext* globalCtx, Actor* actor, s32 arg2) {
     Player* player = PLAYER;
 
-    if (!(player->stateFlags1 & 0x003C7880))
-    {
+    if (!(player->stateFlags1 & 0x003C7880)) {
         player->rideActor = actor;
         player->unk_43C = arg2;
         return 1;
@@ -1848,16 +1655,15 @@ u32 func_8002F63C(GlobalContext* globalCtx, Actor* actor, s32 arg2)
     return 0;
 }
 
-u32 func_8002F674(GlobalContext* globalCtx, Actor* actor)
-{
-    if (actor->attachedB == NULL)
+u32 func_8002F674(GlobalContext* globalCtx, Actor* actor) {
+    if (actor->attachedB == NULL) {
         return 1;
-    else
+    } else {
         return 0;
+    }
 }
 
-void func_8002F698(GlobalContext* globalCtx, u32 arg1, f32 arg2, s16 arg3, f32 arg4, u32 arg5, u32 arg6)
-{
+void func_8002F698(GlobalContext* globalCtx, u32 arg1, f32 arg2, s16 arg3, f32 arg4, u32 arg5, u32 arg6) {
     Player* player = PLAYER;
     player->unk_8A0 = arg6;
     player->unk_8A1 = arg5;
@@ -1866,97 +1672,84 @@ void func_8002F698(GlobalContext* globalCtx, u32 arg1, f32 arg2, s16 arg3, f32 a
     player->unk_8A8 = arg4;
 }
 
-void func_8002F6D4(GlobalContext* globalCtx, u32 arg1, f32 arg2, s16 arg3, f32 arg4, u32 arg5)
-{
+void func_8002F6D4(GlobalContext* globalCtx, u32 arg1, f32 arg2, s16 arg3, f32 arg4, u32 arg5) {
     func_8002F698(globalCtx, arg1, arg2, arg3, arg4, 2, arg5);
 }
 
-void func_8002F71C(GlobalContext* globalCtx, u32 arg1, f32 arg2, s16 arg3, f32 arg4)
-{
+void func_8002F71C(GlobalContext* globalCtx, u32 arg1, f32 arg2, s16 arg3, f32 arg4) {
     func_8002F6D4(globalCtx, arg1, arg2, arg3, arg4, 0);
 }
 
-void func_8002F758(GlobalContext* globalCtx, u32 arg1, f32 arg2, s16 arg3, f32 arg4, u32 arg5)
-{
+void func_8002F758(GlobalContext* globalCtx, u32 arg1, f32 arg2, s16 arg3, f32 arg4, u32 arg5) {
     func_8002F698(globalCtx, arg1, arg2, arg3, arg4, 1, arg5);
 }
 
-void func_8002F7A0(GlobalContext* globalCtx, u32 arg1, f32 arg2, s16 arg3, f32 arg4)
-{
+void func_8002F7A0(GlobalContext* globalCtx, u32 arg1, f32 arg2, s16 arg3, f32 arg4) {
     func_8002F758(globalCtx, arg1, arg2, arg3, arg4, 0);
 }
 
-void func_8002F7DC(Actor* actor, u16 sfxId)
-{
+void func_8002F7DC(Actor* actor, u16 sfxId) {
     Audio_PlaySoundGeneral(sfxId, &actor->unk_E4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
 }
 
-void Audio_PlayActorSound2(Actor* actor, u16 sfxId)
-{
+void Audio_PlayActorSound2(Actor* actor, u16 sfxId) {
     func_80078914(&actor->unk_E4, sfxId);
 }
 
-void func_8002F850(GlobalContext* globalCtx, Actor* actor)
-{
+void func_8002F850(GlobalContext* globalCtx, Actor* actor) {
     s32 sfxId;
 
-    if (actor->bgCheckFlags & 0x20)
-    {
-        if (actor->unk_84 < 20.0f)
+    if (actor->bgCheckFlags & 0x20) {
+        if (actor->unk_84 < 20.0f) {
             sfxId = NA_SE_PL_WALK_WATER0;
-        else
+        } else {
             sfxId = NA_SE_PL_WALK_WATER1;
-    }
-    else
+        }
+    } else {
         sfxId = func_80041F34(&globalCtx->colCtx, actor->floorPoly, actor->floorPolySource, actor);
+    }
 
     func_80078914(&actor->unk_E4, NA_SE_EV_BOMB_BOUND);
     func_80078914(&actor->unk_E4, sfxId + 0x800);
 }
 
-void func_8002F8F0(Actor* actor, u16 sfxId)
-{
+void func_8002F8F0(Actor* actor, u16 sfxId) {
     actor->soundEffect = sfxId;
     actor->flags |= 0x80000;
     actor->flags &= ~0x10300000;
 }
 
-void func_8002F91C(Actor* actor, u16 sfxId)
-{
+void func_8002F91C(Actor* actor, u16 sfxId) {
     actor->soundEffect = sfxId;
     actor->flags |= 0x100000;
     actor->flags &= ~0x10280000;
 }
 
-void func_8002F948(Actor* actor, u16 sfxId)
-{
+void func_8002F948(Actor* actor, u16 sfxId) {
     actor->soundEffect = sfxId;
     actor->flags |= 0x200000;
     actor->flags &= ~0x10180000;
 }
 
-void func_8002F974(Actor* actor, u16 sfxId)
-{
+void func_8002F974(Actor* actor, u16 sfxId) {
     actor->flags &= ~0x10380000;
     actor->soundEffect = sfxId;
 }
 
-void func_8002F994(Actor* actor, s32 sfxId)
-{
+void func_8002F994(Actor* actor, s32 sfxId) {
     actor->flags |= 0x10000000;
     actor->flags &= ~0x00380000;
-    if (sfxId < NA_SE_PL_LAND_GRASS)
+    if (sfxId < NA_SE_PL_LAND_GRASS) {
         actor->soundEffect = NA_SE_PL_WALK_DIRT;
-    else if (sfxId < NA_SE_PL_DIVE_BUBBLE)
+    } else if (sfxId < NA_SE_PL_DIVE_BUBBLE) {
         actor->soundEffect = NA_SE_PL_WALK_CONCRETE;
-    else
+    } else {
         actor->soundEffect = NA_SE_PL_WALK_SAND;
+    }
 }
 
-s32 func_8002F9EC(GlobalContext* globalCtx, Actor* actor, UNK_TYPE arg2, UNK_TYPE arg3, UNK_TYPE arg4)
-{
-    if (func_80041D4C(&globalCtx->colCtx, arg2, arg3) == 8)
-    {
+s32 func_8002F9EC(GlobalContext* globalCtx, Actor* actor, UNK_TYPE arg2, UNK_TYPE arg3, UNK_TYPE arg4) {
+    if (func_80041D4C(&globalCtx->colCtx, arg2, arg3) == 8) {
         globalCtx->unk_11D30[0] = 1;
         func_8005DFAC(globalCtx, 0, arg4);
         Audio_PlayActorSound2(actor, NA_SE_IT_WALL_HIT_BUYO);
@@ -1972,12 +1765,10 @@ z_Light* D_8015BC10;
 s32 D_8015BC14;
 f32 D_8015BC18;
 
-void func_8002FA60(GlobalContext* globalCtx)
-{
+void func_8002FA60(GlobalContext* globalCtx) {
     Vec3f lightPos;
 
-    if (gSaveContext.fw.set)
-    {
+    if (gSaveContext.fw.set) {
         gSaveContext.respawn[RESPAWN_MODE_TOP].data = 0x28;
         gSaveContext.respawn[RESPAWN_MODE_TOP].pos.x = gSaveContext.fw.pos_x;
         gSaveContext.respawn[RESPAWN_MODE_TOP].pos.y = gSaveContext.fw.pos_y;
@@ -1988,9 +1779,7 @@ void func_8002FA60(GlobalContext* globalCtx)
         gSaveContext.respawn[RESPAWN_MODE_TOP].room_index = gSaveContext.fw.room_index;
         gSaveContext.respawn[RESPAWN_MODE_TOP].temp_swch_flags = gSaveContext.fw.temp_swch_flags;
         gSaveContext.respawn[RESPAWN_MODE_TOP].temp_collect_flags = gSaveContext.fw.temp_collect_flags;
-    }
-    else
-    {
+    } else {
         gSaveContext.respawn[RESPAWN_MODE_TOP].data = 0;
         gSaveContext.respawn[RESPAWN_MODE_TOP].pos.x = 0.0f;
         gSaveContext.respawn[RESPAWN_MODE_TOP].pos.y = 0.0f;
@@ -2014,15 +1803,16 @@ Color_RGB8 D_80116060 = { 0xFF, 0xFF, 0xFF };
 Color_RGB8 D_80116064 = { 0x64, 0xC8, 0x00 };
 
 #ifdef NON_MATCHING
-// this function still needs a lot of work
-void func_8002FBAC(GlobalContext* globalCtx)
-{
+// saved register, stack usage and minor ordering differences
+// this also doesn't generate a few useless struct copies
+void func_8002FBAC(GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[6];
+    Gfx* dispRefs[6];
     Vec3f lightPos;
     f32 spD8;
     f32 spD4;
     s32 spD0;
+    s32 spCC;
     f32 spC0;
     Vec3f spB4;
     Vec3f spA4;
@@ -2040,57 +1830,53 @@ void func_8002FBAC(GlobalContext* globalCtx)
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 5308);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 5308);
 
-    if (gSaveContext.respawn[RESPAWN_MODE_TOP].data != 0)
-    {
-        if (LINK_IS_ADULT)
+    if (gSaveContext.respawn[RESPAWN_MODE_TOP].data != 0) {
+        if (LINK_IS_ADULT) {
             spD8 = 80.0f;
-        else
+        } else {
             spD8 = 60.0f;
+        }
 
         spD0 = 0xFF;
         spD4 = 1.0f;
 
         temp_a3 = gSaveContext.respawn[RESPAWN_MODE_TOP].data - 0x28;
+        spCC = temp_a3;
 
-        if (temp_a3 < 0)
-        {
+        if (temp_a3 < 0) {
             gSaveContext.respawn[RESPAWN_MODE_TOP].data++;
             spD4 = ABS(gSaveContext.respawn[RESPAWN_MODE_TOP].data) * 0.025f;
             D_8015BC14 = 60;
             D_8015BC18 = 1.0f;
-        }
-        else if (D_8015BC14 != 0)
-        {
+        } else if (D_8015BC14 != 0) {
             D_8015BC14--;
-        }
-        else if (D_8015BC18 > 0.0f)
-        {
+        } else if (D_8015BC18 > 0.0f) {
             spC0 = D_8015BC18;
             temp_ret = Math_Vec3f_DistXYZAndStoreDiff(&gSaveContext.respawn[RESPAWN_MODE_DOWN].pos,
-                                     &gSaveContext.respawn[RESPAWN_MODE_TOP].pos,
-                                     &spB4);
+                                                      &gSaveContext.respawn[RESPAWN_MODE_TOP].pos, &spB4);
 
-            if (temp_ret < 20.0f)
-            {
+            if (temp_ret < 20.0f) {
                 D_8015BC18 = 0.0f;
-                Math_Vec3f_Copy(&gSaveContext.respawn[RESPAWN_MODE_TOP].pos, &gSaveContext.respawn[RESPAWN_MODE_DOWN].pos);
-            }
-            else
-            {
+                Math_Vec3f_Copy(&gSaveContext.respawn[RESPAWN_MODE_TOP].pos,
+                                &gSaveContext.respawn[RESPAWN_MODE_DOWN].pos);
+            } else {
                 sp9C = (1.0f / D_8015BC18) * temp_ret;
                 phi_f14 = 20.0f / sp9C;
                 phi_f14 = (phi_f14 < 0.05f) ? 0.05f : phi_f14;
                 Math_ApproxF(&D_8015BC18, 0.0f, phi_f14);
                 temp_f2 = ((D_8015BC18 / spC0) * temp_ret) / temp_ret;
-                gSaveContext.respawn[RESPAWN_MODE_TOP].pos.x = gSaveContext.respawn[RESPAWN_MODE_DOWN].pos.x + (spB4.x * temp_f2);
-                gSaveContext.respawn[RESPAWN_MODE_TOP].pos.y = gSaveContext.respawn[RESPAWN_MODE_DOWN].pos.y + (spB4.y * temp_f2);
-                gSaveContext.respawn[RESPAWN_MODE_TOP].pos.z = gSaveContext.respawn[RESPAWN_MODE_DOWN].pos.z + (spB4.z * temp_f2);
+                gSaveContext.respawn[RESPAWN_MODE_TOP].pos.x =
+                    gSaveContext.respawn[RESPAWN_MODE_DOWN].pos.x + (spB4.x * temp_f2);
+                gSaveContext.respawn[RESPAWN_MODE_TOP].pos.y =
+                    gSaveContext.respawn[RESPAWN_MODE_DOWN].pos.y + (spB4.y * temp_f2);
+                gSaveContext.respawn[RESPAWN_MODE_TOP].pos.z =
+                    gSaveContext.respawn[RESPAWN_MODE_DOWN].pos.z + (spB4.z * temp_f2);
                 temp_f12 = sp9C * 0.5f;
                 temp_f14 = temp_ret - temp_f12;
                 spD8 += sqrtf((temp_f12 * temp_f12) - (temp_f14 * temp_f14)) * 0.2f;
-                osSyncPrintf("-------- DISPLAY Y=%f\n", (f64)spD8);
+                osSyncPrintf("-------- DISPLAY Y=%f\n", spD8);
             }
 
             spA4.x = Math_Rand_CenteredFloat(6.0f) + gSaveContext.respawn[RESPAWN_MODE_TOP].pos.x;
@@ -2099,21 +1885,18 @@ void func_8002FBAC(GlobalContext* globalCtx)
 
             func_80028BB0(globalCtx, &spA4, &D_80116048, &D_80116054, &D_80116060, &D_80116064, 1000, 0x10);
 
-            if (D_8015BC18 == 0.0f)
-            {
+            if (D_8015BC18 == 0.0f) {
                 gSaveContext.respawn[RESPAWN_MODE_TOP] = gSaveContext.respawn[RESPAWN_MODE_DOWN];
                 gSaveContext.respawn[RESPAWN_MODE_TOP].player_params = 0x06FF;
                 gSaveContext.respawn[RESPAWN_MODE_TOP].data = 0x28;
             }
 
+            // somehow this shouldn't be optimized out
             gSaveContext.respawn[RESPAWN_MODE_TOP].pos = gSaveContext.respawn[RESPAWN_MODE_TOP].pos;
-        }
-        else if (temp_a3 > 0)
-        {
+        } else if (temp_a3 > 0) {
             temp_f12 = temp_a3 * 0.1f;
 
-            if (temp_f12 < 1.0f)
-            {
+            if (temp_f12 < 1.0f) {
                 sp7C.x = globalCtx->view.eye.x;
                 sp7C.y = globalCtx->view.eye.y - spD8;
                 sp7C.z = globalCtx->view.eye.z;
@@ -2129,49 +1912,46 @@ void func_8002FBAC(GlobalContext* globalCtx)
 
             spD0 = 0xFF - (((temp_a3 * 0x10) - temp_a3) * 2);
 
-            if (spD0 < 0)
-            {
+            if (spD0 < 0) {
                 gSaveContext.fw.set = 0;
                 gSaveContext.respawn[RESPAWN_MODE_TOP].data = 0;
                 spD0 = 0;
-            }
-            else
-            {
+            } else {
                 gSaveContext.respawn[RESPAWN_MODE_TOP].data++;
             }
 
-            spD4 = temp_a3 * 0.200000000000000011102230246252 + 1.0f;
+            spD4 = spCC * 0.200000000000000011102230246252 + 1.0f;
         }
 
         if ((globalCtx->csCtx.state == 0) &&
             (gSaveContext.respawn[RESPAWN_MODE_TOP].entrance_index == gSaveContext.entrance_index) &&
-            (globalCtx->roomCtx.curRoom.num == gSaveContext.respawn[RESPAWN_MODE_TOP].room_index))
-        {
-            gfxCtx->polyXlu.p = func_80093774(gfxCtx->polyXlu.p, 0x19);
+            (globalCtx->roomCtx.curRoom.num == gSaveContext.respawn[RESPAWN_MODE_TOP].room_index)) {
+            gfxCtx->polyXlu.p = Gfx_CallSetupDL(gfxCtx->polyXlu.p, 0x19);
 
             Matrix_Translate(gSaveContext.respawn[RESPAWN_MODE_TOP].pos.x,
                              gSaveContext.respawn[RESPAWN_MODE_TOP].pos.y + spD8,
-                             gSaveContext.respawn[RESPAWN_MODE_TOP].pos.z,
-                             MTXMODE_NEW);
+                             gSaveContext.respawn[RESPAWN_MODE_TOP].pos.z, MTXMODE_NEW);
             Matrix_Scale(0.025f * spD4, 0.025f * spD4, 0.025f * spD4, MTXMODE_APPLY);
             Matrix_Mult(&globalCtx->mf_11D60, MTXMODE_APPLY);
             Matrix_Push();
 
             gDPPipeSync(gfxCtx->polyXlu.p++);
-            gDPSetPrimColor(gfxCtx->polyXlu.p++, 0x80, 0x80,  0xFF, 0xFF, 0xC8, spD0);
+            gDPSetPrimColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0xFF, 0xFF, 0xC8, spD0);
             gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x64, 0xC8, 0x00, 0xFF);
 
             phi_f10 = (globalCtx->gameplayFrames * 1500) & 0xFFFF;
             Matrix_RotateZ((phi_f10 * M_PI) / 32768.0f, MTXMODE_APPLY);
 
-            gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_actor.c", 5458), G_MTX_MODELVIEW | G_MTX_LOAD);
+            gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_actor.c", 5458),
+                      G_MTX_MODELVIEW | G_MTX_LOAD);
             gSPDisplayList(gfxCtx->polyXlu.p++, &D_04010130);
 
             Matrix_Pull();
             phi_f6 = ~((globalCtx->gameplayFrames * 1200) & 0xFFFF);
             Matrix_RotateZ((phi_f6 * M_PI) / 32768.0f, MTXMODE_APPLY);
 
-            gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_actor.c", 5463), G_MTX_MODELVIEW | G_MTX_LOAD);
+            gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_actor.c", 5463),
+                      G_MTX_MODELVIEW | G_MTX_LOAD);
             gSPDisplayList(gfxCtx->polyXlu.p++, &D_04010130);
         }
 
@@ -2179,31 +1959,28 @@ void func_8002FBAC(GlobalContext* globalCtx)
         lightPos.y = gSaveContext.respawn[RESPAWN_MODE_TOP].pos.y + spD8;
         lightPos.z = gSaveContext.respawn[RESPAWN_MODE_TOP].pos.z;
 
-        Lights_InitType0PositionalLight(&D_8015BC00, lightPos.x, lightPos.y, lightPos.z, 0xFF, 0xFF, 0xFF, 500.0f * spD4);
+        Lights_InitType0PositionalLight(&D_8015BC00, lightPos.x, lightPos.y, lightPos.z, 0xFF, 0xFF, 0xFF,
+                                        500.0f * spD4);
 
-        func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 5474);
+        Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 5474);
     }
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_actor/func_8002FBAC.s")
 #endif
 
-void func_80030488(GlobalContext* globalCtx)
-{
+void func_80030488(GlobalContext* globalCtx) {
     Lights_Remove(globalCtx, &globalCtx->lightCtx, D_8015BC10);
 }
 
-void func_800304B0(GlobalContext* globalCtx)
-{
-    if (globalCtx->actorCtx.unk_03 != 0)
-    {
+void func_800304B0(GlobalContext* globalCtx) {
+    if (globalCtx->actorCtx.unk_03 != 0) {
         globalCtx->actorCtx.unk_03 = 0;
         func_800876C8(globalCtx);
     }
 }
 
-void func_800304DC(GlobalContext* globalCtx, ActorContext* actorCtx, ActorEntry* actorEntry)
-{
+void func_800304DC(GlobalContext* globalCtx, ActorContext* actorCtx, ActorEntry* actorEntry) {
     ActorOverlay* overlayEntry;
     SaveSceneFlags* saveSceneFlags;
     s32 i;
@@ -2217,8 +1994,7 @@ void func_800304DC(GlobalContext* globalCtx, ActorContext* actorCtx, ActorEntry*
     Matrix_MtxFCopy(&globalCtx->mf_11D60, &gMtxFClear);
 
     overlayEntry = &gActorOverlayTable[0];
-    for (i = 0; i < ARRAY_COUNT(gActorOverlayTable); i++)
-    {
+    for (i = 0; i < ARRAY_COUNT(gActorOverlayTable); i++) {
         overlayEntry->loadedRamAddr = NULL;
         overlayEntry->nbLoaded = 0;
         overlayEntry++;
@@ -2238,24 +2014,12 @@ void func_800304DC(GlobalContext* globalCtx, ActorContext* actorCtx, ActorEntry*
     func_8002FA60(globalCtx);
 }
 
-u32 D_80116068[] =
-{
-    0x100000C0,
-    0x100000C0,
-    0x00000000,
-    0x100004C0,
-    0x00000080,
-    0x300000C0,
-    0x10000080,
-    0x00000000,
-    0x300000C0,
-    0x100004C0,
-    0x00000000,
-    0x100000C0,
+u32 D_80116068[] = {
+    0x100000C0, 0x100000C0, 0x00000000, 0x100004C0, 0x00000080, 0x300000C0,
+    0x10000080, 0x00000000, 0x300000C0, 0x100004C0, 0x00000000, 0x100000C0,
 };
 
-void Actor_UpdateAll(GlobalContext* globalCtx, ActorContext* actorCtx)
-{
+void Actor_UpdateAll(GlobalContext* globalCtx, ActorContext* actorCtx) {
     Actor* refActor;
     Actor* actor;
     Player* player;
@@ -2268,91 +2032,79 @@ void Actor_UpdateAll(GlobalContext* globalCtx, ActorContext* actorCtx)
 
     player = PLAYER;
 
-    if (0)
-    {
+    if (0) {
         // This assert is optimized out but it exists due to its presence in rodata
-        if (gMaxProfile != ACTOR_DLF_MAX)
+        if (gMaxProfile != ACTOR_DLF_MAX) {
             __assert("MaxProfile == ACTOR_DLF_MAX", "../z_actor.c", UNK_LINE);
+        }
     }
 
     sp74 = NULL;
     unkFlag = 0;
 
-    if (globalCtx->nbSetupActors != 0)
-    {
+    if (globalCtx->nbSetupActors != 0) {
         actorEntry = &globalCtx->setupActorList[0];
-        for (i = 0; i < globalCtx->nbSetupActors; i++)
+        for (i = 0; i < globalCtx->nbSetupActors; i++) {
             Actor_SpawnEntry(&globalCtx->actorCtx, actorEntry++, globalCtx);
+        }
         globalCtx->nbSetupActors = 0;
     }
 
-    if (actorCtx->unk_02 != 0)
+    if (actorCtx->unk_02 != 0) {
         actorCtx->unk_02--;
+    }
 
-    if (KREG(0) == -100)
-    {
+    if (KREG(0) == -100) {
         refActor = &PLAYER->actor;
         KREG(0) = 0;
-        Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_CLEAR_TAG,
-                    refActor->posRot.pos.x, refActor->posRot.pos.y + 100.0f, refActor->posRot.pos.z,
-                    0, 0, 0, 1);
+        Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_CLEAR_TAG, refActor->posRot.pos.x,
+                    refActor->posRot.pos.y + 100.0f, refActor->posRot.pos.z, 0, 0, 0, 1);
     }
 
     sp80 = &D_80116068[0];
 
-    if (player->stateFlags2 & 0x8000000)
+    if (player->stateFlags2 & 0x8000000) {
         unkFlag = 0x2000000;
+    }
 
-    if ((player->stateFlags1 & 0x40) && ((player->actor.textId & 0xFF00) != 0x600))
+    if ((player->stateFlags1 & 0x40) && ((player->actor.textId & 0xFF00) != 0x600)) {
         sp74 = player->unk_694;
+    }
 
-    for (i = 0; i < ARRAY_COUNT(actorCtx->actorList); i++, sp80++)
-    {
+    for (i = 0; i < ARRAY_COUNT(actorCtx->actorList); i++, sp80++) {
         unkCondition = (*sp80 & player->stateFlags1);
 
         actor = actorCtx->actorList[i].first;
-        while (actor != NULL)
-        {
-            if (actor->posRot.pos.y < -25000.0f)
+        while (actor != NULL) {
+            if (actor->posRot.pos.y < -25000.0f) {
                 actor->posRot.pos.y = -25000.0f;
+            }
 
             actor->soundEffect = 0;
 
-            if (actor->init != NULL)
-            {
-                if (Object_IsLoaded(&globalCtx->objectCtx, actor->objBankIndex))
-                {
+            if (actor->init != NULL) {
+                if (Object_IsLoaded(&globalCtx->objectCtx, actor->objBankIndex)) {
                     Actor_SetObjectDependency(globalCtx, actor);
                     actor->init(actor, globalCtx);
                     actor->init = NULL;
                 }
                 actor = actor->next;
-            }
-            else if (!Object_IsLoaded(&globalCtx->objectCtx, actor->objBankIndex))
-            {
+            } else if (!Object_IsLoaded(&globalCtx->objectCtx, actor->objBankIndex)) {
                 Actor_Kill(actor);
                 actor = actor->next;
-            }
-            else if ((unkFlag && !(actor->flags & unkFlag)) ||
-                     (!unkFlag && unkCondition &&
-                      (sp74 != actor) && (actor != player->unk_68C) &&
-                      (actor != player->heldActor) && (&player->actor != actor->attachedA)))
-            {
+            } else if ((unkFlag && !(actor->flags & unkFlag)) ||
+                       (!unkFlag && unkCondition && (sp74 != actor) && (actor != player->unk_68C) &&
+                        (actor != player->heldActor) && (&player->actor != actor->attachedA))) {
                 func_80061E8C(&actor->sub_98);
                 actor = actor->next;
-            }
-            else if (actor->update == NULL)
-            {
-                if (!actor->activelyDrawn)
+            } else if (actor->update == NULL) {
+                if (!actor->activelyDrawn) {
                     actor = Actor_Delete(&globalCtx->actorCtx, actor, globalCtx);
-                else
-                {
+                } else {
                     Actor_Destroy(actor, globalCtx);
                     actor = actor->next;
                 }
-            }
-            else
-            {
+            } else {
                 Math_Vec3f_Copy(&actor->pos4, &actor->posRot.pos);
                 actor->xzDistanceFromLink = func_8002DB8C(actor, &player->actor);
                 actor->yDistanceFromLink = Actor_HeightDiff(actor, &player->actor);
@@ -2361,19 +2113,21 @@ void Actor_UpdateAll(GlobalContext* globalCtx, ActorContext* actorCtx)
                 actor->rotTowardsLinkY = func_8002DA78(actor, &player->actor);
                 actor->flags &= ~0x1000000;
 
-                if ((DECR(actor->freeze) == 0) && (actor->flags & 0x50))
-                {
-                    if (actor == player->unk_664)
+                if ((DECR(actor->freeze) == 0) && (actor->flags & 0x50)) {
+                    if (actor == player->unk_664) {
                         actor->unk_10C = 1;
-                    else
+                    } else {
                         actor->unk_10C = 0;
+                    }
 
-                    if ((actor->unk_10D != 0) && (player->unk_664 == NULL))
+                    if ((actor->unk_10D != 0) && (player->unk_664 == NULL)) {
                         actor->unk_10D = 0;
+                    }
 
                     Actor_SetObjectDependency(globalCtx, actor);
-                    if (actor->unk_114 != 0)
+                    if (actor->unk_114 != 0) {
                         actor->unk_114--;
+                    }
                     actor->update(actor, globalCtx);
                     func_8003F8EC(globalCtx, &globalCtx->colCtx.dyna, actor);
                 }
@@ -2384,23 +2138,21 @@ void Actor_UpdateAll(GlobalContext* globalCtx, ActorContext* actorCtx)
             }
         }
 
-        if (i == ACTORTYPE_BG)
+        if (i == ACTORTYPE_BG) {
             func_8003F984(globalCtx, &globalCtx->colCtx.dyna);
+        }
     }
 
     actor = player->unk_664;
 
-    if ((actor != NULL) && (actor->update == NULL))
-    {
+    if ((actor != NULL) && (actor->update == NULL)) {
         actor = NULL;
         func_8008EDF0(player);
     }
 
-    if ((actor == NULL) || (player->unk_66C < 5))
-    {
+    if ((actor == NULL) || (player->unk_66C < 5)) {
         actor = NULL;
-        if (actorCtx->targetCtx.unk_4B != 0)
-        {
+        if (actorCtx->targetCtx.unk_4B != 0) {
             actorCtx->targetCtx.unk_4B = 0;
             func_80078884(NA_SE_SY_LOCK_OFF);
         }
@@ -2411,13 +2163,11 @@ void Actor_UpdateAll(GlobalContext* globalCtx, ActorContext* actorCtx)
     func_8003FB64(globalCtx, &globalCtx->colCtx.dyna);
 }
 
-void Actor_FaultPrint(Actor* actor, char* command)
-{
+void Actor_FaultPrint(Actor* actor, char* command) {
     ActorOverlay* overlayEntry;
     char* name;
 
-    if ((actor == NULL) || (actor->overlayEntry == NULL))
-    {
+    if ((actor == NULL) || (actor->overlayEntry == NULL)) {
         FaultDrawer_SetCursor(48, 24);
         FaultDrawer_Printf("ACTOR NAME is NULL");
     }
@@ -2428,47 +2178,41 @@ void Actor_FaultPrint(Actor* actor, char* command)
     // Translates to: "ACTOR NAME(%08x:%s)"
     osSyncPrintf("アクターの名前(%08x:%s)\n", actor, name);
 
-    if (command != NULL)
+    if (command != NULL) {
         // Translates to: "COMMAND:%s"
         osSyncPrintf("コメント:%s\n", command);
+    }
 
     FaultDrawer_SetCursor(48, 24);
     FaultDrawer_Printf("ACTOR NAME %08x:%s", actor, name);
 }
 
-void Actor_Draw(GlobalContext* globalCtx, Actor* actor)
-{
+void Actor_Draw(GlobalContext* globalCtx, Actor* actor) {
     FaultClient faultClient;
     LightMapper* lightMapper;
     GraphicsContext* gfxCtx;
     Camera* camera;
-    Gfx* gfxArr[3];
+    Gfx* dispRefs[3];
 
     Fault_AddClient(&faultClient, Actor_FaultPrint, actor, "Actor_draw");
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 6035);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 6035);
 
     lightMapper = Lights_CreateMapper(&globalCtx->lightCtx, globalCtx->state.gfxCtx);
 
     func_8007A474(lightMapper, globalCtx->lightCtx.lightsHead, (actor->flags & 0x400000) ? NULL : &actor->posRot.pos);
     func_80079EFC(lightMapper, globalCtx->state.gfxCtx);
 
-    if (actor->flags & 0x1000)
-    {
+    if (actor->flags & 0x1000) {
         camera = &globalCtx->cameraCtx.activeCameras[0];
         func_800D1694(actor->posRot.pos.x + camera->unk_80.x,
-                           actor->posRot.pos.y + (f32)((actor->shape.unk_08 * actor->scale.y) + camera->unk_80.y),
-                           actor->posRot.pos.z + camera->unk_80.z,
-                           &actor->shape.rot);
-    }
-    else
-    {
-        func_800D1694(actor->posRot.pos.x,
-                           actor->posRot.pos.y + (actor->shape.unk_08 * actor->scale.y),
-                           actor->posRot.pos.z,
-                           &actor->shape.rot);
+                      actor->posRot.pos.y + (f32)((actor->shape.unk_08 * actor->scale.y) + camera->unk_80.y),
+                      actor->posRot.pos.z + camera->unk_80.z, &actor->shape.rot);
+    } else {
+        func_800D1694(actor->posRot.pos.x, actor->posRot.pos.y + (actor->shape.unk_08 * actor->scale.y),
+                      actor->posRot.pos.z, &actor->shape.rot);
     }
 
     Matrix_Scale(actor->scale.x, actor->scale.y, actor->scale.z, MTXMODE_APPLY);
@@ -2477,114 +2221,102 @@ void Actor_Draw(GlobalContext* globalCtx, Actor* actor)
     gSPSegment(gfxCtx->polyOpa.p++, 0x06, globalCtx->objectCtx.status[actor->objBankIndex].segment);
     gSPSegment(gfxCtx->polyXlu.p++, 0x06, globalCtx->objectCtx.status[actor->objBankIndex].segment);
 
-    if (actor->unk_114 != 0)
-    {
+    if (actor->unk_114 != 0) {
         // Must be inline data to match
         Color_RGBA8 sp2C = { 0x00, 0x00, 0x00, 0xFF };
-        if (actor->unk_112 & 0x8000)
+        if (actor->unk_112 & 0x8000) {
             sp2C.r = sp2C.g = sp2C.b = ((actor->unk_112 & 0x1F00) >> 5) | 7;
-        else if (actor->unk_112 & 0x4000)
+        } else if (actor->unk_112 & 0x4000) {
             sp2C.r = ((actor->unk_112 & 0x1F00) >> 5) | 7;
-        else
+        } else {
             sp2C.b = ((actor->unk_112 & 0x1F00) >> 5) | 7;
+        }
 
-        if (actor->unk_112 & 0x2000)
+        if (actor->unk_112 & 0x2000) {
             func_80026860(globalCtx, &sp2C, actor->unk_114, actor->unk_112 & 0xFF);
-        else
+        } else {
             func_80026400(globalCtx, &sp2C, actor->unk_114, actor->unk_112 & 0xFF);
+        }
     }
 
     actor->draw(actor, globalCtx);
 
-    if (actor->unk_114 != 0)
-    {
-        if (actor->unk_112 & 0x2000)
+    if (actor->unk_114 != 0) {
+        if (actor->unk_112 & 0x2000) {
             func_80026A6C(globalCtx);
-        else
+        } else {
             func_80026608(globalCtx);
+        }
     }
 
-    if (actor->shape.shadowDrawFunc != NULL)
+    if (actor->shape.shadowDrawFunc != NULL) {
         actor->shape.shadowDrawFunc(actor, lightMapper, globalCtx);
+    }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 6119);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 6119);
 
     Fault_RemoveClient(&faultClient);
 }
 
-void func_80030ED8(Actor* actor)
-{
-    if (actor->flags & 0x80000)
+void func_80030ED8(Actor* actor) {
+    if (actor->flags & 0x80000) {
         Audio_PlaySoundGeneral(actor->soundEffect, &actor->unk_E4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
-    else if (actor->flags & 0x100000)
+    } else if (actor->flags & 0x100000) {
         func_80078884(actor->soundEffect);
-    else if (actor->flags & 0x200000)
+    } else if (actor->flags & 0x200000) {
         func_800788CC(actor->soundEffect);
-    else if (actor->flags & 0x10000000)
+    } else if (actor->flags & 0x10000000) {
         func_800F4C58(&D_801333D4, 0x2021, (s8)(actor->soundEffect - 1));
-    else
+    } else {
         func_80078914(&actor->unk_E4, actor->soundEffect);
+    }
 }
 
-void func_80030FA8(GraphicsContext* gfxCtx)
-{
-    Gfx* gfxArr[5];
+void func_80030FA8(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_actor.c", 6161);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_actor.c", 6161);
 
-    gDPLoadTextureBlock(gfxCtx->polyXlu.p++,
-                        &D_0401E370,
-                        G_IM_FMT_I,
-                        G_IM_SIZ_8b,
-                        64, 64,
-                        0,
-                        G_TX_MIRROR | G_TX_CLAMP, G_TX_MIRROR | G_TX_CLAMP,
-                        6, 6,
-                        G_TX_NOLOD, G_TX_NOLOD);
+    gDPLoadTextureBlock(gfxCtx->polyXlu.p++, &D_0401E370, G_IM_FMT_I, G_IM_SIZ_8b, 64, 64, 0, G_TX_MIRROR | G_TX_CLAMP,
+                        G_TX_MIRROR | G_TX_CLAMP, 6, 6, G_TX_NOLOD, G_TX_NOLOD);
 
     gDPSetTileSize(gfxCtx->polyXlu.p++, G_TX_RENDERTILE, 384, 224, 892, 732);
     gSPTextureRectangle(gfxCtx->polyXlu.p++, 0, 0, 1280, 960, G_TX_RENDERTILE, 2240, 1600, 576, 597);
     gDPPipeSync(gfxCtx->polyXlu.p++);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_actor.c", 6183);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_actor.c", 6183);
 }
 
-void func_8003115C(GlobalContext* globalCtx, s32 nbInvisibleActors, Actor** invisibleActors)
-{
+void func_8003115C(GlobalContext* globalCtx, s32 nbInvisibleActors, Actor** invisibleActors) {
     Actor** invisibleActor;
     GraphicsContext* gfxCtx;
     s32 i;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_actor.c", 6197);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_actor.c", 6197);
 
     // Translates to: "MAGIC LENS START"
-    gDma1p(gfxCtx->polyOpa.p++, G_NOOP, "魔法のメガネ START", 0, 2);
+    gDPNoOpString(gfxCtx->polyOpa.p++, "魔法のメガネ START", 0);
 
     gDPPipeSync(gfxCtx->polyXlu.p++);
 
-    if (globalCtx->roomCtx.curRoom.showInvisActors  == 0)
-    {
+    if (globalCtx->roomCtx.curRoom.showInvisActors == 0) {
         gDPSetOtherMode(gfxCtx->polyXlu.p++,
-                        G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP |
-                        G_TT_NONE | G_TL_TILE | G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                        G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                            G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
                         G_AC_THRESHOLD | G_ZS_PRIM | Z_UPD | G_RM_CLD_SURF | G_RM_CLD_SURF2);
         gDPSetCombineMode(gfxCtx->polyXlu.p++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
         gDPSetPrimColor(gfxCtx->polyXlu.p++, 0, 0, 0xFF, 0x00, 0x00, 0xFF);
-    }
-    else
-    {
+    } else {
         gDPSetOtherMode(gfxCtx->polyXlu.p++,
-                        G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP |
-                        G_TT_NONE | G_TL_TILE | G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
-                        G_AC_THRESHOLD | G_ZS_PRIM | Z_UPD |
-                        IM_RD | CVG_DST_SAVE | ZMODE_OPA | FORCE_BL |
-                        GBL_c1(G_BL_CLR_BL, G_BL_0, G_BL_CLR_MEM, G_BL_1MA) |
-                        GBL_c2(G_BL_CLR_BL, G_BL_0, G_BL_CLR_MEM, G_BL_1MA));
-        gDPSetCombineLERP(gfxCtx->polyXlu.p++,
-                          PRIMITIVE, TEXEL0, PRIM_LOD_FRAC, 0, PRIMITIVE, TEXEL0, PRIM_LOD_FRAC, 0,
+                        G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                            G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                        G_AC_THRESHOLD | G_ZS_PRIM | Z_UPD | IM_RD | CVG_DST_SAVE | ZMODE_OPA | FORCE_BL |
+                            GBL_c1(G_BL_CLR_BL, G_BL_0, G_BL_CLR_MEM, G_BL_1MA) |
+                            GBL_c2(G_BL_CLR_BL, G_BL_0, G_BL_CLR_MEM, G_BL_1MA));
+        gDPSetCombineLERP(gfxCtx->polyXlu.p++, PRIMITIVE, TEXEL0, PRIM_LOD_FRAC, 0, PRIMITIVE, TEXEL0, PRIM_LOD_FRAC, 0,
                           PRIMITIVE, TEXEL0, PRIM_LOD_FRAC, 0, PRIMITIVE, TEXEL0, PRIM_LOD_FRAC, 0);
         gDPSetPrimColor(gfxCtx->polyXlu.p++, 0, 0xFF, 0x4A, 0x4A, 0x4A, 0x4A);
     }
@@ -2594,29 +2326,27 @@ void func_8003115C(GlobalContext* globalCtx, s32 nbInvisibleActors, Actor** invi
     func_80030FA8(gfxCtx);
 
     // Translates to: "MAGIC LENS INVISIBLE ACTOR DISPLAY START"
-    gDma1p(gfxCtx->polyOpa.p++, G_NOOP, "魔法のメガネ 見えないＡcｔｏｒ表示 START", nbInvisibleActors, 2);
+    gDPNoOpString(gfxCtx->polyOpa.p++, "魔法のメガネ 見えないＡcｔｏｒ表示 START", nbInvisibleActors);
 
     invisibleActor = &invisibleActors[0];
-    for (i = 0; i < nbInvisibleActors; i++)
-    {
+    for (i = 0; i < nbInvisibleActors; i++) {
         // Translates to: "MAGIC LENS INVISIBLE ACTOR DISPLAY"
-        gDma1p(gfxCtx->polyOpa.p++, G_NOOP, "魔法のメガネ 見えないＡcｔｏｒ表示", i, 2);
+        gDPNoOpString(gfxCtx->polyOpa.p++, "魔法のメガネ 見えないＡcｔｏｒ表示", i);
         Actor_Draw(globalCtx, *(invisibleActor++));
     }
 
     // Translates to: "MAGIC LENS INVISIBLE ACTOR DISPLAY END"
-    gDma1p(gfxCtx->polyOpa.p++, G_NOOP, "魔法のメガネ 見えないＡcｔｏｒ表示 END", nbInvisibleActors, 2);
+    gDPNoOpString(gfxCtx->polyOpa.p++, "魔法のメガネ 見えないＡcｔｏｒ表示 END", nbInvisibleActors);
 
-    if (globalCtx->roomCtx.curRoom.showInvisActors != 0)
-    {
+    if (globalCtx->roomCtx.curRoom.showInvisActors != 0) {
         // Translates to: "BLUE SPECTACLES (EXTERIOR)"
-        gDma1p(gfxCtx->polyOpa.p++, G_NOOP, "青い眼鏡(外側)", 0, 2);
+        gDPNoOpString(gfxCtx->polyOpa.p++, "青い眼鏡(外側)", 0);
 
         gDPPipeSync(gfxCtx->polyXlu.p++);
 
         gDPSetOtherMode(gfxCtx->polyXlu.p++,
-                        G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP |
-                        G_TT_NONE | G_TL_TILE | G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                        G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                            G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
                         G_AC_THRESHOLD | G_ZS_PRIM | G_RM_CLD_SURF | G_RM_CLD_SURF2);
         gDPSetCombineMode(gfxCtx->polyXlu.p++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
         gDPSetPrimColor(gfxCtx->polyXlu.p++, 0, 0, 0xFF, 0x00, 0x00, 0xFF);
@@ -2624,118 +2354,95 @@ void func_8003115C(GlobalContext* globalCtx, s32 nbInvisibleActors, Actor** invi
         func_80030FA8(gfxCtx);
 
         // Translates to: "BLUE SPECTACLES (EXTERIOR)"
-        gDma1p(gfxCtx->polyOpa.p++, G_NOOP, "青い眼鏡(外側)", 1, 2);
+        gDPNoOpString(gfxCtx->polyOpa.p++, "青い眼鏡(外側)", 1);
     }
 
     // Translates to: "MAGIC LENS END"
-    gDma1p(gfxCtx->polyOpa.p++, G_NOOP, "魔法のメガネ END", 0, 2);
+    gDPNoOpString(gfxCtx->polyOpa.p++, "魔法のメガネ END", 0);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_actor.c", 6284);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_actor.c", 6284);
 }
 
-s32 func_800314B0(GlobalContext* globalCtx, Actor* actor)
-{
+s32 func_800314B0(GlobalContext* globalCtx, Actor* actor) {
     return func_800314D4(globalCtx, actor, &actor->unk_E4, actor->unk_F0);
 }
 
-s32 func_800314D4(GlobalContext* globalCtx, Actor* actor, Vec3f* arg2, f32 arg3)
-{
+s32 func_800314D4(GlobalContext* globalCtx, Actor* actor, Vec3f* arg2, f32 arg3) {
     f32 var;
 
-    if ((arg2->z > -actor->unk_F8) && (arg2->z < (actor->unk_F4 + actor->unk_F8)))
-    {
+    if ((arg2->z > -actor->unk_F8) && (arg2->z < (actor->unk_F4 + actor->unk_F8))) {
         var = (arg3 < 1.0f) ? 1.0f : 1.0f / arg3;
 
-        if ((((fabsf(arg2->x) - actor->unk_F8) * var) < 1.0f) &&
-            (((arg2->y + actor->unk_FC) * var) > -1.0f) &&
-            (((arg2->y - actor->unk_F8) * var) < 1.0f))
+        if ((((fabsf(arg2->x) - actor->unk_F8) * var) < 1.0f) && (((arg2->y + actor->unk_FC) * var) > -1.0f) &&
+            (((arg2->y - actor->unk_F8) * var) < 1.0f)) {
             return 1;
+        }
     }
 
     return 0;
 }
 
-void func_800315AC(GlobalContext* globalCtx, ActorContext* actorCtx)
-{
+void func_800315AC(GlobalContext* globalCtx, ActorContext* actorCtx) {
     s32 invisibleActorCounter;
     Actor* invisibleActors[INVISIBLE_ACTOR_MAX];
     ActorListEntry* actorListEntry;
     GraphicsContext* gfxCtx;
     s32 i;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
     Actor* actor;
     ActorOverlay* overlayEntry;
     char* actorName;
 
-    gfxCtx  = globalCtx->state.gfxCtx;
+    gfxCtx = globalCtx->state.gfxCtx;
     invisibleActorCounter = 0;
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 6336);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 6336);
 
     actorListEntry = &actorCtx->actorList[0];
 
-    for (i = 0; i < ARRAY_COUNT(actorCtx->actorList); i++, actorListEntry++)
-    {
+    for (i = 0; i < ARRAY_COUNT(actorCtx->actorList); i++, actorListEntry++) {
         actor = actorListEntry->first;
-        while (actor != NULL)
-        {
+        while (actor != NULL) {
             overlayEntry = actor->overlayEntry;
             actorName = overlayEntry->name != NULL ? overlayEntry->name : "";
 
-            gDma1p(gfxCtx->polyOpa.p++, G_NOOP, actorName, i, 2);
-            gDma1p(gfxCtx->polyXlu.p++, G_NOOP, actorName, i, 2);
+            gDPNoOpString(gfxCtx->polyOpa.p++, actorName, i);
+            gDPNoOpString(gfxCtx->polyXlu.p++, actorName, i);
 
             HREG(66) = i;
 
-            if ((HREG(64) != 1) ||
-                ((HREG(65) != -1) && (HREG(65) != HREG(66))) ||
-                (HREG(68) == 0))
-            {
+            if ((HREG(64) != 1) || ((HREG(65) != -1) && (HREG(65) != HREG(66))) || (HREG(68) == 0)) {
                 func_800A6E10(&globalCtx->mf_11D60, &actor->posRot.pos, &actor->unk_E4, &actor->unk_F0);
             }
 
-            if ((HREG(64) != 1) ||
-                ((HREG(65) != -1) && (HREG(65) != HREG(66))) ||
-                (HREG(69) == 0))
-            {
-                if (actor->soundEffect != 0)
+            if ((HREG(64) != 1) || ((HREG(65) != -1) && (HREG(65) != HREG(66))) || (HREG(69) == 0)) {
+                if (actor->soundEffect != 0) {
                     func_80030ED8(actor);
+                }
             }
 
-            if ((HREG(64) != 1) ||
-                ((HREG(65) != -1) && (HREG(65) != HREG(66))) ||
-                (HREG(70) == 0))
-            {
-                if (func_800314B0(globalCtx, actor))
+            if ((HREG(64) != 1) || ((HREG(65) != -1) && (HREG(65) != HREG(66))) || (HREG(70) == 0)) {
+                if (func_800314B0(globalCtx, actor)) {
                     actor->flags |= 0x40;
-                else
+                } else {
                     actor->flags &= ~0x40;
+                }
             }
 
             actor->activelyDrawn = 0;
 
-            if ((HREG(64) != 1) ||
-                ((HREG(65) != -1) && (HREG(65) != HREG(66))) ||
-                (HREG(71) == 0))
-            {
-                if ((actor->init == NULL) && (actor->draw != NULL) && (actor->flags & 0x60))
-                {
+            if ((HREG(64) != 1) || ((HREG(65) != -1) && (HREG(65) != HREG(66))) || (HREG(71) == 0)) {
+                if ((actor->init == NULL) && (actor->draw != NULL) && (actor->flags & 0x60)) {
                     if ((actor->flags & 0x80) &&
-                        ((globalCtx->roomCtx.curRoom.showInvisActors == 0) ||
-                         (globalCtx->actorCtx.unk_03 != 0) ||
-                         (actor->room != globalCtx->roomCtx.curRoom.num)))
-                    {
-                        if (invisibleActorCounter >= INVISIBLE_ACTOR_MAX)
+                        ((globalCtx->roomCtx.curRoom.showInvisActors == 0) || (globalCtx->actorCtx.unk_03 != 0) ||
+                         (actor->room != globalCtx->roomCtx.curRoom.num))) {
+                        if (invisibleActorCounter >= INVISIBLE_ACTOR_MAX) {
                             __assert("invisible_actor_counter < INVISIBLE_ACTOR_MAX", "../z_actor.c", 6464);
+                        }
                         invisibleActors[invisibleActorCounter] = actor;
                         invisibleActorCounter++;
-                    }
-                    else
-                    {
-                        if ((HREG(64) != 1) ||
-                            ((HREG(65) != -1) && (HREG(65) != HREG(66))) ||
-                            (HREG(72) == 0))
-                        {
+                    } else {
+                        if ((HREG(64) != 1) || ((HREG(65) != -1) && (HREG(65) != HREG(66))) || (HREG(72) == 0)) {
                             Actor_Draw(globalCtx, actor);
                             actor->activelyDrawn = 1;
                         }
@@ -2747,48 +2454,50 @@ void func_800315AC(GlobalContext* globalCtx, ActorContext* actorCtx)
         }
     }
 
-    if ((HREG(64) != 1) || (HREG(73) != 0))
+    if ((HREG(64) != 1) || (HREG(73) != 0)) {
         func_80026E74(globalCtx->state.gfxCtx);
+    }
 
-    if ((HREG(64) != 1) || (HREG(74) != 0))
+    if ((HREG(64) != 1) || (HREG(74) != 0)) {
         func_80027BDC(globalCtx);
+    }
 
-    if ((HREG(64) != 1) || (HREG(72) != 0))
-    {
-        if (globalCtx->actorCtx.unk_03 != 0)
-        {
+    if ((HREG(64) != 1) || (HREG(72) != 0)) {
+        if (globalCtx->actorCtx.unk_03 != 0) {
             func_8003115C(globalCtx, invisibleActorCounter, invisibleActors);
-            if ((globalCtx->csCtx.state != 0) || func_8008E988(globalCtx))
+            if ((globalCtx->csCtx.state != 0) || func_8008E988(globalCtx)) {
                 func_800304B0(globalCtx);
+            }
         }
     }
 
     func_8002FBAC(globalCtx);
 
-    if (IREG(32) == 0)
+    if (IREG(32) == 0) {
         func_8007ABBC(globalCtx);
+    }
 
-    if ((HREG(64) != 1) || (HREG(75) != 0))
+    if ((HREG(64) != 1) || (HREG(75) != 0)) {
         TitleCard_Draw(globalCtx, &actorCtx->titleCtx);
+    }
 
-    if ((HREG(64) != 1) || (HREG(76) != 0))
+    if ((HREG(64) != 1) || (HREG(76) != 0)) {
         func_8005D62C(globalCtx, &globalCtx->sub_11E60);
+    }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 6563);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 6563);
 }
 
-void func_80031A28(GlobalContext* globalCtx, ActorContext* actorCtx)
-{
+void func_80031A28(GlobalContext* globalCtx, ActorContext* actorCtx) {
     Actor* actor;
     s32 i;
 
-    for (i = 0; i < ARRAY_COUNT(actorCtx->actorList); i++)
-    {
+    for (i = 0; i < ARRAY_COUNT(actorCtx->actorList); i++) {
         actor = actorCtx->actorList[i].first;
-        while (actor != NULL)
-        {
-            if (!Object_IsLoaded(&globalCtx->objectCtx, actor->objBankIndex))
+        while (actor != NULL) {
+            if (!Object_IsLoaded(&globalCtx->objectCtx, actor->objBankIndex)) {
                 Actor_Kill(actor);
+            }
             actor = actor->next;
         }
     }
@@ -2796,47 +2505,38 @@ void func_80031A28(GlobalContext* globalCtx, ActorContext* actorCtx)
 
 u8 sEnemyActorTypes[] = { ACTORTYPE_ENEMY, ACTORTYPE_BOSS };
 
-void Actor_FreezeAllEnemies(GlobalContext* globalCtx, ActorContext* actorCtx, s32 freezeValue)
-{
+void Actor_FreezeAllEnemies(GlobalContext* globalCtx, ActorContext* actorCtx, s32 freezeValue) {
     Actor* actor;
     s32 i;
 
-    for (i = 0; i < ARRAY_COUNT(sEnemyActorTypes); i++)
-    {
+    for (i = 0; i < ARRAY_COUNT(sEnemyActorTypes); i++) {
         actor = actorCtx->actorList[sEnemyActorTypes[i]].first;
-        while (actor != NULL)
-        {
+        while (actor != NULL) {
             actor->freeze = freezeValue;
             actor = actor->next;
         }
     }
 }
 
-void func_80031B14(GlobalContext* globalCtx, ActorContext* actorCtx)
-{
+void func_80031B14(GlobalContext* globalCtx, ActorContext* actorCtx) {
     Actor* actor;
     s32 i;
 
-    for (i = 0; i < ARRAY_COUNT(actorCtx->actorList); i++)
-    {
+    for (i = 0; i < ARRAY_COUNT(actorCtx->actorList); i++) {
         actor = actorCtx->actorList[i].first;
-        while (actor != NULL)
-        {
-            if ((actor->room >= 0) &&
-                (actor->room != globalCtx->roomCtx.curRoom.num) &&
-                (actor->room != globalCtx->roomCtx.prevRoom.num))
-            {
-                if (!actor->activelyDrawn)
+        while (actor != NULL) {
+            if ((actor->room >= 0) && (actor->room != globalCtx->roomCtx.curRoom.num) &&
+                (actor->room != globalCtx->roomCtx.prevRoom.num)) {
+                if (!actor->activelyDrawn) {
                     actor = Actor_Delete(actorCtx, actor, globalCtx);
-                else
-                {
+                } else {
                     Actor_Kill(actor);
                     Actor_Destroy(actor, globalCtx);
                     actor = actor->next;
                 }
-            }
-            else
+            } else {
                 actor = actor->next;
+            }
         }
     }
 
@@ -2846,27 +2546,24 @@ void func_80031B14(GlobalContext* globalCtx, ActorContext* actorCtx)
     globalCtx->msgCtx.unk_E3F4 = 0;
 }
 
-void func_80031C3C(ActorContext* actorCtx, GlobalContext* globalCtx)
-{
+void func_80031C3C(ActorContext* actorCtx, GlobalContext* globalCtx) {
     Actor* actor;
     s32 i;
 
-    for (i = 0; i < ARRAY_COUNT(actorCtx->actorList); i++)
-    {
+    for (i = 0; i < ARRAY_COUNT(actorCtx->actorList); i++) {
         actor = actorCtx->actorList[i].first;
-        while (actor != NULL)
-        {
+        while (actor != NULL) {
             Actor_Delete(actorCtx, actor, globalCtx);
             actor = actorCtx->actorList[i].first;
         }
     }
 
-    if (HREG(20) != 0)
+    if (HREG(20) != 0) {
         // Translates to: "ABSOLUTE MAGIC FIELD DEALLOCATION"
         osSyncPrintf("絶対魔法領域解放\n");
+    }
 
-    if (actorCtx->absoluteSpace != NULL)
-    {
+    if (actorCtx->absoluteSpace != NULL) {
         ZeldaArena_FreeDebug(actorCtx->absoluteSpace, "../z_actor.c", 6731);
         actorCtx->absoluteSpace = NULL;
     }
@@ -2880,8 +2577,7 @@ void func_80031C3C(ActorContext* actorCtx, GlobalContext* globalCtx)
  * Adds a given actor instance at the front of the actor list of the specified type.
  * Also sets the actor instance as being of that type.
  */
-void Actor_AddToTypeList(ActorContext* actorCtx, Actor* actorToAdd, u8 actorType)
-{
+void Actor_AddToTypeList(ActorContext* actorCtx, Actor* actorToAdd, u8 actorType) {
     Actor* prevFirstActor;
 
     actorToAdd->type = actorType;
@@ -2890,8 +2586,9 @@ void Actor_AddToTypeList(ActorContext* actorCtx, Actor* actorToAdd, u8 actorType
     actorCtx->actorList[actorType].length++;
     prevFirstActor = actorCtx->actorList[actorType].first;
 
-    if (prevFirstActor != NULL)
+    if (prevFirstActor != NULL) {
         prevFirstActor->prev = actorToAdd;
+    }
 
     actorCtx->actorList[actorType].first = actorToAdd;
     actorToAdd->next = prevFirstActor;
@@ -2901,81 +2598,75 @@ void Actor_AddToTypeList(ActorContext* actorCtx, Actor* actorToAdd, u8 actorType
  * Removes a given actor instance from its actor list.
  * Also sets the temp clear flag of the current room if the actor removed was the last enemy loaded.
  */
-Actor* Actor_RemoveFromTypeList(GlobalContext* globalCtx, ActorContext* actorCtx, Actor* actorToRemove)
-{
+Actor* Actor_RemoveFromTypeList(GlobalContext* globalCtx, ActorContext* actorCtx, Actor* actorToRemove) {
     Actor* newFirstActor;
 
     actorCtx->total--;
     actorCtx->actorList[actorToRemove->type].length--;
 
-    if (actorToRemove->prev != NULL)
+    if (actorToRemove->prev != NULL) {
         actorToRemove->prev->next = actorToRemove->next;
-    else
+    } else {
         actorCtx->actorList[actorToRemove->type].first = actorToRemove->next;
+    }
 
     newFirstActor = actorToRemove->next;
 
-    if (newFirstActor != NULL)
+    if (newFirstActor != NULL) {
         newFirstActor->prev = actorToRemove->prev;
+    }
 
     actorToRemove->next = NULL;
     actorToRemove->prev = NULL;
 
-    if ((actorToRemove->room == globalCtx->roomCtx.curRoom.num) &&
-        (actorToRemove->type == ACTORTYPE_ENEMY) &&
-        (actorCtx->actorList[ACTORTYPE_ENEMY].length == 0))
-    {
+    if ((actorToRemove->room == globalCtx->roomCtx.curRoom.num) && (actorToRemove->type == ACTORTYPE_ENEMY) &&
+        (actorCtx->actorList[ACTORTYPE_ENEMY].length == 0)) {
         Flags_SetTempClear(globalCtx, globalCtx->roomCtx.curRoom.num);
     }
 
     return newFirstActor;
 }
 
-void Actor_FreeOverlay(ActorOverlay* actorOverlay)
-{
+void Actor_FreeOverlay(ActorOverlay* actorOverlay) {
     osSyncPrintf(VT_FGCOL(CYAN));
 
-    if (actorOverlay->nbLoaded == 0)
-    {
-        if (HREG(20) != 0)
+    if (actorOverlay->nbLoaded == 0) {
+        if (HREG(20) != 0) {
             // Translates to: "ACTOR CLIENT IS NOW 0"
             osSyncPrintf("アクタークライアントが０になりました\n");
+        }
 
-        if (actorOverlay->loadedRamAddr != NULL)
-        {
-            if (actorOverlay->allocType & ALLOCTYPE_PERMANENT)
-            {
-                if (HREG(20) != 0)
+        if (actorOverlay->loadedRamAddr != NULL) {
+            if (actorOverlay->allocType & ALLOCTYPE_PERMANENT) {
+                if (HREG(20) != 0) {
                     // Translates to: "OVERLAY WILL NOT BE DEALLOCATED"
                     osSyncPrintf("オーバーレイ解放しません\n");
-            }
-            else if (actorOverlay->allocType & ALLOCTYPE_ABSOLUTE)
-            {
-                if (HREG(20) != 0)
+                }
+            } else if (actorOverlay->allocType & ALLOCTYPE_ABSOLUTE) {
+                if (HREG(20) != 0) {
                     // Translates to: "ABSOLUTE MAGIC FIELD RESERVED, SO DEALLOCATION WILL NOT OCCUR"
                     osSyncPrintf("絶対魔法領域確保なので解放しません\n");
+                }
                 actorOverlay->loadedRamAddr = NULL;
-            }
-            else
-            {
-                if (HREG(20) != 0)
+            } else {
+                if (HREG(20) != 0) {
                     // Translates to: "OVERLAY DEALLOCATED"
                     osSyncPrintf("オーバーレイ解放します\n");
+                }
                 ZeldaArena_FreeDebug(actorOverlay->loadedRamAddr, "../z_actor.c", 6834);
                 actorOverlay->loadedRamAddr = NULL;
             }
         }
-    }
-    else if (HREG(20) != 0)
+    } else if (HREG(20) != 0) {
         // Translates to: "%d OF ACTOR CLIENT REMAINS"
         osSyncPrintf("アクタークライアントはあと %d 残っています\n", actorOverlay->nbLoaded);
+    }
 
     osSyncPrintf(VT_RST);
 }
 
-Actor* Actor_Spawn(ActorContext* actorCtx, GlobalContext* globalCtx, s16 actorId,
-                   f32 posX, f32 posY, f32 posZ, s16 rotX, s16 rotY, s16 rotZ, s16 params)
-{
+Actor* Actor_Spawn(ActorContext* actorCtx, GlobalContext* globalCtx, s16 actorId, f32 posX, f32 posY, f32 posZ,
+                   s16 rotX, s16 rotY, s16 rotZ, s16 params) {
     s32 pad;
     Actor* actor;
     ActorInit* actorInit;
@@ -2987,132 +2678,126 @@ Actor* Actor_Spawn(ActorContext* actorCtx, GlobalContext* globalCtx, s16 actorId
 
     overlayEntry = &gActorOverlayTable[actorId];
 
-    if (actorId >= ACTOR_DLF_MAX)
+    if (actorId >= ACTOR_DLF_MAX) {
         __assert("profile < ACTOR_DLF_MAX", "../z_actor.c", 6883);
+    }
 
     name = overlayEntry->name != NULL ? overlayEntry->name : "";
     overlaySize = (u32)overlayEntry->vramEnd - (u32)overlayEntry->vramStart;
 
-    if (HREG(20) != 0)
+    if (HREG(20) != 0) {
         // Translates to: "ACTOR CLASS ADDITION [%d:%s]"
         osSyncPrintf("アクタークラス追加 [%d:%s]\n", actorId, name);
+    }
 
-    if (actorCtx->total > ACTOR_NUMBER_MAX)
-    {
+    if (actorCtx->total > ACTOR_NUMBER_MAX) {
         // Translates to: "Ａｃｔｏｒ SET NUMBER EXCEEDED"
         osSyncPrintf(VT_COL(YELLOW, BLACK) "Ａｃｔｏｒセット数オーバー\n" VT_RST);
         return NULL;
     }
 
-    if (overlayEntry->vramStart == 0)
-    {
-        if (HREG(20) != 0)
+    if (overlayEntry->vramStart == 0) {
+        if (HREG(20) != 0) {
             // Translates to: "NOT AN OVERLAY"
             osSyncPrintf("オーバーレイではありません\n");
+        }
 
         actorInit = overlayEntry->initInfo;
-    }
-    else
-    {
-        if (overlayEntry->loadedRamAddr != NULL)
-        {
-            if (HREG(20) != 0)
+    } else {
+        if (overlayEntry->loadedRamAddr != NULL) {
+            if (HREG(20) != 0) {
                 // Translates to: "ALREADY LOADED"
                 osSyncPrintf("既にロードされています\n");
-        }
-        else
-        {
-            if (overlayEntry->allocType & ALLOCTYPE_ABSOLUTE)
-            {
-                if (overlaySize > AM_FIELD_SIZE)
+            }
+        } else {
+            if (overlayEntry->allocType & ALLOCTYPE_ABSOLUTE) {
+                if (overlaySize > AM_FIELD_SIZE) {
                     __assert("actor_segsize <= AM_FIELD_SIZE", "../z_actor.c", 6934);
+                }
 
-                if (actorCtx->absoluteSpace == NULL)
-                {
+                if (actorCtx->absoluteSpace == NULL) {
                     // Translates to: "AMF: ABSOLUTE MAGIC FIELD"
                     actorCtx->absoluteSpace = ZeldaArena_MallocRDebug(AM_FIELD_SIZE, "AMF:絶対魔法領域", 0);
-                    if (HREG(20) != 0)
+                    if (HREG(20) != 0) {
                         // Translates to: "ABSOLUTE MAGIC FIELD RESERVATION - %d BYTES RESERVED"
                         osSyncPrintf("絶対魔法領域確保 %d バイト確保\n", AM_FIELD_SIZE);
+                    }
                 }
 
                 overlayEntry->loadedRamAddr = actorCtx->absoluteSpace;
-            }
-            else if (overlayEntry->allocType & ALLOCTYPE_PERMANENT)
+            } else if (overlayEntry->allocType & ALLOCTYPE_PERMANENT) {
                 overlayEntry->loadedRamAddr = ZeldaArena_MallocRDebug(overlaySize, name, 0);
-            else
+            } else {
                 overlayEntry->loadedRamAddr = ZeldaArena_MallocDebug(overlaySize, name, 0);
+            }
 
-            if (overlayEntry->loadedRamAddr == NULL)
-            {
+            if (overlayEntry->loadedRamAddr == NULL) {
                 // Translates to: "CANNOT RESERVE ACTOR PROGRAM MEMORY"
                 osSyncPrintf(VT_COL(RED, WHITE) "Ａｃｔｏｒプログラムメモリが確保できません\n" VT_RST);
                 return NULL;
             }
 
-            Overlay_Load(overlayEntry->vromStart, overlayEntry->vromEnd,
-                          overlayEntry->vramStart, overlayEntry->vramEnd,
-                          overlayEntry->loadedRamAddr);
+            Overlay_Load(overlayEntry->vromStart, overlayEntry->vromEnd, overlayEntry->vramStart, overlayEntry->vramEnd,
+                         overlayEntry->loadedRamAddr);
 
             osSyncPrintf(VT_FGCOL(GREEN));
-            osSyncPrintf("OVL(a):Seg:%08x-%08x Ram:%08x-%08x Off:%08x %s\n",
-                         overlayEntry->vramStart, overlayEntry->vramEnd,
-                         overlayEntry->loadedRamAddr,
+            osSyncPrintf("OVL(a):Seg:%08x-%08x Ram:%08x-%08x Off:%08x %s\n", overlayEntry->vramStart,
+                         overlayEntry->vramEnd, overlayEntry->loadedRamAddr,
                          (u32)overlayEntry->loadedRamAddr + (u32)overlayEntry->vramEnd - (u32)overlayEntry->vramStart,
-                         (u32)overlayEntry->vramStart - (u32)overlayEntry->loadedRamAddr,
-                         name);
+                         (u32)overlayEntry->vramStart - (u32)overlayEntry->loadedRamAddr, name);
             osSyncPrintf(VT_RST);
 
             overlayEntry->nbLoaded = 0;
         }
 
-        actorInit = (ActorInit*)((u32)(overlayEntry->initInfo != NULL ?
-                    (ActorInit*)((u32)overlayEntry->initInfo - (s32)((u32)overlayEntry->vramStart - (u32)overlayEntry->loadedRamAddr)) :
-                    NULL));
+        actorInit =
+            (ActorInit*)((u32)(overlayEntry->initInfo != NULL
+                                   ? (ActorInit*)((u32)overlayEntry->initInfo - (s32)((u32)overlayEntry->vramStart -
+                                                                                      (u32)overlayEntry->loadedRamAddr))
+                                   : NULL));
     }
 
     objBankIndex = Object_GetIndex(&globalCtx->objectCtx, actorInit->objectId);
 
     if ((objBankIndex < 0) ||
-        ((actorInit->type == ACTORTYPE_ENEMY) && (Flags_GetClear(globalCtx,  globalCtx->roomCtx.curRoom.num))))
-    {
+        ((actorInit->type == ACTORTYPE_ENEMY) && (Flags_GetClear(globalCtx, globalCtx->roomCtx.curRoom.num)))) {
         // Translates to: "NO DATA BANK!! <DATA BANK＝%d> (profilep->bank=%d)"
-        osSyncPrintf(VT_COL(RED, WHITE) "データバンク無し！！<データバンク＝%d>(profilep->bank=%d)\n" VT_RST, objBankIndex, actorInit->objectId);
+        osSyncPrintf(VT_COL(RED, WHITE) "データバンク無し！！<データバンク＝%d>(profilep->bank=%d)\n" VT_RST,
+                     objBankIndex, actorInit->objectId);
         Actor_FreeOverlay(overlayEntry);
         return NULL;
     }
 
     actor = ZeldaArena_MallocDebug(actorInit->instanceSize, name, 1);
 
-    if (actor == NULL)
-    {
+    if (actor == NULL) {
         // Translates to: "ACTOR CLASS CANNOT BE RESERVED! %s <SIZE＝%d BYTES>"
-        osSyncPrintf(VT_COL(RED, WHITE) "Ａｃｔｏｒクラス確保できません！ %s <サイズ＝%dバイト>\n", VT_RST, name, actorInit->instanceSize);
+        osSyncPrintf(VT_COL(RED, WHITE) "Ａｃｔｏｒクラス確保できません！ %s <サイズ＝%dバイト>\n", VT_RST, name,
+                     actorInit->instanceSize);
         Actor_FreeOverlay(overlayEntry);
         return NULL;
     }
 
-    if (overlayEntry->nbLoaded >= 255)
+    if (overlayEntry->nbLoaded >= 255) {
         __assert("actor_dlftbl->clients < 255", "../z_actor.c", 7031);
+    }
 
     overlayEntry->nbLoaded++;
 
-    if (HREG(20) != 0)
+    if (HREG(20) != 0) {
         // Translates to: "ACTOR CLIENT No. %d"
         osSyncPrintf("アクタークライアントは %d 個目です\n", overlayEntry->nbLoaded);
+    }
 
     Lib_MemSet(actor, actorInit->instanceSize, 0);
     actor->overlayEntry = overlayEntry;
     actor->id = actorInit->id;
     actor->flags = actorInit->flags;
 
-    if (actorInit->id == ACTOR_EN_PART)
-    {
+    if (actorInit->id == ACTOR_EN_PART) {
         actor->objBankIndex = rotZ;
         rotZ = 0;
-    }
-    else
-    {
+    } else {
         actor->objBankIndex = objBankIndex;
     }
 
@@ -3138,26 +2823,24 @@ Actor* Actor_Spawn(ActorContext* actorCtx, GlobalContext* globalCtx, s16 actorId
     return actor;
 }
 
-Actor* Actor_SpawnAttached(ActorContext* actorCtx, Actor* attachedTo, GlobalContext* globalCtx, s16 actorId,
-                           f32 posX, f32 posY, f32 posZ, s16 rotX, s16 rotY, s16 rotZ, s16 params)
-{
-    Actor* spawnedActor = Actor_Spawn(actorCtx, globalCtx, actorId,
-                                      posX, posY, posZ,
-                                      rotX, rotY, rotZ, params);
-    if (spawnedActor == NULL)
+Actor* Actor_SpawnAttached(ActorContext* actorCtx, Actor* attachedTo, GlobalContext* globalCtx, s16 actorId, f32 posX,
+                           f32 posY, f32 posZ, s16 rotX, s16 rotY, s16 rotZ, s16 params) {
+    Actor* spawnedActor = Actor_Spawn(actorCtx, globalCtx, actorId, posX, posY, posZ, rotX, rotY, rotZ, params);
+    if (spawnedActor == NULL) {
         return NULL;
+    }
 
     attachedTo->attachedB = spawnedActor;
     spawnedActor->attachedA = attachedTo;
 
-    if (spawnedActor->room >= 0)
+    if (spawnedActor->room >= 0) {
         spawnedActor->room = attachedTo->room;
+    }
 
     return spawnedActor;
 }
 
-void Actor_SpawnTransitionActors(GlobalContext* globalCtx, ActorContext* actorCtx)
-{
+void Actor_SpawnTransitionActors(GlobalContext* globalCtx, ActorContext* actorCtx) {
     TransitionActorEntry* transitionActor;
     u8 nbTransitionActors;
     s32 i;
@@ -3165,20 +2848,16 @@ void Actor_SpawnTransitionActors(GlobalContext* globalCtx, ActorContext* actorCt
     transitionActor = globalCtx->transitionActorList;
     nbTransitionActors = globalCtx->nbTransitionActors;
 
-    for (i = 0; i < nbTransitionActors; i++)
-    {
-        if (transitionActor->id >= 0)
-        {
+    for (i = 0; i < nbTransitionActors; i++) {
+        if (transitionActor->id >= 0) {
             if (((transitionActor->frontRoom >= 0) &&
                  ((transitionActor->frontRoom == globalCtx->roomCtx.curRoom.num) ||
                   (transitionActor->frontRoom == globalCtx->roomCtx.prevRoom.num))) ||
                 ((transitionActor->backRoom >= 0) &&
                  ((transitionActor->backRoom == globalCtx->roomCtx.curRoom.num) ||
-                  (transitionActor->backRoom == globalCtx->roomCtx.prevRoom.num))))
-            {
-                Actor_Spawn(actorCtx, globalCtx, (s16)(transitionActor->id & 0x1FFF),
-                            transitionActor->pos.x, transitionActor->pos.y, transitionActor->pos.z,
-                            0, transitionActor->rotY, 0,
+                  (transitionActor->backRoom == globalCtx->roomCtx.prevRoom.num)))) {
+                Actor_Spawn(actorCtx, globalCtx, (s16)(transitionActor->id & 0x1FFF), transitionActor->pos.x,
+                            transitionActor->pos.y, transitionActor->pos.z, 0, transitionActor->rotY, 0,
                             (i << 0xA) + transitionActor->params);
 
                 transitionActor->id = -transitionActor->id;
@@ -3189,16 +2868,12 @@ void Actor_SpawnTransitionActors(GlobalContext* globalCtx, ActorContext* actorCt
     }
 }
 
-Actor* Actor_SpawnEntry(ActorContext* actorCtx, ActorEntry* actorEntry, GlobalContext* globalCtx)
-{
-    return Actor_Spawn(actorCtx, globalCtx, actorEntry->id,
-                       actorEntry->pos.x, actorEntry->pos.y, actorEntry->pos.z,
-                       actorEntry->rot.x, actorEntry->rot.y, actorEntry->rot.z,
-                       actorEntry->params);
+Actor* Actor_SpawnEntry(ActorContext* actorCtx, ActorEntry* actorEntry, GlobalContext* globalCtx) {
+    return Actor_Spawn(actorCtx, globalCtx, actorEntry->id, actorEntry->pos.x, actorEntry->pos.y, actorEntry->pos.z,
+                       actorEntry->rot.x, actorEntry->rot.y, actorEntry->rot.z, actorEntry->params);
 }
 
-Actor* Actor_Delete(ActorContext* actorCtx, Actor* actor, GlobalContext* globalCtx)
-{
+Actor* Actor_Delete(ActorContext* actorCtx, Actor* actor, GlobalContext* globalCtx) {
     char* name;
     Player* player;
     Actor* newFirstActor;
@@ -3209,24 +2884,27 @@ Actor* Actor_Delete(ActorContext* actorCtx, Actor* actor, GlobalContext* globalC
     overlayEntry = actor->overlayEntry;
     name = overlayEntry->name != NULL ? overlayEntry->name : "";
 
-    if (HREG(20) != 0)
+    if (HREG(20) != 0) {
         // Translates to: "ACTOR CLASS DELETED [%s]"
         osSyncPrintf("アクタークラス削除 [%s]\n", name);
+    }
 
-    if ((player != NULL) && (actor == player->unk_664))
-    {
+    if ((player != NULL) && (actor == player->unk_664)) {
         func_8008EDF0(player);
         func_8005A444(func_800C04A4(globalCtx, func_800C030C(globalCtx)), 0);
     }
 
-    if (actor == actorCtx->targetCtx.arrowPointedActor)
+    if (actor == actorCtx->targetCtx.arrowPointedActor) {
         actorCtx->targetCtx.arrowPointedActor = NULL;
+    }
 
-    if (actor == actorCtx->targetCtx.unk_8C)
+    if (actor == actorCtx->targetCtx.unk_8C) {
         actorCtx->targetCtx.unk_8C = NULL;
+    }
 
-    if (actor == actorCtx->targetCtx.unk_90)
+    if (actor == actorCtx->targetCtx.unk_90) {
         actorCtx->targetCtx.unk_90 = NULL;
+    }
 
     func_800F89E8(&actor->unk_E4);
     Actor_Destroy(actor, globalCtx);
@@ -3235,19 +2913,19 @@ Actor* Actor_Delete(ActorContext* actorCtx, Actor* actor, GlobalContext* globalC
 
     ZeldaArena_FreeDebug(actor, "../z_actor.c", 7242);
 
-    if (overlayEntry->vramStart == 0)
-    {
-        if (HREG(20) != 0)
+    if (overlayEntry->vramStart == 0) {
+        if (HREG(20) != 0) {
             // Translates to: "NOT AN OVERLAY"
             osSyncPrintf("オーバーレイではありません\n");
-    }
-    else
-    {
-        if (overlayEntry->loadedRamAddr == NULL)
+        }
+    } else {
+        if (overlayEntry->loadedRamAddr == NULL) {
             __assert("actor_dlftbl->allocp != NULL", "../z_actor.c", 7251);
+        }
 
-        if (overlayEntry->nbLoaded <= 0)
+        if (overlayEntry->nbLoaded <= 0) {
             __assert("actor_dlftbl->clients > 0", "../z_actor.c", 7252);
+        }
 
         overlayEntry->nbLoaded--;
         Actor_FreeOverlay(overlayEntry);
@@ -3256,8 +2934,7 @@ Actor* Actor_Delete(ActorContext* actorCtx, Actor* actor, GlobalContext* globalC
     return newFirstActor;
 }
 
-s32 func_80032880(GlobalContext* globalCtx, Actor* actor)
-{
+s32 func_80032880(GlobalContext* globalCtx, Actor* actor) {
     s16 sp1E;
     s16 sp1C;
 
@@ -3273,49 +2950,37 @@ f32 D_8015BBF4;
 s32 D_8015BBF8;
 s16 D_8015BBFC;
 
-void func_800328D4(GlobalContext* globalCtx, ActorContext* actorCtx, Player* player, u32 actorType)
-{
+void func_800328D4(GlobalContext* globalCtx, ActorContext* actorCtx, Player* player, u32 actorType) {
     f32 var;
     Actor* actor;
     Actor* sp84;
-    CollisionPoly *sp80;
+    CollisionPoly* sp80;
     UNK_TYPE sp7C;
     Vec3f sp70;
 
     actor = actorCtx->actorList[actorType].first;
     sp84 = player->unk_664;
 
-    while (actor != NULL)
-    {
-        if ((actor->update != NULL) && ((Player*)actor != player) && ((actor->flags & 1) == 1))
-        {
-            if ((actorType == ACTORTYPE_ENEMY) && ((actor->flags & 5) == 5) &&
-                (actor->waterSurfaceDist < 250000.0f) && (actor->waterSurfaceDist < D_8015BBF4))
-            {
-                    actorCtx->targetCtx.unk_90 = actor;
-                    D_8015BBF4 = actor->waterSurfaceDist;
+    while (actor != NULL) {
+        if ((actor->update != NULL) && ((Player*)actor != player) && ((actor->flags & 1) == 1)) {
+            if ((actorType == ACTORTYPE_ENEMY) && ((actor->flags & 5) == 5) && (actor->waterSurfaceDist < 250000.0f) &&
+                (actor->waterSurfaceDist < D_8015BBF4)) {
+                actorCtx->targetCtx.unk_90 = actor;
+                D_8015BBF4 = actor->waterSurfaceDist;
             }
 
-            if (actor != sp84)
-            {
+            if (actor != sp84) {
                 var = func_8002EFC0(actor, player, D_8015BBFC);
-                if ((var < D_8015BBF0) &&
-                    func_8002F090(actor, var) &&
-                    func_80032880(globalCtx, actor) &&
-                    (!func_8003DD6C(&globalCtx->colCtx, &player->actor.posRot2.pos,
-                                    &actor->posRot2.pos, &sp70, &sp80, 1, 1, 1, 1, &sp7C) ||
-                     func_80042048(&globalCtx->colCtx, sp80, sp7C)))
-                {
-                    if (actor->unk_10D != 0)
-                    {
-                        if (actor->unk_10D < D_8015BBF8)
-                        {
+                if ((var < D_8015BBF0) && func_8002F090(actor, var) && func_80032880(globalCtx, actor) &&
+                    (!func_8003DD6C(&globalCtx->colCtx, &player->actor.posRot2.pos, &actor->posRot2.pos, &sp70, &sp80,
+                                    1, 1, 1, 1, &sp7C) ||
+                     func_80042048(&globalCtx->colCtx, sp80, sp7C))) {
+                    if (actor->unk_10D != 0) {
+                        if (actor->unk_10D < D_8015BBF8) {
                             D_8015BBEC = actor;
                             D_8015BBF8 = actor->unk_10D;
                         }
-                    }
-                    else
-                    {
+                    } else {
                         D_8015BBE8 = actor;
                         D_8015BBF0 = var;
                     }
@@ -3327,24 +2992,12 @@ void func_800328D4(GlobalContext* globalCtx, ActorContext* actorCtx, Player* pla
     }
 }
 
-u8 D_801160A0[] =
-{
-    ACTORTYPE_BOSS,
-    ACTORTYPE_ENEMY,
-    ACTORTYPE_BG,
-    ACTORTYPE_EXPLOSIVES,
-    ACTORTYPE_NPC,
-    ACTORTYPE_ITEMACTION,
-    ACTORTYPE_CHEST,
-    ACTORTYPE_SWITCH,
-    ACTORTYPE_PROP,
-    ACTORTYPE_MISC,
-    ACTORTYPE_DOOR,
-    ACTORTYPE_SWITCH,
+u8 D_801160A0[] = {
+    ACTORTYPE_BOSS,  ACTORTYPE_ENEMY,  ACTORTYPE_BG,   ACTORTYPE_EXPLOSIVES, ACTORTYPE_NPC,  ACTORTYPE_ITEMACTION,
+    ACTORTYPE_CHEST, ACTORTYPE_SWITCH, ACTORTYPE_PROP, ACTORTYPE_MISC,       ACTORTYPE_DOOR, ACTORTYPE_SWITCH,
 };
 
-Actor* func_80032AF0(GlobalContext* globalCtx, ActorContext* actorCtx, Actor** actorPtr, Player* player)
-{
+Actor* func_80032AF0(GlobalContext* globalCtx, ActorContext* actorCtx, Actor** actorPtr, Player* player) {
     s32 i;
     u8* entry;
 
@@ -3352,33 +3005,30 @@ Actor* func_80032AF0(GlobalContext* globalCtx, ActorContext* actorCtx, Actor** a
     D_8015BBF0 = D_8015BBF4 = FLT_MAX;
     D_8015BBF8 = 0x7FFFFFFF;
 
-    if (!func_8008E988(globalCtx))
-    {
+    if (!func_8008E988(globalCtx)) {
         entry = &D_801160A0[0];
 
         actorCtx->targetCtx.unk_90 = NULL;
         D_8015BBFC = player->actor.shape.rot.y;
 
-        for (i = 0; i < 3; i++)
-        {
+        for (i = 0; i < 3; i++) {
             func_800328D4(globalCtx, actorCtx, player, *entry);
             entry++;
         }
 
-        if (D_8015BBE8 == NULL)
-        {
-            for (i; i < ARRAY_COUNT(D_801160A0); i++)
-            {
+        if (D_8015BBE8 == NULL) {
+            for (i; i < ARRAY_COUNT(D_801160A0); i++) {
                 func_800328D4(globalCtx, actorCtx, player, *entry);
                 entry++;
             }
         }
     }
 
-    if (D_8015BBE8 == 0)
+    if (D_8015BBE8 == 0) {
         *actorPtr = D_8015BBEC;
-    else
+    } else {
         *actorPtr = D_8015BBE8;
+    }
 
     return *actorPtr;
 }
@@ -3386,84 +3036,77 @@ Actor* func_80032AF0(GlobalContext* globalCtx, ActorContext* actorCtx, Actor** a
 /**
  * Finds the first actor instance of a specified id and type if there is one.
  */
-Actor* Actor_Find(ActorContext* actorCtx, s32 actorId, s32 actorType)
-{
+Actor* Actor_Find(ActorContext* actorCtx, s32 actorId, s32 actorType) {
     Actor* actor = actorCtx->actorList[actorType].first;
 
-    while (actor != NULL)
-    {
-        if (actorId == actor->id)
+    while (actor != NULL) {
+        if (actorId == actor->id) {
             return actor;
+        }
         actor = actor->next;
     }
 
     return NULL;
 }
 
-void func_80032C7C(GlobalContext* globalCtx, Actor* actor)
-{
+void func_80032C7C(GlobalContext* globalCtx, Actor* actor) {
     globalCtx->actorCtx.unk_00 = 5;
     Audio_PlaySoundAtPosition(globalCtx, &actor->posRot.pos, 0x14, NA_SE_EN_LAST_DAMAGE);
 }
 
-s16 func_80032CB4(s16* arg0, s16 arg1, s16 arg2, s16 arg3)
-{
-    if (DECR(arg0[1]) == 0)
+s16 func_80032CB4(s16* arg0, s16 arg1, s16 arg2, s16 arg3) {
+    if (DECR(arg0[1]) == 0) {
         arg0[1] = Math_Rand_S16Offset(arg1, arg2);
+    }
 
-    if ((arg0[1] - arg3) > 0)
+    if ((arg0[1] - arg3) > 0) {
         arg0[0] = 0;
-    else if (((arg0[1] - arg3) > -2) || (arg0[1] < 2))
+    } else if (((arg0[1] - arg3) > -2) || (arg0[1] < 2)) {
         arg0[0] = 1;
-    else
+    } else {
         arg0[0] = 2;
+    }
 
     return arg0[0];
 }
 
-s16 func_80032D60(s16* arg0, s16 arg1, s16 arg2, s16 arg3)
-{
-    if (DECR(arg0[1]) == 0)
-    {
+s16 func_80032D60(s16* arg0, s16 arg1, s16 arg2, s16 arg3) {
+    if (DECR(arg0[1]) == 0) {
         arg0[1] = Math_Rand_S16Offset(arg1, arg2);
         arg0[0]++;
 
-        if ((arg0[0] % 3) == 0)
+        if ((arg0[0] % 3) == 0) {
             arg0[0] = (s32)(Math_Rand_ZeroOne() * arg3) * 3;
+        }
     }
 
     return arg0[0];
 }
 
-typedef struct
-{
+typedef struct {
     /* 0x00 */ MtxF* unk_00;
     /* 0x04 */ s16* unk_04;
-    /* 0x08 */ s16  unk_08;
+    /* 0x08 */ s16 unk_08;
     /* 0x0A */ char unk_0A[0x02];
     /* 0x0C */ s32* unk_0C;
-    /* 0x10 */ s32  unk_10;
-    /* 0x14 */ s32  unk_14;
+    /* 0x10 */ s32 unk_10;
+    /* 0x14 */ s32 unk_14;
 } struct_80032E24;
 
-void func_80032E24(struct_80032E24* arg0, s32 arg1, GlobalContext* globalCtx)
-{
+void func_80032E24(struct_80032E24* arg0, s32 arg1, GlobalContext* globalCtx) {
     u32 sp28;
     u32 sp24;
     u32 sp20;
 
     sp28 = (arg1 * sizeof(*arg0->unk_00)) + sizeof(*arg0->unk_00);
     arg0->unk_00 = ZeldaArena_MallocDebug(sp28, "../z_actor.c", 7540);
-    if (arg0->unk_00 != NULL)
-    {
+    if (arg0->unk_00 != NULL) {
         sp24 = (arg1 * sizeof(*arg0->unk_0C)) + sizeof(*arg0->unk_0C);
         arg0->unk_0C = ZeldaArena_MallocDebug(sp24, "../z_actor.c", 7543);
-        if (arg0->unk_0C != NULL)
-        {
+        if (arg0->unk_0C != NULL) {
             sp20 = (arg1 * sizeof(*arg0->unk_04)) + sizeof(*arg0->unk_04);
             arg0->unk_04 = ZeldaArena_MallocDebug(sp20, "../z_actor.c", 7546);
-            if (arg0->unk_04 != NULL)
-            {
+            if (arg0->unk_04 != NULL) {
                 Lib_MemSet(arg0->unk_00, sp28, 0);
                 Lib_MemSet(arg0->unk_0C, sp24, 0);
                 Lib_MemSet(arg0->unk_04, sp20, 0);
@@ -3473,35 +3116,35 @@ void func_80032E24(struct_80032E24* arg0, s32 arg1, GlobalContext* globalCtx)
         }
     }
 
-    if (arg0->unk_00 != NULL)
+    if (arg0->unk_00 != NULL) {
         ZeldaArena_FreeDebug(arg0->unk_00, "../z_actor.c", 7558);
+    }
 
-    if (arg0->unk_0C != NULL)
+    if (arg0->unk_0C != NULL) {
         ZeldaArena_FreeDebug(arg0->unk_0C, "../z_actor.c", 7561);
+    }
 
-    if (arg0->unk_04 != NULL)
+    if (arg0->unk_04 != NULL) {
         ZeldaArena_FreeDebug(arg0->unk_04, "../z_actor.c", 7564);
+    }
 }
 
-void func_80032F54(struct_80032E24* arg0, s32 arg1, s32 arg2, s32 arg3, u32 arg4, s32* arg5, s16 arg6)
-{
+void func_80032F54(struct_80032E24* arg0, s32 arg1, s32 arg2, s32 arg3, u32 arg4, s32* arg5, s16 arg6) {
     GlobalContext* globalCtx = func_80026B00();
 
-    if ((globalCtx->actorCtx.unk_00 == 0) &&  (arg0->unk_10 > 0))
-    {
-        if ((arg1 >= arg2) && (arg3 >= arg1) && (*arg5 != 0))
-        {
+    if ((globalCtx->actorCtx.unk_00 == 0) && (arg0->unk_10 > 0)) {
+        if ((arg1 >= arg2) && (arg3 >= arg1) && (*arg5 != 0)) {
             arg0->unk_0C[arg0->unk_10] = *arg5;
             Matrix_Get(&arg0->unk_00[arg0->unk_10]);
             arg0->unk_04[arg0->unk_10] = arg6;
             arg0->unk_10++;
         }
 
-        if (arg1 != arg0->unk_14)
+        if (arg1 != arg0->unk_14) {
             arg0->unk_08++;
+        }
 
-        if (arg0->unk_08 >= arg4)
-        {
+        if (arg0->unk_08 >= arg4) {
             arg0->unk_08 = arg0->unk_10 - 1;
             arg0->unk_10 = -1;
         }
@@ -3510,45 +3153,41 @@ void func_80032F54(struct_80032E24* arg0, s32 arg1, s32 arg2, s32 arg3, u32 arg4
     arg0->unk_14 = arg1;
 }
 
-typedef struct
-{
-    /* 0x000 */ Actor   actor;
-    /* 0x14C */ u8      unk_14C;
-    /* 0x14E */ s16     unk_14E;
-    /* 0x150 */ s32     unk_150;
-    /* 0x154 */ f32     unk_154;
-    /* 0x158 */ f32     unk_158;
+typedef struct {
+    /* 0x000 */ Actor actor;
+    /* 0x14C */ u8 unk_14C;
+    /* 0x14E */ s16 unk_14E;
+    /* 0x150 */ s32 unk_150;
+    /* 0x154 */ f32 unk_154;
+    /* 0x158 */ f32 unk_158;
 } ActorEnPart;
 
-s32 func_8003305C(Actor* actor, struct_80032E24* arg1, GlobalContext* globalCtx, s16 params)
-{
+s32 func_8003305C(Actor* actor, struct_80032E24* arg1, GlobalContext* globalCtx, s16 params) {
     ActorEnPart* spawnedEnPart;
     MtxF* mtx;
     s16 objBankIndex;
 
-    if (arg1->unk_10 != -1)
+    if (arg1->unk_10 != -1) {
         return 0;
+    }
 
-    while (arg1->unk_08 > 0)
-    {
+    while (arg1->unk_08 > 0) {
         Matrix_Put(&arg1->unk_00[arg1->unk_08]);
         Matrix_Scale(1.0f / actor->scale.x, 1.0f / actor->scale.y, 1.0f / actor->scale.z, MTXMODE_APPLY);
         Matrix_Get(&arg1->unk_00[arg1->unk_08]);
 
-        if (1) // Necessary to match
-        {
-            if (arg1->unk_04[arg1->unk_08] >= 0)
+        if (1) { // Necessary to match
+            if (arg1->unk_04[arg1->unk_08] >= 0) {
                 objBankIndex = arg1->unk_04[arg1->unk_08];
-            else
+            } else {
                 objBankIndex = actor->objBankIndex;
+            }
         }
 
         mtx = &arg1->unk_00[arg1->unk_08];
         spawnedEnPart = (ActorEnPart*)Actor_SpawnAttached(&globalCtx->actorCtx, actor, globalCtx, ACTOR_EN_PART,
-                                                          mtx->wx, mtx->wy, mtx->wz,
-                                                          0, 0, objBankIndex, params);
-        if (spawnedEnPart != NULL)
-        {
+                                                          mtx->wx, mtx->wy, mtx->wz, 0, 0, objBankIndex, params);
+        if (spawnedEnPart != NULL) {
             func_800D20CC(&arg1->unk_00[arg1->unk_08], &spawnedEnPart->actor.shape.rot, 0);
             spawnedEnPart->unk_150 = arg1->unk_0C[arg1->unk_08];
             spawnedEnPart->actor.scale = actor->scale;
@@ -3565,8 +3204,8 @@ s32 func_8003305C(Actor* actor, struct_80032E24* arg1, GlobalContext* globalCtx,
     return 1;
 }
 
-void func_80033260(GlobalContext* globalCtx, Actor* actor, Vec3f* arg2, f32 arg3, s32 arg4, f32 arg5, s16 arg6, s16 arg7, u8 arg8)
-{
+void func_80033260(GlobalContext* globalCtx, Actor* actor, Vec3f* arg2, f32 arg3, s32 arg4, f32 arg5, s16 arg6,
+                   s16 arg7, u8 arg8) {
     Vec3f sp9C;
     Vec3f sp90 = { 0.0f, 0.0f, 0.0f };
     Vec3f sp84 = { 0.0f, 0.3f, 0.0f };
@@ -3577,26 +3216,25 @@ void func_80033260(GlobalContext* globalCtx, Actor* actor, Vec3f* arg2, f32 arg3
     sp9C.y = actor->unk_80;
     sp84.y += (Math_Rand_ZeroOne() - 0.5f) * 0.2f;
 
-    for (i = arg4; i >= 0; i--)
-    {
+    for (i = arg4; i >= 0; i--) {
         sp9C.x = (func_800CA720(var) * arg3) + arg2->x;
         sp9C.z = (func_800CA774(var) * arg3) + arg2->z;
         sp84.x = (Math_Rand_ZeroOne() - 0.5f) * arg5;
         sp84.z = (Math_Rand_ZeroOne() - 0.5f) * arg5;
 
-        if (arg6 == 0)
+        if (arg6 == 0) {
             func_8002857C(globalCtx, &sp9C, &sp90, &sp84);
-        else if (arg8 != 0)
+        } else if (arg8 != 0) {
             func_800286CC(globalCtx, &sp9C, &sp90, &sp84, arg6, arg7);
-        else
+        } else {
             func_8002865C(globalCtx, &sp9C, &sp90, &sp84, arg6, arg7);
+        }
 
         var += 6.28f / (arg4 + 1.0f);
     }
 }
 
-void func_80033480(GlobalContext* globalCtx, Vec3f* arg1, f32 arg2, s32 arg3, s16 arg4, s16 arg5, u8 arg6)
-{
+void func_80033480(GlobalContext* globalCtx, Vec3f* arg1, f32 arg2, s32 arg3, s16 arg4, s16 arg5, u8 arg6) {
     Vec3f sp94;
     Vec3f sp88 = { 0.0f, 0.0f, 0.0f };
     Vec3f sp7C = { 0.0f, 0.3f, 0.0f };
@@ -3604,8 +3242,7 @@ void func_80033480(GlobalContext* globalCtx, Vec3f* arg1, f32 arg2, s32 arg3, s1
     u32 var2;
     s32 i;
 
-    for (i = arg3; i >= 0; i--)
-    {
+    for (i = arg3; i >= 0; i--) {
         sp94.x = arg1->x + ((Math_Rand_ZeroOne() - 0.5f) * arg2);
         sp94.y = arg1->y + ((Math_Rand_ZeroOne() - 0.5f) * arg2);
         sp94.z = arg1->z + ((Math_Rand_ZeroOne() - 0.5f) * arg2);
@@ -3613,17 +3250,16 @@ void func_80033480(GlobalContext* globalCtx, Vec3f* arg1, f32 arg2, s32 arg3, s1
         var = (s16)((Math_Rand_ZeroOne() * arg4) * 0.2f) + arg4;
         var2 = arg6;
 
-        if (var2 != 0)
+        if (var2 != 0) {
             func_800286CC(globalCtx, &sp94, &sp88, &sp7C, var, arg5);
-        else
+        } else {
             func_8002865C(globalCtx, &sp94, &sp88, &sp7C, var, arg5);
+        }
     }
 }
 
-Actor* func_80033640(GlobalContext* globalCtx, Collider* collider)
-{
-    if ((collider->collideFlags & 0x2) && (collider->ac->type == ACTORTYPE_EXPLOSIVES))
-    {
+Actor* func_80033640(GlobalContext* globalCtx, Collider* collider) {
+    if ((collider->collideFlags & 0x2) && (collider->ac->type == ACTORTYPE_EXPLOSIVES)) {
         collider->collideFlags &= ~0x2;
         return collider->ac;
     }
@@ -3631,22 +3267,18 @@ Actor* func_80033640(GlobalContext* globalCtx, Collider* collider)
     return NULL;
 }
 
-Actor* func_80033684(GlobalContext* globalCtx, Actor* explosiveActor)
-{
+Actor* func_80033684(GlobalContext* globalCtx, Actor* explosiveActor) {
     Actor* actor = globalCtx->actorCtx.actorList[ACTORTYPE_EXPLOSIVES].first;
 
-    while (actor != NULL)
-    {
-        if ((actor == explosiveActor) || (actor->params != 1))
-        {
+    while (actor != NULL) {
+        if ((actor == explosiveActor) || (actor->params != 1)) {
             actor = actor->next;
-        }
-        else
-        {
-            if (func_8002DB48(explosiveActor, actor) <= (actor->shape.rot.z * 10) + 80.0f)
+        } else {
+            if (func_8002DB48(explosiveActor, actor) <= (actor->shape.rot.z * 10) + 80.0f) {
                 return actor;
-            else
+            } else {
                 actor = actor->next;
+            }
         }
     }
 
@@ -3657,21 +3289,18 @@ Actor* func_80033684(GlobalContext* globalCtx, Actor* explosiveActor)
  * Dynamically changes the type of a given actor instance.
  * This is done by moving it to the corresponding type list and setting its type variable accordingly.
  */
-void Actor_ChangeType(GlobalContext* globalCtx, ActorContext* actorCtx, Actor* actor, u8 actorType)
-{
+void Actor_ChangeType(GlobalContext* globalCtx, ActorContext* actorCtx, Actor* actor, u8 actorType) {
     Actor_RemoveFromTypeList(globalCtx, actorCtx, actor);
     Actor_AddToTypeList(actorCtx, actor, actorType);
 }
 
-typedef struct
-{
-    /* 0x000 */ Actor   actor;
-    /* 0x14C */ char    unk_14C[0xC4];
-    /* 0x210 */ s16     unk_210;
+typedef struct {
+    /* 0x000 */ Actor actor;
+    /* 0x14C */ char unk_14C[0xC4];
+    /* 0x210 */ s16 unk_210;
 } Actor_80033780;
 
-Actor_80033780* func_80033780(GlobalContext* globalCtx, Actor* refActor, f32 arg2)
-{
+Actor_80033780* func_80033780(GlobalContext* globalCtx, Actor* refActor, f32 arg2) {
     Actor_80033780* itemActor;
     Vec3f spA8;
     f32 deltaX;
@@ -3682,19 +3311,15 @@ Actor_80033780* func_80033780(GlobalContext* globalCtx, Actor* refActor, f32 arg
     Actor* actor;
 
     actor = globalCtx->actorCtx.actorList[ACTORTYPE_ITEMACTION].first;
-    while (actor != NULL)
-    {
-        if (((actor->id != ACTOR_ARMS_HOOK) && (actor->id != ACTOR_EN_ARROW)) || (actor == refActor))
+    while (actor != NULL) {
+        if (((actor->id != ACTOR_ARMS_HOOK) && (actor->id != ACTOR_EN_ARROW)) || (actor == refActor)) {
             actor = actor->next;
-        else
-        {
+        } else {
             itemActor = (Actor_80033780*)actor;
-            if ((arg2 < Math_Vec3f_DistXYZ(&refActor->posRot.pos, &itemActor->actor.posRot.pos)) || (itemActor->unk_210 == 0))
-            {
+            if ((arg2 < Math_Vec3f_DistXYZ(&refActor->posRot.pos, &itemActor->actor.posRot.pos)) ||
+                (itemActor->unk_210 == 0)) {
                 actor = actor->next;
-            }
-            else
-            {
+            } else {
                 deltaX = Math_Sins(itemActor->actor.posRot.rot.y) * (itemActor->actor.speedXZ * 10.0f);
                 deltaY = itemActor->actor.velocity.y + (itemActor->actor.gravity * 10.0f);
                 deltaZ = Math_Coss(itemActor->actor.posRot.rot.y) * (itemActor->actor.speedXZ * 10.0f);
@@ -3703,11 +3328,12 @@ Actor_80033780* func_80033780(GlobalContext* globalCtx, Actor* refActor, f32 arg
                 spA8.y = itemActor->actor.posRot.pos.y + deltaY;
                 spA8.z = itemActor->actor.posRot.pos.z + deltaZ;
 
-                if (func_80062ECC(refActor->sub_98.unk_10, refActor->sub_98.unk_12, 0.0f,
-                                    &refActor->posRot.pos, &itemActor->actor.posRot.pos, &spA8, &sp90, &sp84))
+                if (func_80062ECC(refActor->sub_98.unk_10, refActor->sub_98.unk_12, 0.0f, &refActor->posRot.pos,
+                                  &itemActor->actor.posRot.pos, &spA8, &sp90, &sp84)) {
                     return itemActor;
-                else
+                } else {
                     actor = actor->next;
+                }
             }
         }
     }
@@ -3718,12 +3344,10 @@ Actor_80033780* func_80033780(GlobalContext* globalCtx, Actor* refActor, f32 arg
 /**
  * Sets the actor's text id with a dynamic prefix based on the current scene.
  */
-void Actor_SetTextWithPrefix(GlobalContext* globalCtx, Actor* actor, s16 baseTextId)
-{
+void Actor_SetTextWithPrefix(GlobalContext* globalCtx, Actor* actor, s16 baseTextId) {
     s16 prefix;
 
-    switch (globalCtx->sceneNum)
-    {
+    switch (globalCtx->sceneNum) {
         case SCENE_YDAN:
         case SCENE_YDAN_BOSS:
         case SCENE_MORIBOSSROOM:
@@ -3797,8 +3421,7 @@ void Actor_SetTextWithPrefix(GlobalContext* globalCtx, Actor* actor, s16 baseTex
     actor->textId = prefix | baseTextId;
 }
 
-s16 func_800339B8(Actor* actor, GlobalContext* globalCtx, f32 arg2, s16 arg3)
-{
+s16 func_800339B8(Actor* actor, GlobalContext* globalCtx, f32 arg2, s16 arg3) {
     s16 ret;
     s16 sp44;
     f32 sp40;
@@ -3820,36 +3443,32 @@ s16 func_800339B8(Actor* actor, GlobalContext* globalCtx, f32 arg2, s16 arg3)
     return ret;
 }
 
-s32 func_80033A84(GlobalContext* globalCtx, Actor* actor)
-{
+s32 func_80033A84(GlobalContext* globalCtx, Actor* actor) {
     Player* player = PLAYER;
-    if ((player->stateFlags1 & 0x10) && (actor->unk_10C != 0))
+    if ((player->stateFlags1 & 0x10) && (actor->unk_10C != 0)) {
         return 1;
-    else
+    } else {
         return 0;
+    }
 }
 
-s32 func_80033AB8(GlobalContext* globalCtx, Actor* actor)
-{
+s32 func_80033AB8(GlobalContext* globalCtx, Actor* actor) {
     Player* player = PLAYER;
-    if ((player->stateFlags1 & 0x10) && (actor->unk_10C == 0))
+    if ((player->stateFlags1 & 0x10) && (actor->unk_10C == 0)) {
         return 1;
-    else
+    } else {
         return 0;
+    }
 }
 
-f32 func_80033AEC(Vec3f* arg0, Vec3f* arg1, f32 arg2, f32 arg3, f32 arg4, f32 arg5)
-{
+f32 func_80033AEC(Vec3f* arg0, Vec3f* arg1, f32 arg2, f32 arg3, f32 arg4, f32 arg5) {
     f32 ret = 0.0f;
 
-    if (arg4 <= Math_Vec3f_DistXYZ(arg0, arg1))
-    {
+    if (arg4 <= Math_Vec3f_DistXYZ(arg0, arg1)) {
         ret = Math_SmoothScaleMaxMinF(&arg1->x, arg0->x, arg2, arg3, 0.0f);
         ret += Math_SmoothScaleMaxMinF(&arg1->y, arg0->y, arg2, arg3, 0.0f);
         ret += Math_SmoothScaleMaxMinF(&arg1->z, arg0->z, arg2, arg3, 0.0f);
-    }
-    else if (arg5 < Math_Vec3f_DistXYZ(arg0, arg1))
-    {
+    } else if (arg5 < Math_Vec3f_DistXYZ(arg0, arg1)) {
         ret = Math_SmoothScaleMaxMinF(&arg1->x, arg0->x, arg2, arg3, 0.0f);
         ret += Math_SmoothScaleMaxMinF(&arg1->y, arg0->y, arg2, arg3, 0.0f);
         ret += Math_SmoothScaleMaxMinF(&arg1->z, arg0->z, arg2, arg3, 0.0f);
@@ -3858,20 +3477,19 @@ f32 func_80033AEC(Vec3f* arg0, Vec3f* arg1, f32 arg2, f32 arg3, f32 arg4, f32 ar
     return ret;
 }
 
-void func_80033C30(Vec3f* arg0, Vec3f* arg1, u8 alpha, GlobalContext* globalCtx)
-{
+void func_80033C30(Vec3f* arg0, Vec3f* arg1, u8 alpha, GlobalContext* globalCtx) {
     MtxF sp60;
     f32 var;
     Vec3f sp50;
     CollisionPoly* sp4C;
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8120);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 8120);
 
-    if (0) ; // Necessary to match
+    if (0) {} // Necessary to match
 
-    gfxCtx->polyOpa.p = func_80093774(gfxCtx->polyOpa.p, 0x2C);
+    gfxCtx->polyOpa.p = Gfx_CallSetupDL(gfxCtx->polyOpa.p, 0x2C);
 
     gDPSetPrimColor(gfxCtx->polyOpa.p++, 0, 0, 0x00, 0x00, 0x00, alpha);
 
@@ -3881,60 +3499,55 @@ void func_80033C30(Vec3f* arg0, Vec3f* arg1, u8 alpha, GlobalContext* globalCtx)
 
     var = func_8003C8EC(globalCtx, &globalCtx->colCtx, &sp4C, &sp50);
 
-    if (sp4C != NULL)
-    {
+    if (sp4C != NULL) {
         func_80038A28(sp4C, arg0->x, var, arg0->z, &sp60);
         Matrix_Put(&sp60);
-    }
-    else
+    } else {
         Matrix_Translate(arg0->x, arg0->y, arg0->z, MTXMODE_NEW);
+    }
 
     Matrix_Scale(arg1->x, 1.0f, arg1->z, MTXMODE_APPLY);
 
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_actor.c", 8149), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_actor.c", 8149),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, &D_04049210);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8155);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 8155);
 }
 
-void func_80033DB8(GlobalContext* globalCtx, s16 arg1, s16 arg2)
-{
-    s16 var = func_80092F88(&globalCtx->cameraCtx.activeCameras[0], 3);
-    func_80092DAC(var, 20000);
-    func_80092E70(var, arg1, 0, 0, 0);
-    func_80092DF0(var, arg2);
+void func_80033DB8(GlobalContext* globalCtx, s16 arg1, s16 arg2) {
+    s16 var = Quake_Add(&globalCtx->cameraCtx.activeCameras[0], 3);
+    Quake_SetSpeed(var, 20000);
+    Quake_SetQuakeValues(var, arg1, 0, 0, 0);
+    Quake_SetCountdown(var, arg2);
 }
 
-void func_80033E1C(GlobalContext* globalCtx, s16 arg1, s16 arg2, s16 arg3)
-{
-    s16 var = func_80092F88(&globalCtx->cameraCtx.activeCameras[0], 3);
-    func_80092DAC(var, arg3);
-    func_80092E70(var, arg1, 0, 0, 0);
-    func_80092DF0(var, arg2);
+void func_80033E1C(GlobalContext* globalCtx, s16 arg1, s16 arg2, s16 arg3) {
+    s16 var = Quake_Add(&globalCtx->cameraCtx.activeCameras[0], 3);
+    Quake_SetSpeed(var, arg3);
+    Quake_SetQuakeValues(var, arg1, 0, 0, 0);
+    Quake_SetCountdown(var, arg2);
 }
 
-void func_80033E88(Actor* actor, GlobalContext* globalCtx, s16 arg2, s16 arg3)
-{
-    if (arg2 >= 5)
+void func_80033E88(Actor* actor, GlobalContext* globalCtx, s16 arg2, s16 arg3) {
+    if (arg2 >= 5) {
         func_800AA000(actor->waterSurfaceDist, 0xFF, 0x14, 0x96);
-    else
+    } else {
         func_800AA000(actor->waterSurfaceDist, 0xB4, 0x14, 0x64);
+    }
 
     func_80033DB8(globalCtx, arg2, arg3);
 }
 
-f32 Math_Rand_ZeroFloat(f32 f)
-{
+f32 Math_Rand_ZeroFloat(f32 f) {
     return Math_Rand_ZeroOne() * f;
 }
 
-f32 Math_Rand_CenteredFloat(f32 f)
-{
+f32 Math_Rand_CenteredFloat(f32 f) {
     return (Math_Rand_ZeroOne() - 0.5f) * f;
 }
 
-typedef struct
-{
+typedef struct {
     /* 0x00 */ f32 unk_00;
     /* 0x04 */ f32 unk_04;
     /* 0x08 */ f32 unk_08;
@@ -3944,15 +3557,13 @@ typedef struct
     /* 0x18 */ u32 unk_18;
 } struct_801160DC; // size = 0x1C
 
-struct_801160DC D_801160DC[3] =
-{
-    {       0.54f,  6000.0f, 5000.0f,  1.0f, 0.0f, 0x050011F0, 0x05001100 },
-    {      0.644f, 12000.0f, 8000.0f,  1.0f, 0.0f, 0x06001530, 0x06001400 },
-    { 0.64000005f,  8500.0f, 8000.0f, 1.75f, 0.1f, 0x050011F0, 0x05001100 },
+struct_801160DC D_801160DC[3] = {
+    { 0.54f, 6000.0f, 5000.0f, 1.0f, 0.0f, 0x050011F0, 0x05001100 },
+    { 0.644f, 12000.0f, 8000.0f, 1.0f, 0.0f, 0x06001530, 0x06001400 },
+    { 0.64000005f, 8500.0f, 8000.0f, 1.75f, 0.1f, 0x050011F0, 0x05001100 },
 };
 
-void func_80033F54(GlobalContext* globalCtx, s32 arg1, s32 arg2)
-{
+void func_80033F54(GlobalContext* globalCtx, s32 arg1, s32 arg2) {
     struct_801160DC* entry;
     s32 i;
     MtxF spB0;
@@ -3961,13 +3572,13 @@ void func_80033F54(GlobalContext* globalCtx, s32 arg1, s32 arg2)
     f32 temp2;
     f32 temp3;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     entry = &D_801160DC[arg2];
     var = entry->unk_10;
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8265);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 8265);
 
     Matrix_Translate(0.0f, entry->unk_08, 500.0f, MTXMODE_APPLY);
     Matrix_Get(&spB0);
@@ -3975,22 +3586,24 @@ void func_80033F54(GlobalContext* globalCtx, s32 arg1, s32 arg2)
     temp1 = sinf(entry->unk_00 - var) * -(10 - arg1) * 0.1f * entry->unk_04;
     temp2 = cosf(entry->unk_00 - var) * (10 - arg1) * 0.1f * entry->unk_04;
 
-    for (i = 0; i < 4; i++)
-    {
+    for (i = 0; i < 4; i++) {
         Matrix_Put(&spB0);
         Matrix_RotateZ(var, MTXMODE_APPLY);
         Matrix_Translate(temp1, temp2, 0.0f, MTXMODE_APPLY);
 
-        if (entry->unk_0C != 1.0f)
+        if (entry->unk_0C != 1.0f) {
             Matrix_Scale(entry->unk_0C, entry->unk_0C, entry->unk_0C, MTXMODE_APPLY);
+        }
 
-        gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_actor.c", 8299), G_MTX_MODELVIEW | G_MTX_LOAD);
+        gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_actor.c", 8299),
+                  G_MTX_MODELVIEW | G_MTX_LOAD);
         gSPDisplayList(gfxCtx->polyOpa.p++, entry->unk_14);
 
-        if (i % 2)
+        if (i % 2) {
             temp3 = entry->unk_00 + entry->unk_00;
-        else
+        } else {
             temp3 = M_PI - (entry->unk_00 + entry->unk_00);
+        }
 
         var += temp3;
     }
@@ -3998,28 +3611,27 @@ void func_80033F54(GlobalContext* globalCtx, s32 arg1, s32 arg2)
     Matrix_Put(&spB0);
     Matrix_Scale(arg1 * 0.1f, arg1 * 0.1f, arg1 * 0.1f, MTXMODE_APPLY);
 
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_actor.c", 8314), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_actor.c", 8314),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, entry->unk_18);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8319);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 8319);
 }
 
-void func_8003424C(GlobalContext* globalCtx, Vec3f* arg1)
-{
+void func_8003424C(GlobalContext* globalCtx, Vec3f* arg1) {
     func_80062D60(globalCtx, arg1);
 }
 
-void func_8003426C(Actor* actor, s16 arg1, s16 arg2, s16 arg3, s16 arg4)
-{
-    if ((arg1 == 0x8000) && !(arg2 & 0x8000))
+void func_8003426C(Actor* actor, s16 arg1, s16 arg2, s16 arg3, s16 arg4) {
+    if ((arg1 == 0x8000) && !(arg2 & 0x8000)) {
         Audio_PlayActorSound2(actor, NA_SE_EN_LIGHT_ARROW_HIT);
+    }
 
     actor->unk_112 = arg1 | arg3 | ((arg2 & 0xF8) << 5) | arg4;
     actor->unk_114 = arg4;
 }
 
-Hilite* func_800342EC(Vec3f* object, GlobalContext* globalCtx)
-{
+Hilite* func_800342EC(Vec3f* object, GlobalContext* globalCtx) {
     Vec3f lightDir;
 
     lightDir.x = globalCtx->unk_10A4E;
@@ -4029,8 +3641,7 @@ Hilite* func_800342EC(Vec3f* object, GlobalContext* globalCtx)
     return func_8002EABC(object, &globalCtx->view.eye, &lightDir, globalCtx->state.gfxCtx);
 }
 
-Hilite* func_8003435C(Vec3f* object, GlobalContext* globalCtx)
-{
+Hilite* func_8003435C(Vec3f* object, GlobalContext* globalCtx) {
     Vec3f lightDir;
 
     lightDir.x = globalCtx->unk_10A4E;
@@ -4040,102 +3651,93 @@ Hilite* func_8003435C(Vec3f* object, GlobalContext* globalCtx)
     return func_8002EB44(object, &globalCtx->view.eye, &lightDir, globalCtx->state.gfxCtx);
 }
 
-typedef s16 (*func_800343CC_arg4)(GlobalContext*, Actor*);
-typedef s16 (*func_800343CC_arg5)(GlobalContext*, Actor*);
-
-s32 func_800343CC(GlobalContext* globalCtx, Actor* actor, s16* arg2, f32 arg3, func_800343CC_arg4 unkFunc1, func_800343CC_arg5 unkFunc2)
-{
+s32 func_800343CC(GlobalContext* globalCtx, Actor* actor, s16* arg2, f32 arg3, u16 (*unkFunc1)(GlobalContext*, Actor*),
+                  s16 (*unkFunc2)(GlobalContext*, Actor*)) {
     s16 sp26;
     s16 sp24;
 
-    if (func_8002F194(actor, globalCtx))
-    {
+    if (func_8002F194(actor, globalCtx)) {
         *arg2 = 1;
         return 1;
     }
 
-    if (*arg2 != 0)
-    {
+    if (*arg2 != 0) {
         *arg2 = unkFunc2(globalCtx, actor);
         return 0;
     }
 
     func_8002F374(globalCtx, actor, &sp26, &sp24);
 
-    if ((sp26 < 0) || (sp26 > 0x140) || (sp24 < 0) || (sp24 > 0xF0))
+    if ((sp26 < 0) || (sp26 > 0x140) || (sp24 < 0) || (sp24 > 0xF0)) {
         return 0;
+    }
 
-    if (!func_8002F2CC(actor, globalCtx, arg3))
+    if (!func_8002F2CC(actor, globalCtx, arg3)) {
         return 0;
+    }
 
     actor->textId = unkFunc1(globalCtx, actor);
 
     return 0;
 }
 
-typedef struct
-{
-    /* 0x00 */ s16  unk_00;
-    /* 0x02 */ s16  unk_02;
-    /* 0x04 */ s16  unk_04;
-    /* 0x06 */ s16  unk_06;
-    /* 0x08 */ s16  unk_08;
-    /* 0x0A */ s16  unk_0A;
+typedef struct {
+    /* 0x00 */ s16 unk_00;
+    /* 0x02 */ s16 unk_02;
+    /* 0x04 */ s16 unk_04;
+    /* 0x06 */ s16 unk_06;
+    /* 0x08 */ s16 unk_08;
+    /* 0x0A */ s16 unk_0A;
     /* 0x0C */ char unk_0C[0x2];
-    /* 0x0E */ s16  unk_0E;
-    /* 0x10 */ s16  unk_10;
+    /* 0x0E */ s16 unk_0E;
+    /* 0x10 */ s16 unk_10;
     /* 0x12 */ char unk_12[0x2];
-    /* 0x14 */ f32  unk_14;
+    /* 0x14 */ f32 unk_14;
     /* 0x18 */ Vec3f unk_18;
 } struct_80034A14_arg1;
 
-typedef struct
-{
-    /* 0x00 */ s16  unk_00;
-    /* 0x02 */ s16  unk_02;
-    /* 0x04 */ s16  unk_04;
-    /* 0x06 */ s16  unk_06;
-    /* 0x08 */ s16  unk_08;
-    /* 0x0A */ s16  unk_0A;
-    /* 0x0C */ u8   unk_0C;
+typedef struct {
+    /* 0x00 */ s16 unk_00;
+    /* 0x02 */ s16 unk_02;
+    /* 0x04 */ s16 unk_04;
+    /* 0x06 */ s16 unk_06;
+    /* 0x08 */ s16 unk_08;
+    /* 0x0A */ s16 unk_0A;
+    /* 0x0C */ u8 unk_0C;
 } struct_80116130_0; // size = 0x10
 
-typedef struct
-{
+typedef struct {
     /* 0x00 */ struct_80116130_0 sub_00;
-    /* 0x10 */ f32  unk_10;
-    /* 0x14 */ s16  unk_14;
+    /* 0x10 */ f32 unk_10;
+    /* 0x14 */ s16 unk_14;
 } struct_80116130; // size = 0x18
 
-struct_80116130 D_80116130[13] =
-{
+struct_80116130 D_80116130[13] = {
     { { 0x2AA8, 0xF1C8, 0x18E2, 0x1554, 0x0000, 0x0000, 1 }, 170.0f, 0x3FFC },
     { { 0x2AA8, 0xEAAC, 0x1554, 0x1554, 0xF8E4, 0x0E38, 1 }, 170.0f, 0x3FFC },
     { { 0x31C4, 0xE390, 0x0E38, 0x0E38, 0xF1C8, 0x071C, 1 }, 170.0f, 0x3FFC },
     { { 0x1554, 0xF1C8, 0x0000, 0x071C, 0xF8E4, 0x0000, 1 }, 170.0f, 0x3FFC },
     { { 0x2AA8, 0xF8E4, 0x071C, 0x0E38, 0xD558, 0x2AA8, 1 }, 170.0f, 0x3FFC },
     { { 0x0000, 0xE390, 0x2AA8, 0x3FFC, 0xF1C8, 0x0E38, 1 }, 170.0f, 0x3FFC },
-    { { 0x2AA8, 0xF1C8, 0x0E38, 0x0E38, 0x0000, 0x0000, 1 },   0.0f, 0x0000 },
-    { { 0x2AA8, 0xF1C8, 0x0000, 0x0E38, 0x0000, 0x1C70, 1 },   0.0f, 0x0000 },
-    { { 0x2AA8, 0xF1C8, 0xF1C8, 0x0000, 0x0000, 0x0000, 1 },   0.0f, 0x0000 },
-    { { 0x071C, 0xF1C8, 0x0E38, 0x1C70, 0x0000, 0x0000, 1 },   0.0f, 0x0000 },
-    { { 0x0E38, 0xF1C8, 0x0000, 0x1C70, 0x0000, 0x0E38, 1 },   0.0f, 0x0000 },
-    { { 0x2AA8, 0xE390, 0x1C70, 0x0E38, 0xF1C8, 0x0E38, 1 },   0.0f, 0x0000 },
-    { { 0x18E2, 0xF1C8, 0x0E38, 0x0E38, 0x0000, 0x0000, 1 },   0.0f, 0x0000 },
+    { { 0x2AA8, 0xF1C8, 0x0E38, 0x0E38, 0x0000, 0x0000, 1 }, 0.0f, 0x0000 },
+    { { 0x2AA8, 0xF1C8, 0x0000, 0x0E38, 0x0000, 0x1C70, 1 }, 0.0f, 0x0000 },
+    { { 0x2AA8, 0xF1C8, 0xF1C8, 0x0000, 0x0000, 0x0000, 1 }, 0.0f, 0x0000 },
+    { { 0x071C, 0xF1C8, 0x0E38, 0x1C70, 0x0000, 0x0000, 1 }, 0.0f, 0x0000 },
+    { { 0x0E38, 0xF1C8, 0x0000, 0x1C70, 0x0000, 0x0E38, 1 }, 0.0f, 0x0000 },
+    { { 0x2AA8, 0xE390, 0x1C70, 0x0E38, 0xF1C8, 0x0E38, 1 }, 0.0f, 0x0000 },
+    { { 0x18E2, 0xF1C8, 0x0E38, 0x0E38, 0x0000, 0x0000, 1 }, 0.0f, 0x0000 },
 };
 
 #ifdef NON_MATCHING
-// this function still needs a lot of work
-void func_800344BC(Actor* actor, struct_80034A14_arg1* arg1, s16 arg2, s16 arg3, s16 arg4, s16 arg5, s16 arg6, s16 arg7, u8 arg8)
-{
+// regalloc differences
+void func_800344BC(Actor* actor, struct_80034A14_arg1* arg1, s16 arg2, s16 arg3, s16 arg4, s16 arg5, s16 arg6, s16 arg7,
+                   u8 arg8) {
     s16 sp46;
     s16 sp44;
-    s16 temp1;
-    s16 sp40;
     s16 temp2;
+    s16 sp40;
+    s16 temp1;
     Vec3f sp30;
-    s16 temp3;
-    s16 temp4;
 
     sp30.x = actor->posRot.pos.x;
     sp30.y = actor->posRot.pos.y + arg1->unk_14;
@@ -4143,51 +3745,57 @@ void func_800344BC(Actor* actor, struct_80034A14_arg1* arg1, s16 arg2, s16 arg3,
 
     sp46 = Math_Vec3f_Pitch(&sp30, &arg1->unk_18);
     sp44 = Math_Vec3f_Yaw(&sp30, &arg1->unk_18);
+    sp40 = Math_Vec3f_Yaw(&actor->posRot.pos, &arg1->unk_18) - actor->shape.rot.y;
 
-    temp1 = Math_Vec3f_Yaw(&actor->posRot.pos, &arg1->unk_18) - actor->shape.rot.y;
+    temp1 = (sp40 < -arg2) ? -arg2 : ((sp40 > arg2) ? arg2 : sp40);
+    Math_SmoothScaleMaxMinS(&arg1->unk_0A, temp1, 6, 2000, 1);
 
-    Math_SmoothScaleMaxMinS(&arg1->unk_0A, (temp1 < -arg2) ? -arg2 : ((temp1 > arg2) ? arg2 : temp1), 6, 2000, 1);
+    sp40 = (ABS(sp40) >= 0x8000) ? 0 : ((sp40 >= 0) ? sp40 : -sp40);
+    arg1->unk_0A = ((arg1->unk_0A < -sp40) ? -sp40 : ((arg1->unk_0A > sp40) ? sp40 : arg1->unk_0A));
 
-    temp3 = (ABS(temp1) >= 0x8000) ? 0 : ((temp1 >= 0) ? temp1 : -temp1);
-    arg1->unk_0A = ((arg1->unk_0A < -temp3) ? -temp3 : ((arg1->unk_0A > temp3) ? temp3 : arg1->unk_0A));
+    sp40 = sp40 - arg1->unk_0A;
 
-    sp40 = temp1 - arg1->unk_0A;
-    Math_SmoothScaleMaxMinS(&arg1->unk_10, (sp40 < -arg5) ? -arg5 : ((sp40 > arg5) ? arg5 : sp40), 6, 2000, 1);
+    temp1 = (sp40 < -arg5) ? -arg5 : ((sp40 > arg5) ? arg5 : sp40);
+    Math_SmoothScaleMaxMinS(&arg1->unk_10, temp1, 6, 2000, 1);
 
-    temp4 = (ABS(sp40) >= 0x8000) ? 0 : ((sp40 >= 0) ? sp40 : -sp40);
-    arg1->unk_10 = ((arg1->unk_10 < -temp4) ? -temp4 : ((arg1->unk_10 > temp4) ? temp4 : arg1->unk_10));
+    sp40 = (ABS(sp40) >= 0x8000) ? 0 : ((sp40 >= 0) ? sp40 : -sp40);
+    arg1->unk_10 = ((arg1->unk_10 < -sp40) ? -sp40 : ((arg1->unk_10 > sp40) ? sp40 : arg1->unk_10));
 
-    if (arg8 != 0)
+    if (arg8 != 0) {
+        if (arg3) {} // Seems necessary to match
         Math_SmoothScaleMaxMinS(&actor->shape.rot.y, sp44, 6, 2000, 1);
+    }
 
-    Math_SmoothScaleMaxMinS(&arg1->unk_08, (sp46 < arg4) ? arg4 : ((sp46 > arg3) ? arg3 : sp46), 6, 2000, 1);
+    temp1 = (sp46 < arg4) ? arg4 : ((sp46 > arg3) ? arg3 : sp46);
+    Math_SmoothScaleMaxMinS(&arg1->unk_08, temp1, 6, 2000, 1);
 
     temp2 = sp46 - arg1->unk_08;
-    Math_SmoothScaleMaxMinS(&arg1->unk_0E, (temp2 < arg7) ? arg4 : ((temp2 > arg6) ? arg3 : temp2), 6, 2000, 1);
+
+    temp1 = (temp2 < arg7) ? arg7 : ((temp2 > arg6) ? arg6 : temp2);
+    Math_SmoothScaleMaxMinS(&arg1->unk_0E, temp1, 6, 2000, 1);
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_actor/func_800344BC.s")
 #endif
 
-s16 func_800347E8(s16 arg0)
-{
+s16 func_800347E8(s16 arg0) {
     return D_80116130[arg0].unk_14;
 }
 
-s16 func_80034810(Actor* actor, struct_80034A14_arg1* arg1, f32 arg2, s16 arg3, s16 arg4)
-{
+s16 func_80034810(Actor* actor, struct_80034A14_arg1* arg1, f32 arg2, s16 arg3, s16 arg4) {
     s32 pad;
     s16 var;
     s16 abs_var;
 
-    if (arg4 != 0)
+    if (arg4 != 0) {
         return arg4;
+    }
 
-    if (arg1->unk_00 != 0)
+    if (arg1->unk_00 != 0) {
         return 4;
+    }
 
-    if (arg2 < Math_Vec3f_DistXYZ(&actor->posRot.pos, &arg1->unk_18))
-    {
+    if (arg2 < Math_Vec3f_DistXYZ(&actor->posRot.pos, &arg1->unk_18)) {
         arg1->unk_04 = 0;
         arg1->unk_06 = 0;
         return 1;
@@ -4195,18 +3803,17 @@ s16 func_80034810(Actor* actor, struct_80034A14_arg1* arg1, f32 arg2, s16 arg3,
 
     var = Math_Vec3f_Yaw(&actor->posRot.pos, &arg1->unk_18);
     abs_var = ABS((s16)((f32)var - actor->shape.rot.y));
-    if (arg3 >= abs_var)
-    {
+    if (arg3 >= abs_var) {
         arg1->unk_04 = 0;
         arg1->unk_06 = 0;
         return 2;
     }
 
-    if (DECR(arg1->unk_04) != 0)
+    if (DECR(arg1->unk_04) != 0) {
         return arg1->unk_02;
+    }
 
-    switch (arg1->unk_06)
-    {
+    switch (arg1->unk_06) {
         case 0:
         case 2:
             arg1->unk_04 = Math_Rand_S16Offset(30, 30);
@@ -4221,16 +3828,14 @@ s16 func_80034810(Actor* actor, struct_80034A14_arg1* arg1, f32 arg2, s16 arg3,
     return 4;
 }
 
-void func_80034A14(Actor* actor, struct_80034A14_arg1* arg1, s16 arg2, s16 arg3)
-{
+void func_80034A14(Actor* actor, struct_80034A14_arg1* arg1, s16 arg2, s16 arg3) {
     struct_80116130_0 sp38;
 
     arg1->unk_02 = func_80034810(actor, arg1, D_80116130[arg2].unk_10, D_80116130[arg2].unk_14, arg3);
 
     sp38 = D_80116130[arg2].sub_00;
 
-    switch (arg1->unk_02)
-    {
+    switch (arg1->unk_02) {
         case 1:
             sp38.unk_00 = 0;
             sp38.unk_04 = 0;
@@ -4243,12 +3848,11 @@ void func_80034A14(Actor* actor, struct_80034A14_arg1* arg1, s16 arg2, s16 arg3)
             sp38.unk_0C = 0;
     }
 
-    func_800344BC(actor, arg1, sp38.unk_00, sp38.unk_04, sp38.unk_02,
-                  sp38.unk_06, sp38.unk_0A, sp38.unk_08, sp38.unk_0C);
+    func_800344BC(actor, arg1, sp38.unk_00, sp38.unk_04, sp38.unk_02, sp38.unk_06, sp38.unk_0A, sp38.unk_08,
+                  sp38.unk_0C);
 }
 
-Gfx* func_80034B28(GraphicsContext* gfxCtx)
-{
+Gfx* func_80034B28(GraphicsContext* gfxCtx) {
     Gfx* displayList;
 
     displayList = Graph_Alloc(gfxCtx, sizeof(Gfx));
@@ -4259,19 +3863,16 @@ Gfx* func_80034B28(GraphicsContext* gfxCtx)
 
 #ifdef NON_MATCHING
 // doesn't generate the 2 useless move instructions before returning
-Gfx* func_80034B54(GraphicsContext* gfxCtx)
-{
+Gfx* func_80034B54(GraphicsContext* gfxCtx) {
     Gfx* displayList;
     Gfx* displayListHead;
 
     displayList = Graph_Alloc(gfxCtx, 2 * sizeof(Gfx));
     displayListHead = displayList;
 
-    gDPSetRenderMode(displayListHead++,
-        AA_EN | Z_CMP | Z_UPD | IM_RD | CLR_ON_CVG | CVG_DST_WRAP | ZMODE_XLU | FORCE_BL |
-        GBL_c1(G_BL_CLR_FOG, G_BL_A_SHADE, G_BL_CLR_IN, G_BL_1MA),
-        AA_EN | Z_CMP | Z_UPD | IM_RD | CLR_ON_CVG | CVG_DST_WRAP | ZMODE_XLU | FORCE_BL |
-        GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_1MA));
+    gDPSetRenderMode(displayListHead++, G_RM_FOG_SHADE_A,
+                     AA_EN | Z_CMP | Z_UPD | IM_RD | CLR_ON_CVG | CVG_DST_WRAP | ZMODE_XLU | FORCE_BL |
+                         GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_1MA));
 
     gSPEndDisplayList(displayListHead);
 
@@ -4281,12 +3882,12 @@ Gfx* func_80034B54(GraphicsContext* gfxCtx)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_actor/func_80034B54.s")
 #endif
 
-void func_80034BA0(GlobalContext* globalCtx, SkelAnime* skelAnime, void* unkFunc1, void* unkFunc2, Actor* actor, s16 alpha)
-{
+void func_80034BA0(GlobalContext* globalCtx, SkelAnime* skelAnime, SkelAnime_LimbUpdateMatrix2 unkFunc1,
+                   SkelAnime_LimbAppendDlist2 unkFunc2, Actor* actor, s16 alpha) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8831);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 8831);
 
     func_80093D18(globalCtx->state.gfxCtx);
 
@@ -4295,18 +3896,18 @@ void func_80034BA0(GlobalContext* globalCtx, SkelAnime* skelAnime, void* unkFunc
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gSPSegment(gfxCtx->polyOpa.p++, 0x0C, func_80034B28(globalCtx->state.gfxCtx));
 
-    gfxCtx->polyOpa.p = func_800A273C(globalCtx, skelAnime->limbIndex, skelAnime->actorDrawTbl,
-                                      skelAnime->dListCount, unkFunc1, unkFunc2, actor, gfxCtx->polyOpa.p);
+    gfxCtx->polyOpa.p = SkelAnime_DrawSV2(globalCtx, skelAnime->skeleton, skelAnime->actorDrawTbl,
+                                          skelAnime->dListCount, unkFunc1, unkFunc2, actor, gfxCtx->polyOpa.p);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8860);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 8860);
 }
 
-void func_80034CC4(GlobalContext* globalCtx, SkelAnime* skelAnime, void* unkFunc1, void* unkFunc2, Actor* actor, s16 alpha)
-{
+void func_80034CC4(GlobalContext* globalCtx, SkelAnime* skelAnime, SkelAnime_LimbUpdateMatrix2 unkFunc1,
+                   SkelAnime_LimbAppendDlist2 unkFunc2, Actor* actor, s16 alpha) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8876);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 8876);
 
     func_80093D84(globalCtx->state.gfxCtx);
 
@@ -4314,29 +3915,26 @@ void func_80034CC4(GlobalContext* globalCtx, SkelAnime* skelAnime, void* unkFunc
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x00, 0x00, 0x00, alpha);
     gSPSegment(gfxCtx->polyXlu.p++, 0x0C, func_80034B54(globalCtx->state.gfxCtx));
 
-    gfxCtx->polyXlu.p = func_800A273C(globalCtx, skelAnime->limbIndex, skelAnime->actorDrawTbl,
-                                      skelAnime->dListCount, unkFunc1, unkFunc2, actor, gfxCtx->polyXlu.p);
+    gfxCtx->polyXlu.p = SkelAnime_DrawSV2(globalCtx, skelAnime->skeleton, skelAnime->actorDrawTbl,
+                                          skelAnime->dListCount, unkFunc1, unkFunc2, actor, gfxCtx->polyXlu.p);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8904);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 8904);
 }
 
-s16 func_80034DD4(Actor* actor, GlobalContext* globalCtx, s16 arg2, f32 arg3)
-{
+s16 func_80034DD4(Actor* actor, GlobalContext* globalCtx, s16 arg2, f32 arg3) {
     Player* player = PLAYER;
     f32 var;
 
-    if ((globalCtx->csCtx.state != 0) || (D_8011D394 != 0))
+    if ((globalCtx->csCtx.state != 0) || (D_8011D394 != 0)) {
         var = Math_Vec3f_DistXYZ(&actor->posRot.pos, &globalCtx->view.eye) * 0.25f;
-    else
+    } else {
         var = Math_Vec3f_DistXYZ(&actor->posRot.pos, &player->actor.posRot.pos);
+    }
 
-    if (arg3 < var)
-    {
-        actor->flags &= ~0x1;
+    if (arg3 < var) {
+        actor->flags &= ~1;
         Math_SmoothScaleMaxMinS(&arg2, 0, 6, 0x14, 1);
-    }
-    else
-    {
+    } else {
         actor->flags |= 1;
         Math_SmoothScaleMaxMinS(&arg2, 0xFF, 6, 0x14, 1);
     }
@@ -4344,78 +3942,53 @@ s16 func_80034DD4(Actor* actor, GlobalContext* globalCtx, s16 arg2, f32 arg3)
     return arg2;
 }
 
-// Some animation related structure
-typedef struct
-{
-    /* 0x00 */ u32      animation;
-    /* 0x04 */ f32      playbackSpeed;
-    /* 0x08 */ f32      unk_08;
-    /* 0x0C */ f32      frameCount;
-    /* 0x10 */ u8       unk_10;
-    /* 0x14 */ f32      transitionRate;
-} struct_80034EC0_Entry; // size = 0x18
-
-void func_80034EC0(SkelAnime* skelAnime, struct_80034EC0_Entry* arg1, s32 arg2)
-{
+void func_80034EC0(SkelAnime* skelAnime, struct_80034EC0_Entry* arg1, s32 arg2) {
     f32 frameCount;
 
     arg1 += arg2;
 
-    if (arg1->frameCount > 0.0f)
+    if (arg1->frameCount > 0.0f) {
         frameCount = arg1->frameCount;
-    else
+    } else {
         frameCount = SkelAnime_GetFrameCount(arg1->animation);
+    }
 
-    SkelAnime_ChangeAnimation(skelAnime, arg1->animation, arg1->playbackSpeed,
-                              arg1->unk_08, frameCount, arg1->unk_10, arg1->transitionRate);
+    SkelAnime_ChangeAnim(skelAnime, arg1->animation, arg1->playbackSpeed, arg1->unk_08, frameCount, arg1->unk_10,
+                         arg1->transitionRate);
 }
 
-void func_80034F54(GlobalContext* globalCtx, s16* arg1, s16* arg2, s32 arg3)
-{
+void func_80034F54(GlobalContext* globalCtx, s16* arg1, s16* arg2, s32 arg3) {
     u32 frames = globalCtx->gameplayFrames;
     s32 i;
 
-    for (i = 0; i < arg3; i++)
-    {
+    for (i = 0; i < arg3; i++) {
         arg1[i] = (0x814 + 50 * i) * frames;
         arg2[i] = (0x940 + 50 * i) * frames;
     }
 }
 
-void Actor_Noop(Actor* actor, GlobalContext* globalCtx)
-{
-
+void Actor_Noop(Actor* actor, GlobalContext* globalCtx) {
 }
 
-s32 func_80035124(Actor* actor, GlobalContext* globalCtx)
-{
+s32 func_80035124(Actor* actor, GlobalContext* globalCtx) {
     s32 ret = 0;
 
-    switch (actor->params)
-    {
+    switch (actor->params) {
         case 0:
-            if (func_8002F410(actor, globalCtx))
-            {
+            if (func_8002F410(actor, globalCtx)) {
                 actor->params = 1;
-            }
-            else if (!(actor->bgCheckFlags & 1))
-            {
+            } else if (!(actor->bgCheckFlags & 1)) {
                 Actor_MoveForward(actor);
                 Math_SmoothScaleMaxMinF(&actor->speedXZ, 0.0f, 1.0f, 0.1f, 0.0f);
-            }
-            else if ((actor->bgCheckFlags & 2) && (actor->velocity.y < -4.0f))
-            {
+            } else if ((actor->bgCheckFlags & 2) && (actor->velocity.y < -4.0f)) {
                 ret = 1;
-            }
-            else
-            {
+            } else {
                 actor->shape.rot.x = actor->shape.rot.z = 0;
                 func_8002F580(actor, globalCtx);
             }
             break;
         case 1:
-            if (func_8002F5A0(actor, globalCtx))
-            {
+            if (func_8002F5A0(actor, globalCtx)) {
                 actor->params = 0;
             }
             break;
@@ -4426,38 +3999,9 @@ s32 func_80035124(Actor* actor, GlobalContext* globalCtx)
     return ret;
 }
 
-/* z_cheap_proc.c */
-
-void Draw_DListOpa(GlobalContext* globalCtx, u32 dlist)
-{
-    GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
-
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 214);
+#include "z_cheap_proc.c"
 
-    func_80093D18(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_cheap_proc.c", 216), G_MTX_MODELVIEW | G_MTX_LOAD);
-    gSPDisplayList(gfxCtx->polyOpa.p++, dlist);
-
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 219);
-}
-
-void Draw_DListXlu(GlobalContext* globalCtx, u32 dlist)
-{
-    GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
-
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 228);
-
-    func_80093D84(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_cheap_proc.c", 230), G_MTX_MODELVIEW | G_MTX_LOAD);
-    gSPDisplayList(gfxCtx->polyXlu.p++, dlist);
-
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 233);
-}
-
-u8 func_800353E8(GlobalContext* globalCtx)
-{
+u8 func_800353E8(GlobalContext* globalCtx) {
     Player* player = PLAYER;
     return player->unk_845;
 }
@@ -4466,30 +4010,25 @@ u8 func_800353E8(GlobalContext* globalCtx)
  * Finds the first actor instance of a specified id and type within a given range from an actor if there is one.
  * If the id provided is -1, this will look for any actor of the specified type rather than a specific id.
  */
-Actor* Actor_FindNearby(GlobalContext* globalCtx, Actor* refActor, s16 actorId, u8 actorType, f32 range)
-{
+Actor* Actor_FindNearby(GlobalContext* globalCtx, Actor* refActor, s16 actorId, u8 actorType, f32 range) {
     Actor* actor = globalCtx->actorCtx.actorList[actorType].first;
 
-    while (actor != NULL)
-    {
-        if (actor == refActor || ((actorId != -1) && (actorId != actor->id)))
-        {
+    while (actor != NULL) {
+        if (actor == refActor || ((actorId != -1) && (actorId != actor->id))) {
             actor = actor->next;
-        }
-        else
-        {
-            if (func_8002DB48(refActor, actor) <= range)
+        } else {
+            if (func_8002DB48(refActor, actor) <= range) {
                 return actor;
-            else
+            } else {
                 actor = actor->next;
+            }
         }
     }
 
     return NULL;
 }
 
-s32 func_800354B4(GlobalContext* globalCtx, Actor* actor, f32 range, s16 arg3, s16 arg4, s16 arg5)
-{
+s32 func_800354B4(GlobalContext* globalCtx, Actor* actor, f32 range, s16 arg3, s16 arg4, s16 arg5) {
     Player* player = PLAYER;
     s16 var1;
     s16 var2;
@@ -4497,15 +4036,15 @@ s32 func_800354B4(GlobalContext* globalCtx, Actor* actor, f32 range, s16 arg3, s
     var1 = (s16)(actor->rotTowardsLinkY + 0x8000) - player->actor.shape.rot.y;
     var2 = actor->rotTowardsLinkY - arg5;
 
-    if ((actor->xzDistanceFromLink <= range) && (player->swordState != 0) &&
-        (arg4 >= ABS(var1)) && (arg3 >= ABS(var2)))
+    if ((actor->xzDistanceFromLink <= range) && (player->swordState != 0) && (arg4 >= ABS(var1)) &&
+        (arg3 >= ABS(var2))) {
         return 1;
-    else
+    } else {
         return 0;
+    }
 }
 
-void func_8003555C(GlobalContext* globalCtx, Vec3f* arg1, Vec3f* arg2, Vec3f* arg3)
-{
+void func_8003555C(GlobalContext* globalCtx, Vec3f* arg1, Vec3f* arg2, Vec3f* arg3) {
     Color_RGB8 color1;
     Color_RGB8 color2;
 
@@ -4523,151 +4062,105 @@ void func_8003555C(GlobalContext* globalCtx, Vec3f* arg1, Vec3f* arg2, Vec3f* ar
 Vec3f D_80116268 = { 0.0f, -1.5f, 0.0f };
 Vec3f D_80116274 = { 0.0f, -0.2f, 0.0f };
 
-// unused
-Gfx D_80116280[] =
-{
-    gsDPSetRenderMode(AA_EN | Z_CMP | Z_UPD | IM_RD | CLR_ON_CVG |
-                      CVG_DST_WRAP | ZMODE_XLU | FORCE_BL |
-                      GBL_c1(G_BL_CLR_FOG, G_BL_A_SHADE, G_BL_CLR_IN, G_BL_1MA),
-                      AA_EN | Z_CMP | Z_UPD | IM_RD | CLR_ON_CVG |
-                      CVG_DST_WRAP | ZMODE_XLU | FORCE_BL |
-                      GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_1MA)),
+Gfx D_80116280[] = {
+    gsDPSetRenderMode(G_RM_FOG_SHADE_A, AA_EN | Z_CMP | Z_UPD | IM_RD | CLR_ON_CVG | CVG_DST_WRAP | ZMODE_XLU |
+                                            FORCE_BL | GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_1MA)),
     gsDPSetAlphaCompare(G_AC_THRESHOLD),
     gsSPEndDisplayList(),
 };
 
-void func_800355B8(GlobalContext* globalCtx, Vec3f* arg1)
-{
+void func_800355B8(GlobalContext* globalCtx, Vec3f* arg1) {
     func_8003555C(globalCtx, arg1, &D_80116268, &D_80116274);
 }
 
-u8 func_800355E4(GlobalContext* globalCtx, ColliderCylinderInit* colCylinderInit)
-{
+u8 func_800355E4(GlobalContext* globalCtx, ColliderCylinderInit* colCylinderInit) {
     Player* player = PLAYER;
 
-    if ((colCylinderInit->inner.toucherDamage & 0x08) && (player->swordState != 0) && (player->swordAnimation == 0x16))
+    if ((colCylinderInit->inner.toucherDamage & 0x08) && (player->swordState != 0) &&
+        (player->swordAnimation == 0x16)) {
         return 1;
-    else
+    } else {
         return 0;
+    }
 }
 
-u8 Actor_ApplyDamage(Actor* actor)
-{
-    if (actor->sub_98.damage >= actor->sub_98.health)
+u8 Actor_ApplyDamage(Actor* actor) {
+    if (actor->sub_98.damage >= actor->sub_98.health) {
         actor->sub_98.health = 0;
-    else
+    } else {
         actor->sub_98.health -= actor->sub_98.damage;
+    }
 
     return actor->sub_98.health;
 }
 
-void func_80035650(Actor* actor, ColliderBody* colBody, s32 freezeFlag)
-{
-    if (colBody->colliding == NULL)
-    {
+void func_80035650(Actor* actor, ColliderBody* colBody, s32 freezeFlag) {
+    if (colBody->colliding == NULL) {
         actor->unk_116 = 0x00;
-    }
-    else if (freezeFlag && (colBody->colliding->toucher.flags & 0x10060000))
-    {
+    } else if (freezeFlag && (colBody->colliding->toucher.flags & 0x10060000)) {
         actor->freeze = colBody->colliding->toucher.damage;
         actor->unk_116 = 0x00;
-    }
-    else if (colBody->colliding->toucher.flags & 0x0800)
-    {
+    } else if (colBody->colliding->toucher.flags & 0x0800) {
         actor->unk_116 = 0x01;
-    }
-    else if (colBody->colliding->toucher.flags & 0x1000)
-    {
+    } else if (colBody->colliding->toucher.flags & 0x1000) {
         actor->unk_116 = 0x02;
-    }
-    else if (colBody->colliding->toucher.flags & 0x4000)
-    {
+    } else if (colBody->colliding->toucher.flags & 0x4000) {
         actor->unk_116 = 0x04;
-    }
-    else if (colBody->colliding->toucher.flags & 0x8000)
-    {
+    } else if (colBody->colliding->toucher.flags & 0x8000) {
         actor->unk_116 = 0x08;
-    }
-    else if ((colBody->colliding->toucher.flags << 0xF) < 0)
-    {
+    } else if ((colBody->colliding->toucher.flags << 0xF) < 0) {
         actor->unk_116 = 0x10;
-    }
-    else if (colBody->colliding->toucher.flags & 0x2000)
-    {
+    } else if (colBody->colliding->toucher.flags & 0x2000) {
         actor->unk_116 = 0x20;
-    }
-    else if ((colBody->colliding->toucher.flags << 0xC) < 0)
-    {
-        if (freezeFlag)
+    } else if ((colBody->colliding->toucher.flags << 0xC) < 0) {
+        if (freezeFlag) {
             actor->freeze = colBody->colliding->toucher.damage;
+        }
         actor->unk_116 = 0x40;
-    }
-    else
-    {
+    } else {
         actor->unk_116 = 0x00;
     }
 }
 
-void func_8003573C(Actor* actor, ColliderBody* colBody, s32 freezeFlag)
-{
+void func_8003573C(Actor* actor, ColliderBody* colBody, s32 freezeFlag) {
     ColliderBody* curColBody;
     s32 flag;
     s32 i;
 
     actor->unk_116 = 0x00;
 
-    for (i = colBody->unk_18 - 1; i >= 0; i--)
-    {
+    for (i = colBody->unk_18 - 1; i >= 0; i--) {
         curColBody = &colBody->colBuf[i].c;
-        if (curColBody->colliding == NULL)
-        {
+        if (curColBody->colliding == NULL) {
             flag = 0x00;
-        }
-        else if (freezeFlag && (curColBody->colliding->toucher.flags & 0x10060000))
-        {
+        } else if (freezeFlag && (curColBody->colliding->toucher.flags & 0x10060000)) {
             actor->freeze = curColBody->colliding->toucher.damage;
             flag = 0x00;
-        }
-        else if (curColBody->colliding->toucher.flags & 0x0800)
-        {
+        } else if (curColBody->colliding->toucher.flags & 0x0800) {
             flag = 0x01;
-        }
-        else if (curColBody->colliding->toucher.flags & 0x1000)
-        {
+        } else if (curColBody->colliding->toucher.flags & 0x1000) {
             flag = 0x02;
-        }
-        else if (curColBody->colliding->toucher.flags & 0x4000)
-        {
+        } else if (curColBody->colliding->toucher.flags & 0x4000) {
             flag = 0x04;
-        }
-        else if (curColBody->colliding->toucher.flags & 0x8000)
-        {
+        } else if (curColBody->colliding->toucher.flags & 0x8000) {
             flag = 0x08;
-        }
-        else if (curColBody->colliding->toucher.flags & 0x10000)
-        {
+        } else if (curColBody->colliding->toucher.flags & 0x10000) {
             flag = 0x10;
-        }
-        else if (curColBody->colliding->toucher.flags & 0x2000)
-        {
+        } else if (curColBody->colliding->toucher.flags & 0x2000) {
             flag = 0x20;
-        }
-        else if (curColBody->colliding->toucher.flags & 0x80000)
-        {
-            if (freezeFlag)
+        } else if (curColBody->colliding->toucher.flags & 0x80000) {
+            if (freezeFlag) {
                 actor->freeze = curColBody->colliding->toucher.damage;
+            }
             flag = 0x40;
-        }
-        else
-        {
+        } else {
             flag = 0x00;
         }
         actor->unk_116 |= flag;
     }
 }
 
-void func_80035844(Vec3f* arg0, Vec3f* arg1, s16* arg2, s32 arg3)
-{
+void func_80035844(Vec3f* arg0, Vec3f* arg1, s16* arg2, s32 arg3) {
     f32 dx = arg1->x - arg0->x;
     f32 dz = arg1->z - arg0->z;
     f32 dy = arg3 ? (arg1->y - arg0->y) : (arg0->y - arg1->y);
@@ -4679,17 +4172,14 @@ void func_80035844(Vec3f* arg0, Vec3f* arg1, s16* arg2, s32 arg3)
 /**
  * Spawns En_Part (Dissipating Flames) actor attached to the given actor.
  */
-ActorEnPart* func_800358DC(Actor* actor, Vec3f* spawnPos, Vec3s* spawnRot, Vec3f* arg3, s32 arg4,
-                           s32 unused, GlobalContext* globalCtx, s16 params, s32 arg8)
-{
+ActorEnPart* func_800358DC(Actor* actor, Vec3f* spawnPos, Vec3s* spawnRot, Vec3f* arg3, s32 arg4, s32 unused,
+                           GlobalContext* globalCtx, s16 params, s32 arg8) {
     ActorEnPart* spawnedEnPart;
 
     spawnedEnPart = (ActorEnPart*)Actor_SpawnAttached(&globalCtx->actorCtx, actor, globalCtx, ACTOR_EN_PART,
-                                                      spawnPos->x, spawnPos->y, spawnPos->z,
-                                                      spawnRot->x, spawnRot->y, actor->objBankIndex,
-                                                      params);
-    if (spawnedEnPart != NULL)
-    {
+                                                      spawnPos->x, spawnPos->y, spawnPos->z, spawnRot->x, spawnRot->y,
+                                                      actor->objBankIndex, params);
+    if (spawnedEnPart != NULL) {
         spawnedEnPart->actor.scale = actor->scale;
         spawnedEnPart->actor.speedXZ = arg3->x;
         spawnedEnPart->unk_150 = arg8;
@@ -4703,8 +4193,7 @@ ActorEnPart* func_800358DC(Actor* actor, Vec3f* spawnPos, Vec3s* spawnRot, Vec3f
     return NULL;
 }
 
-void func_800359B8(Actor* actor, s16 arg1, Vec3s* arg2)
-{
+void func_800359B8(Actor* actor, s16 arg1, Vec3s* arg2) {
     f32 sp44;
     f32 sp40;
     f32 sp3C;
@@ -4717,8 +4206,7 @@ void func_800359B8(Actor* actor, s16 arg1, Vec3s* arg2)
     CollisionPoly* floorPoly;
     s32 pad;
 
-    if (actor->floorPoly != NULL)
-    {
+    if (actor->floorPoly != NULL) {
         floorPoly = actor->floorPoly;
         sp44 = floorPoly->norm.x * (1.f / 32767);
         sp40 = floorPoly->norm.y * (1.f / 32767);
@@ -4727,17 +4215,16 @@ void func_800359B8(Actor* actor, s16 arg1, Vec3s* arg2)
         sp38 = Math_Sins(arg1);
         sp34 = Math_Coss(arg1);
         sp28 = (-(sp44 * sp38) - (sp3C * sp34));
-        arg2->x = -(s16)(func_800FD250(sp28 * sp40, 1.0f) * (32768 / M_PI));
+        arg2->x = -(s16)(Math_atan2f(sp28 * sp40, 1.0f) * (32768 / M_PI));
 
         sp2C = Math_Sins(arg1 - 16375);
         sp30 = Math_Coss(arg1 - 16375);
         sp24 = (-(sp44 * sp2C) - (sp3C * sp30));
-        arg2->z = -(s16)(func_800FD250(sp24 * sp40, 1.0f) * (32768 / M_PI));
+        arg2->z = -(s16)(Math_atan2f(sp24 * sp40, 1.0f) * (32768 / M_PI));
     }
 }
 
-void func_80035B18(GlobalContext* globalCtx, Actor* actor, u16 textId)
-{
+void func_80035B18(GlobalContext* globalCtx, Actor* actor, u16 textId) {
     func_8010B720(globalCtx, textId);
     actor->textId = textId;
 }
@@ -4745,496 +4232,458 @@ void func_80035B18(GlobalContext* globalCtx, Actor* actor, u16 textId)
 /**
  * Tests if event_chk_inf flag is set.
  */
-s32 Flags_GetEventChkInf(s32 flag)
-{
+s32 Flags_GetEventChkInf(s32 flag) {
     return gSaveContext.event_chk_inf[flag >> 4] & (1 << (flag & 0xF));
 }
 
 /**
  * Sets event_chk_inf flag.
  */
-void Flags_SetEventChkInf(s32 flag)
-{
+void Flags_SetEventChkInf(s32 flag) {
     gSaveContext.event_chk_inf[flag >> 4] |= (1 << (flag & 0xF));
 }
 
 /**
  * Tests if inf_table flag is set.
  */
-s32 Flags_GetInfTable(s32 flag)
-{
+s32 Flags_GetInfTable(s32 flag) {
     return gSaveContext.inf_table[flag >> 4] & (1 << (flag & 0xF));
 }
 
 /**
  * Sets inf_table flag.
  */
-void Flags_SetInfTable(s32 flag)
-{
+void Flags_SetInfTable(s32 flag) {
     gSaveContext.inf_table[flag >> 4] |= (1 << (flag & 0xF));
 }
 
-u32 func_80035BFC(GlobalContext* globalCtx, s16 arg1)
-{
+u32 func_80035BFC(GlobalContext* globalCtx, s16 arg1) {
     u16 retTextId = 0;
 
-    switch(arg1)
-    {
+    switch (arg1) {
         case 0:
-            if (Flags_GetEventChkInf(0x9))
-            {
-                if (Flags_GetInfTable(0x5))
+            if (Flags_GetEventChkInf(0x9)) {
+                if (Flags_GetInfTable(0x5)) {
                     retTextId = 0x1048;
-                else
+                } else {
                     retTextId = 0x1047;
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x2))
-                {
-                    if (Flags_GetInfTable(0x3))
+                }
+            } else {
+                if (Flags_GetEventChkInf(0x2)) {
+                    if (Flags_GetInfTable(0x3)) {
                         retTextId = 0x1032;
-                    else
+                    } else {
                         retTextId = 0x1031;
-                }
-                else
-                {
-                    if (Flags_GetInfTable(0x0))
-                    {
-                        if (Flags_GetInfTable(0x1))
+                    }
+                } else {
+                    if (Flags_GetInfTable(0x0)) {
+                        if (Flags_GetInfTable(0x1)) {
                             retTextId = 0x1003;
-                        else
+                        } else {
                             retTextId = 0x1002;
-                    }
-                    else
+                        }
+                    } else {
                         retTextId = 0x1001;
+                    }
                 }
             }
             break;
         case 1:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x9))
-                {
-                    if (Flags_GetInfTable(0x10))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x9)) {
+                    if (Flags_GetInfTable(0x10)) {
                         retTextId = 0x1046;
-                    else
+                    } else {
                         retTextId = 0x1045;
-                }
-                else
-                {
-                    if (Flags_GetEventChkInf(0x3))
-                    {
-                        if (Flags_GetInfTable(0xE))
+                    }
+                } else {
+                    if (Flags_GetEventChkInf(0x3)) {
+                        if (Flags_GetInfTable(0xE)) {
                             retTextId = 0x1034;
-                        else
+                        } else {
                             retTextId = 0x1033;
-                    }
-                    else
-                    {
-                        if (Flags_GetInfTable(0xC))
+                        }
+                    } else {
+                        if (Flags_GetInfTable(0xC)) {
                             retTextId = 0x1030;
-                        else
+                        } else {
                             retTextId = 0x102F;
+                        }
                     }
                 }
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x5C))
-                {
-                    if (Flags_GetInfTable(0x19))
+            } else {
+                if (Flags_GetEventChkInf(0x5C)) {
+                    if (Flags_GetInfTable(0x19)) {
                         retTextId = 0x1071;
-                    else
+                    } else {
                         retTextId = 0x1070;
-                }
-                else
-                {
-                    if (Flags_GetEventChkInf(0xB))
-                    {
-                        if (Flags_GetInfTable(0x17))
+                    }
+                } else {
+                    if (Flags_GetEventChkInf(0xB)) {
+                        if (Flags_GetInfTable(0x17)) {
                             retTextId = 0x1068;
-                        else
+                        } else {
                             retTextId = 0x1067;
-                    }
-                    else
-                    {
-                        if (Flags_GetInfTable(0x15))
+                        }
+                    } else {
+                        if (Flags_GetInfTable(0x15)) {
                             retTextId = 0x1061;
-                        else
+                        } else {
                             retTextId = 0x1060;
+                        }
                     }
                 }
             }
             break;
         case 2:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x9))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x9)) {
                     retTextId = 0x1042;
-                else
+                } else {
                     retTextId = 0x1004;
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x5C))
+                }
+            } else {
+                if (Flags_GetEventChkInf(0x5C)) {
                     retTextId = 0x1072;
-                else if (Flags_GetInfTable(0x41))
+                } else if (Flags_GetInfTable(0x41)) {
                     retTextId = 0x1055;
-                else
+                } else {
                     retTextId = 0x1056;
+                }
             }
             break;
         case 3:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x9))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x9)) {
                     retTextId = 0x1043;
-                else
-                {
-                    if (Flags_GetInfTable(0x1E))
+                } else {
+                    if (Flags_GetInfTable(0x1E)) {
                         retTextId = 0x1006;
-                    else
+                    } else {
                         retTextId = 0x1005;
+                    }
                 }
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x5C))
+            } else {
+                if (Flags_GetEventChkInf(0x5C)) {
                     retTextId = 0x1073;
-                else
+                } else {
                     retTextId = 0x105A;
+                }
             }
             break;
         case 4:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x9))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x9)) {
                     retTextId = 0x1042;
-                else
+                } else {
                     retTextId = 0x1007;
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x5C))
+                }
+            } else {
+                if (Flags_GetEventChkInf(0x5C)) {
                     retTextId = 0x1072;
-                else if (Flags_GetInfTable(0x47))
+                } else if (Flags_GetInfTable(0x47)) {
                     retTextId = 0x105E;
-                else
+                } else {
                     retTextId = 0x105D;
+                }
             }
             break;
         case 5:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x9))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x9)) {
                     retTextId = 0x1044;
-                else if (Flags_GetInfTable(0x22))
+                } else if (Flags_GetInfTable(0x22)) {
                     retTextId = 0x1009;
-                else
+                } else {
                     retTextId = 0x1008;
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x5C))
+                }
+            } else {
+                if (Flags_GetEventChkInf(0x5C)) {
                     retTextId = 0x1075;
-                else
+                } else {
                     retTextId = 0x105B;
+                }
             }
             break;
         case 6:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x9))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x9)) {
                     retTextId = 0x1042;
-                else if (Flags_GetInfTable(0x24))
+                } else if (Flags_GetInfTable(0x24)) {
                     retTextId = 0x100B;
-                else
+                } else {
                     retTextId = 0x100A;
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x5C))
+                }
+            } else {
+                if (Flags_GetEventChkInf(0x5C)) {
                     retTextId = 0x1056;
-                else
+                } else {
                     retTextId = 0x105F;
+                }
             }
             break;
         case 7:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x9))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x9)) {
                     retTextId = 0x1043;
-                else if (Flags_GetInfTable(0x26))
+                } else if (Flags_GetInfTable(0x26)) {
                     retTextId = 0x100D;
-                else
+                } else {
                     retTextId = 0x100C;
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x5C))
+                }
+            } else {
+                if (Flags_GetEventChkInf(0x5C)) {
                     retTextId = 0x1057;
-                else
+                } else {
                     retTextId = 0x1057;
+                }
             }
             break;
         case 8:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x9))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x9)) {
                     retTextId = 0x1043;
-                else if (Flags_GetInfTable(0x28))
+                } else if (Flags_GetInfTable(0x28)) {
                     retTextId = 0x1019;
-                else
+                } else {
                     retTextId = 0x100E;
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x5C))
+                }
+            } else {
+                if (Flags_GetEventChkInf(0x5C)) {
                     retTextId = 0x1077;
-                else if (Flags_GetInfTable(0x51))
+                } else if (Flags_GetInfTable(0x51)) {
                     retTextId = 0x1058;
-                else
+                } else {
                     retTextId = 0x1059;
+                }
             }
             break;
         case 9:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x9))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x9)) {
                     retTextId = 0x1049;
-                else
+                } else {
                     retTextId = 0x1035;
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x5C))
+                }
+            } else {
+                if (Flags_GetEventChkInf(0x5C)) {
                     retTextId = 0x1079;
-                else
+                } else {
                     retTextId = 0x104e;
+                }
             }
             break;
         case 10:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x9))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x9)) {
                     retTextId = 0x104A;
-                else
+                } else {
                     retTextId = 0x1038;
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x5C))
+                }
+            } else {
+                if (Flags_GetEventChkInf(0x5C)) {
                     retTextId = 0x1079;
-                else if (Flags_GetInfTable(0x59))
+                } else if (Flags_GetInfTable(0x59)) {
                     retTextId = 0x1050;
-                else
+                } else {
                     retTextId = 0x104F;
+                }
             }
             break;
         case 11:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x9))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x9)) {
                     retTextId = 0x104B;
-                else
+                } else {
                     retTextId = 0x103C;
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x5C))
+                }
+            } else {
+                if (Flags_GetEventChkInf(0x5C)) {
                     retTextId = 0x107b;
-                else
+                } else {
                     retTextId = 0x1051;
+                }
             }
             break;
         case 12:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x9))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x9)) {
                     retTextId = 0x104C;
-                else
+                } else {
                     retTextId = 0x103D;
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x5C))
+                }
+            } else {
+                if (Flags_GetEventChkInf(0x5C)) {
                     retTextId = 0x107C;
-                else
+                } else {
                     retTextId = 0x1052;
+                }
             }
             break;
         case 13:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x9))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x9)) {
                     retTextId = 0x104D;
-                else
+                } else {
                     retTextId = 0x103E;
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x5C))
+                }
+            } else {
+                if (Flags_GetEventChkInf(0x5C)) {
                     retTextId = 0x106E;
-                else if (Flags_GetInfTable(0x61))
+                } else if (Flags_GetInfTable(0x61)) {
                     retTextId = 0x1053;
-                else
+                } else {
                     retTextId = 0x1054;
+                }
             }
             break;
         case 15:
-            if (Flags_GetEventChkInf(0x5C))
+            if (Flags_GetEventChkInf(0x5C)) {
                 retTextId = 0x1078;
-            else if (Flags_GetInfTable(0x66))
+            } else if (Flags_GetInfTable(0x66)) {
                 retTextId = 0x1066;
-            else
+            } else {
                 retTextId = 0x1062;
+            }
             break;
         case 16:
-            if (globalCtx->sceneNum == SCENE_SPOT15)
+            if (globalCtx->sceneNum == SCENE_SPOT15) {
                 retTextId = 0x7002;
-            else if (Flags_GetInfTable(0x6A))
+            } else if (Flags_GetInfTable(0x6A)) {
                 retTextId = 0x7004;
-            else if ((gSaveContext.day_time >= 0x4000) && (gSaveContext.day_time < 0xC556))
+            } else if ((gSaveContext.day_time >= 0x4000) && (gSaveContext.day_time < 0xC556)) {
                 retTextId = 0x7002;
-            else
+            } else {
                 retTextId = 0x7003;
+            }
             break;
         case 17:
-            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37))
-            {
-                if (Flags_GetInfTable(0x6c))
+            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37)) {
+                if (Flags_GetInfTable(0x6c)) {
                     retTextId = 0x7008;
-                else
+                } else {
                     retTextId = 0x7007;
-            }
-            else
+                }
+            } else {
                 retTextId = 0;
+            }
             break;
         case 19:
             retTextId = 0x702D;
             break;
         case 18:
-            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37))
+            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37)) {
                 retTextId = 0x7006;
-            else
-            {
-                if (Flags_GetEventChkInf(0x12))
-                {
-                    if (Flags_GetInfTable(0x71))
+            } else {
+                if (Flags_GetEventChkInf(0x12)) {
+                    if (Flags_GetInfTable(0x71)) {
                         retTextId = 0x7072;
-                    else
+                    } else {
                         retTextId = 0x7071;
-                }
-                else
+                    }
+                } else {
                     retTextId = 0x7029;
+                }
             }
             break;
         case 20:
         case 21:
-            if (Flags_GetEventChkInf(0x42))
+            if (Flags_GetEventChkInf(0x42)) {
                 retTextId = 0x2012;
-            else if (Flags_GetEventChkInf(0x41))
-            {
-                if (Flags_GetInfTable(0x76))
+            } else if (Flags_GetEventChkInf(0x41)) {
+                if (Flags_GetInfTable(0x76)) {
                     retTextId = 0x2011;
-                else
+                } else {
                     retTextId = 0x2010;
-            }
-            else if (Flags_GetEventChkInf(0x40))
+                }
+            } else if (Flags_GetEventChkInf(0x40)) {
                 retTextId = 0x200F;
-            else
+            } else {
                 retTextId = 0x200E;
+            }
             break;
         case 24:
-            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37))
+            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37)) {
                 retTextId = 0x7044;
-            else
+            } else {
                 retTextId = 0x7015;
+            }
             break;
         case 25:
-            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37))
+            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37)) {
                 retTextId = 0x7045;
-            else
-            {
+            } else {
                 Flags_GetInfTable(0xC2);
                 retTextId = 0x7016;
             }
             break;
         case 26:
-            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37))
+            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37)) {
                 retTextId = 0x7046;
-            else
-            {
+            } else {
                 Flags_GetInfTable(0xc2);
                 retTextId = 0x7018;
             }
             break;
         case 27:
-            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37))
+            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37)) {
                 retTextId = 0x7047;
-            else if (Flags_GetEventChkInf(0x14))
+            } else if (Flags_GetEventChkInf(0x14)) {
                 retTextId = 0x701A;
-            else if (Flags_GetEventChkInf(0x11))
-            {
-                if (Flags_GetInfTable(0xC6))
+            } else if (Flags_GetEventChkInf(0x11)) {
+                if (Flags_GetInfTable(0xC6)) {
                     retTextId = 0x701C;
-                else
+                } else {
                     retTextId = 0x701B;
-            }
-            else
+                }
+            } else {
                 retTextId = 0x701A;
+            }
             break;
         case 28:
-            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37))
+            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37)) {
                 retTextId = 0x7048;
-            else
-            {
+            } else {
                 Flags_GetInfTable(0xca);
                 retTextId = 0x701D;
             }
             break;
         case 29:
-            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37))
+            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37)) {
                 retTextId = 0x7049;
-            else
-            {
+            } else {
                 Flags_GetInfTable(0xcc);
                 retTextId = 0x701F;
             }
             break;
         case 30:
-            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37))
+            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37)) {
                 retTextId = 0x704A;
-            else
-            {
+            } else {
                 Flags_GetInfTable(0xCE);
                 retTextId = 0x7021;
             }
             break;
         case 31:
-            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37))
+            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37)) {
                 retTextId = 0x704B;
-            else
-            {
+            } else {
                 Flags_GetInfTable(0xD0);
                 retTextId = 0x7023;
             }
             break;
         case 32:
-            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37))
+            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37)) {
                 retTextId = 0x704C;
-            else
-            {
+            } else {
                 Flags_GetInfTable(0xD2);
                 retTextId = 0x7025;
             }
             break;
         case 33:
-            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37))
+            if (Flags_GetEventChkInf(0x9) && Flags_GetEventChkInf(0x25) && Flags_GetEventChkInf(0x37)) {
                 retTextId = 0x704D;
-            else
-            {
+            } else {
                 Flags_GetInfTable(0xD4);
                 retTextId = 0x7027;
             }
@@ -5244,213 +4693,212 @@ u32 func_80035BFC(GlobalContext* globalCtx, s16 arg1)
             retTextId = 0x403C;
             break;
         case 35:
-            if (Flags_GetInfTable(0xD8))
+            if (Flags_GetInfTable(0xD8)) {
                 retTextId = 0x5029;
-            else
+            } else {
                 retTextId = 0x5028;
+            }
             break;
         case 37:
             retTextId = 0x5002;
             break;
         case 38:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x25))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x25)) {
                     retTextId = 0x3027;
-                else if (Flags_GetEventChkInf(0x23))
+                } else if (Flags_GetEventChkInf(0x23)) {
                     retTextId = 0x3021;
-                else if (Flags_GetInfTable(0xE0))
+                } else if (Flags_GetInfTable(0xE0)) {
                     retTextId = 0x302A;
-                else
+                } else {
                     retTextId = 0x3008;
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x20))
+                }
+            } else {
+                if (Flags_GetEventChkInf(0x20)) {
                     retTextId = 0x4043;
-                else
+                } else {
                     retTextId = 0x302A;
+                }
             }
             break;
         case 39:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x25))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x25)) {
                     retTextId = 0x3027;
-                else if (Flags_GetEventChkInf(0x23))
+                } else if (Flags_GetEventChkInf(0x23)) {
                     retTextId = 0x3026;
-                else
+                } else {
                     retTextId = 0x3009;
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x2A))
+                }
+            } else {
+                if (Flags_GetEventChkInf(0x2A)) {
                     retTextId = 0x4043;
-                else
+                } else {
                     retTextId = 0x302A;
+                }
             }
             break;
         case 40:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x25))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x25)) {
                     retTextId = 0x3027;
-                else if (Flags_GetEventChkInf(0x23))
+                } else if (Flags_GetEventChkInf(0x23)) {
                     retTextId = 0x3026;
-                else if (Flags_GetInfTable(0xEB))
+                } else if (Flags_GetInfTable(0xEB)) {
                     retTextId = 0x302B;
-                else
+                } else {
                     retTextId = 0x300A;
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x2B))
+                }
+            } else {
+                if (Flags_GetEventChkInf(0x2B)) {
                     retTextId = 0x4043;
-                else
+                } else {
                     retTextId = 0x302A;
+                }
             }
             break;
         case 41:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x25))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x25)) {
                     retTextId = 0x3027;
-                else if (Flags_GetInfTable(0xF0))
+                } else if (Flags_GetInfTable(0xF0)) {
                     retTextId = 0x3015;
-                else
+                } else {
                     retTextId = 0x3014;
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x2C))
+                }
+            } else {
+                if (Flags_GetEventChkInf(0x2C)) {
                     retTextId = 0x4043;
-                else
+                } else {
                     retTextId = 0x302A;
+                }
             }
             break;
         case 42:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x25))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x25)) {
                     retTextId = 0x3027;
-                else if (Flags_GetInfTable(0xF4))
+                } else if (Flags_GetInfTable(0xF4)) {
                     retTextId = 0x3017;
-                else
+                } else {
                     retTextId = 0x3016;
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x2C))
+                }
+            } else {
+                if (Flags_GetEventChkInf(0x2C)) {
                     retTextId = 0x4043;
-                else
+                } else {
                     retTextId = 0x302A;
+                }
             }
             break;
         case 43:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x25))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x25)) {
                     retTextId = 0x3027;
-                else if (Flags_GetInfTable(0xF8))
+                } else if (Flags_GetInfTable(0xF8)) {
                     retTextId = 0x3019;
-                else
+                } else {
                     retTextId = 0x3018;
-            }
-            else
-            {
-                if (Flags_GetEventChkInf(0x2D))
+                }
+            } else {
+                if (Flags_GetEventChkInf(0x2D)) {
                     retTextId = 0x4043;
-                else
+                } else {
                     retTextId = 0x302A;
+                }
             }
             break;
         case 48:
-            if (Flags_GetEventChkInf(0x25))
+            if (Flags_GetEventChkInf(0x25)) {
                 retTextId = 0x3029;
-            else if (Flags_GetEventChkInf(0x20) && Flags_GetEventChkInf(0x21))
+            } else if (Flags_GetEventChkInf(0x20) && Flags_GetEventChkInf(0x21)) {
                 retTextId = 0x301B;
-            else
+            } else {
                 retTextId = 0x301A;
+            }
             break;
         case 49:
-            if (Flags_GetEventChkInf(0x37))
+            if (Flags_GetEventChkInf(0x37)) {
                 retTextId = 0x402D;
-            else if (Flags_GetEventChkInf(0x30))
+            } else if (Flags_GetEventChkInf(0x30)) {
                 retTextId = 0x4007;
-            else
+            } else {
                 retTextId = 0x4006;
+            }
             break;
         case 50:
-            if (Flags_GetEventChkInf(0x37))
+            if (Flags_GetEventChkInf(0x37)) {
                 retTextId = 0x402E;
-            else if (Flags_GetEventChkInf(0x30))
-            {
-                if (Flags_GetInfTable(0x124))
+            } else if (Flags_GetEventChkInf(0x30)) {
+                if (Flags_GetInfTable(0x124)) {
                     retTextId = 0x4009;
-                else
+                } else {
                     retTextId = 0x4008;
-            }
-            else
+                }
+            } else {
                 retTextId = 0x4006;
+            }
             break;
         case 51:
-            if (Flags_GetEventChkInf(0x37))
+            if (Flags_GetEventChkInf(0x37)) {
                 retTextId = 0x402D;
-            else if (Flags_GetEventChkInf(0x31))
-            {
-                if (Flags_GetInfTable(0x12A))
+            } else if (Flags_GetEventChkInf(0x31)) {
+                if (Flags_GetInfTable(0x12A)) {
                     retTextId = 0x400B;
-                else
+                } else {
                     retTextId = 0x402F;
-            }
-            else if (Flags_GetEventChkInf(0x30))
+                }
+            } else if (Flags_GetEventChkInf(0x30)) {
                 retTextId = 0x400A;
-            else
+            } else {
                 retTextId = 0x4006;
+            }
             break;
         case 52:
-            if (Flags_GetEventChkInf(0x37))
+            if (Flags_GetEventChkInf(0x37)) {
                 retTextId = 0x402E;
-            else if (Flags_GetEventChkInf(0x30))
+            } else if (Flags_GetEventChkInf(0x30)) {
                 retTextId = 0x400C;
-            else
+            } else {
                 retTextId = 0x4006;
+            }
             break;
         case 53:
-            if (Flags_GetEventChkInf(0x37))
+            if (Flags_GetEventChkInf(0x37)) {
                 retTextId = 0x402D;
-            else if (Flags_GetEventChkInf(0x33))
+            } else if (Flags_GetEventChkInf(0x33)) {
                 retTextId = 0x4010;
-            else if (Flags_GetEventChkInf(0x30))
+            } else if (Flags_GetEventChkInf(0x30)) {
                 retTextId = 0x400F;
-            else
+            } else {
                 retTextId = 0x4006;
+            }
             break;
         case 54:
-            if (Flags_GetEventChkInf(0x37))
+            if (Flags_GetEventChkInf(0x37)) {
                 retTextId = 0x402E;
-            else if (Flags_GetEventChkInf(0x30))
+            } else if (Flags_GetEventChkInf(0x30)) {
                 retTextId = 0x4011;
-            else
+            } else {
                 retTextId = 0x4006;
+            }
             break;
         case 55:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x37))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x37)) {
                     retTextId = 0x402B;
-                else if (Flags_GetEventChkInf(0x31))
-                {
-                    if (Flags_GetInfTable(0x138))
+                } else if (Flags_GetEventChkInf(0x31)) {
+                    if (Flags_GetInfTable(0x138)) {
                         retTextId = 0x401C;
-                    else
+                    } else {
                         retTextId = 0x401B;
-                }
-                else
+                    }
+                } else {
                     retTextId = 0x401A;
-            }
-            else
+                }
+            } else {
                 retTextId = 0;
+            }
             break;
         case 58:
             retTextId = 0x500F;
@@ -5462,79 +4910,77 @@ u32 func_80035BFC(GlobalContext* globalCtx, s16 arg1)
             retTextId = 0x5012;
             break;
         case 61:
-            if (Flags_GetInfTable(0x166))
+            if (Flags_GetInfTable(0x166)) {
                 retTextId = 0x5001;
-            else
+            } else {
                 retTextId = 0x5000;
+            }
             break;
         case 62:
             retTextId = 0x5012;
             break;
         case 63:
-            if (Flags_GetInfTable(0x16A))
+            if (Flags_GetInfTable(0x16A)) {
                 retTextId = 0x5001;
-            else
+            } else {
                 retTextId = 0x5000;
+            }
             break;
         case 71:
-            if (Flags_GetEventChkInf(0x16))
+            if (Flags_GetEventChkInf(0x16)) {
                 retTextId = 0x2049;
-            else if (Flags_GetEventChkInf(0x15))
+            } else if (Flags_GetEventChkInf(0x15)) {
                 retTextId = 0x2048;
-            else if (Flags_GetEventChkInf(0x14))
+            } else if (Flags_GetEventChkInf(0x14)) {
                 retTextId = 0x2047;
-            else if (Flags_GetEventChkInf(0x12) && !Flags_GetEventChkInf(0x14))
+            } else if (Flags_GetEventChkInf(0x12) && !Flags_GetEventChkInf(0x14)) {
                 retTextId = 0x2044;
-            else if (Flags_GetEventChkInf(0x10))
-            {
-                if (Flags_GetEventChkInf(0x11))
+            } else if (Flags_GetEventChkInf(0x10)) {
+                if (Flags_GetEventChkInf(0x11)) {
                     retTextId = 0x2043;
-                else
+                } else {
                     retTextId = 0x2042;
-            }
-            else
+                }
+            } else {
                 retTextId = 0x2041;
+            }
             break;
         case 72:
-            if (LINK_IS_CHILD)
-            {
-                if (Flags_GetEventChkInf(0x14))
+            if (LINK_IS_CHILD) {
+                if (Flags_GetEventChkInf(0x14)) {
                     retTextId = 0x2040;
-                else if (Flags_GetInfTable(0x94))
+                } else if (Flags_GetInfTable(0x94)) {
                     retTextId = 0x2040;
-                else
+                } else {
                     retTextId = 0x203F;
-            }
-            else
-            {
-                if (!Flags_GetEventChkInf(0x18))
-                {
-                    if (gSaveContext.night_flag)
+                }
+            } else {
+                if (!Flags_GetEventChkInf(0x18)) {
+                    if (gSaveContext.night_flag) {
                         retTextId = 0x204E;
-                    else if (Flags_GetInfTable(0x9A))
+                    } else if (Flags_GetInfTable(0x9A)) {
                         retTextId = 0x2031;
-                    else
+                    } else {
                         retTextId = 0x2030;
-                }
-                else
+                    }
+                } else {
                     retTextId = 0;
+                }
             }
             break;
     }
 
-    if (retTextId == 0)
+    if (retTextId == 0) {
         retTextId = 1;
+    }
 
     return retTextId;
 }
 
-void func_80036E50(u16 textId, s16 arg1)
-{
-    switch (arg1)
-    {
+void func_80036E50(u16 textId, s16 arg1) {
+    switch (arg1) {
         case 0:
-            switch (textId)
-            {
+            switch (textId) {
                 case 0x1001:
                     Flags_SetInfTable(0x0);
                     return;
@@ -5551,14 +4997,14 @@ void func_80036E50(u16 textId, s16 arg1)
             }
             return;
         case 1:
-            switch (textId)
-            {
+            switch (textId) {
                 case 0x102F:
                     Flags_SetEventChkInf(0x2);
                     Flags_SetInfTable(0xC);
                     return;
                 case 0x1033:
-                    Audio_PlaySoundGeneral(NA_SE_SY_CORRECT_CHIME, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
+                    Audio_PlaySoundGeneral(NA_SE_SY_CORRECT_CHIME, &D_801333D4, 4, &D_801333E0, &D_801333E0,
+                                           &D_801333E8);
                     Flags_SetEventChkInf(0x4);
                     Flags_SetInfTable(0xE);
                     return;
@@ -5578,132 +5024,160 @@ void func_80036E50(u16 textId, s16 arg1)
             }
             return;
         case 2:
-            if (textId == 0x1056)
+            if (textId == 0x1056) {
                 Flags_SetInfTable(0x41);
+            }
             return;
         case 3:
-            if (textId == 0x1005)
+            if (textId == 0x1005) {
                 Flags_SetInfTable(0x1E);
+            }
             return;
         case 4:
-            if (textId == 0x105D)
+            if (textId == 0x105D) {
                 Flags_SetInfTable(0x47);
+            }
             return;
         case 5:
-            if (textId == 0x1008)
+            if (textId == 0x1008) {
                 Flags_SetInfTable(0x22);
+            }
             return;
         case 6:
-            if (textId == 0x100A)
+            if (textId == 0x100A) {
                 Flags_SetInfTable(0x24);
+            }
             return;
         case 7:
-            if (textId == 0x100C)
+            if (textId == 0x100C) {
                 Flags_SetInfTable(0x26);
+            }
             return;
         case 8:
-            if (textId == 0x100E)
+            if (textId == 0x100E) {
                 Flags_SetInfTable(0x28);
-            if (textId == 0x1059)
+            }
+            if (textId == 0x1059) {
                 Flags_SetInfTable(0x51);
+            }
             return;
         case 10:
-            if (textId == 0x104F)
+            if (textId == 0x104F) {
                 Flags_SetInfTable(0x59);
+            }
             return;
         case 13:
-            if (textId == 0x1054)
+            if (textId == 0x1054) {
                 Flags_SetInfTable(0x61);
+            }
             return;
         case 15:
-            if (textId == 0x1062)
+            if (textId == 0x1062) {
                 Flags_SetInfTable(0x66);
+            }
             return;
         case 16:
-            if (textId == 0x7002)
+            if (textId == 0x7002) {
                 Flags_SetInfTable(0x6A);
-            if (textId == 0x7003)
+            }
+            if (textId == 0x7003) {
                 Flags_SetInfTable(0x6A);
+            }
             return;
         case 17:
-            if (textId == 0x7007)
+            if (textId == 0x7007) {
                 Flags_SetInfTable(0x6C);
+            }
             return;
         case 18:
-            if (textId == 0x7071)
+            if (textId == 0x7071) {
                 Flags_SetInfTable(0x71);
+            }
             return;
         case 20:
         case 21:
-            if (textId == 0x2010)
+            if (textId == 0x2010) {
                 Flags_SetInfTable(0x76);
+            }
             return;
         case 25:
-            if (textId == 0x7016)
+            if (textId == 0x7016) {
                 Flags_SetInfTable(0xC2);
+            }
             return;
         case 26:
-            if (textId == 0x7018)
+            if (textId == 0x7018) {
                 Flags_SetInfTable(0xC4);
+            }
             return;
         case 28:
-            if (textId == 0x701D)
+            if (textId == 0x701D) {
                 Flags_SetInfTable(0xCA);
+            }
             return;
         case 29:
-            if (textId == 0x701F)
+            if (textId == 0x701F) {
                 Flags_SetInfTable(0xCC);
+            }
             return;
         case 30:
-            if (textId == 0x7021)
+            if (textId == 0x7021) {
                 Flags_SetInfTable(0xCE);
+            }
             return;
         case 31:
-            if (textId == 0x7023)
+            if (textId == 0x7023) {
                 Flags_SetInfTable(0xD0);
+            }
             return;
         case 32:
-            if (textId == 0x7025)
+            if (textId == 0x7025) {
                 Flags_SetInfTable(0xD2);
+            }
             return;
         case 33:
-            if (textId == 0x7027)
+            if (textId == 0x7027) {
                 Flags_SetInfTable(0xD4);
+            }
             return;
         case 34:
-            if (textId == 0x403c)
+            if (textId == 0x403c) {
                 Flags_SetInfTable(0xD6);
+            }
             return;
         case 35:
-            if (textId == 0x5028)
+            if (textId == 0x5028) {
                 Flags_SetInfTable(0xD8);
+            }
             return;
         case 38:
-            if (textId == 0x3008)
+            if (textId == 0x3008) {
                 Flags_SetInfTable(0xE0);
+            }
             return;
         case 40:
-            if (textId == 0x300B)
+            if (textId == 0x300B) {
                 Flags_SetInfTable(0xEB);
+            }
             return;
         case 41:
-            if (textId == 0x3014)
+            if (textId == 0x3014) {
                 Flags_SetInfTable(0xF0);
+            }
             return;
         case 42:
-            if (textId == 0x3016)
+            if (textId == 0x3016) {
                 Flags_SetInfTable(0xF4);
+            }
             return;
         case 43:
-            if (textId == 0x3018)
-            {
+            if (textId == 0x3018) {
                 Flags_SetEventChkInf(0x20);
                 Flags_SetInfTable(0xF8);
             }
             return;
         case 48:
-            if (textId == 0x3020)
-            {
+            if (textId == 0x3020) {
                 Flags_SetEventChkInf(0x22);
                 Flags_SetInfTable(0x113);
             }
@@ -5712,136 +5186,140 @@ void func_80036E50(u16 textId, s16 arg1)
         case 52:
         case 53:
         case 54:
-            if (textId == 0x4006)
+            if (textId == 0x4006) {
                 Flags_SetEventChkInf(0x30);
+            }
             return;
         case 50:
-            if (textId == 0x4006)
+            if (textId == 0x4006) {
                 Flags_SetEventChkInf(0x30);
-            if (textId == 0x4008)
+            }
+            if (textId == 0x4008) {
                 Flags_SetInfTable(0x124);
+            }
             return;
         case 51:
-            if (textId == 0x4006)
+            if (textId == 0x4006) {
                 Flags_SetEventChkInf(0x30);
-            if (textId == 0x400A)
+            }
+            if (textId == 0x400A) {
                 Flags_SetEventChkInf(0x32);
-            if (textId == 0x402F)
+            }
+            if (textId == 0x402F) {
                 Flags_SetInfTable(0x12A);
+            }
             return;
         case 55:
-            if (textId == 0x401B)
-            {
+            if (textId == 0x401B) {
                 Flags_SetEventChkInf(0x33);
                 Flags_SetInfTable(0x138);
             }
             return;
         case 61:
-            if (textId == 0x5000)
+            if (textId == 0x5000) {
                 Flags_SetInfTable(0x166);
+            }
             return;
         case 63:
-            if (textId == 0x5013)
+            if (textId == 0x5013) {
                 Flags_SetInfTable(0x16A);
+            }
             return;
         case 71:
-            if (textId == 0x2041)
+            if (textId == 0x2041) {
                 Flags_SetEventChkInf(0x10);
-            if (textId == 0x2044)
+            }
+            if (textId == 0x2044) {
                 Flags_SetEventChkInf(0x12);
-            if (textId == 0x2047)
+            }
+            if (textId == 0x2047) {
                 Flags_SetEventChkInf(0x15);
-            if (textId == 0x2048)
+            }
+            if (textId == 0x2048) {
                 Flags_SetEventChkInf(0x16);
+            }
             return;
         case 72:
             return;
     }
 }
 
-s32 func_800374E0(GlobalContext* globalCtx, Actor* actor, u16 textId)
-{
+s32 func_800374E0(GlobalContext* globalCtx, Actor* actor, u16 textId) {
     MessageContext* msgCtx = &globalCtx->msgCtx;
     s32 ret = 1;
 
-    switch (textId)
-    {
+    switch (textId) {
         case 0x1035:
-            if (msgCtx->choiceIndex == 0)
-            {
-                if (Flags_GetInfTable(0x2A))
+            if (msgCtx->choiceIndex == 0) {
+                if (Flags_GetInfTable(0x2A)) {
                     func_80035B18(globalCtx, actor, 0x1036);
-                else
+                } else {
                     func_80035B18(globalCtx, actor, 0x1041);
+                }
             }
-            if (msgCtx->choiceIndex == 1)
-            {
-                if (Flags_GetInfTable(0x2B))
+            if (msgCtx->choiceIndex == 1) {
+                if (Flags_GetInfTable(0x2B)) {
                     func_80035B18(globalCtx, actor, 0x1037);
-                else
+                } else {
                     func_80035B18(globalCtx, actor, 0x1041);
+                }
             }
             ret = 0;
             break;
         case 0x1038:
-            if (msgCtx->choiceIndex == 0)
-            {
-                if (Flags_GetInfTable(0x2E))
+            if (msgCtx->choiceIndex == 0) {
+                if (Flags_GetInfTable(0x2E)) {
                     func_80035B18(globalCtx, actor, 0x1039);
-                else
+                } else {
                     func_80035B18(globalCtx, actor, 0x1041);
+                }
             }
-            if (msgCtx->choiceIndex == 1)
-            {
-                if (Flags_GetInfTable(0x2F))
+            if (msgCtx->choiceIndex == 1) {
+                if (Flags_GetInfTable(0x2F)) {
                     func_80035B18(globalCtx, actor, 0x103A);
-                else
+                } else {
                     func_80035B18(globalCtx, actor, 0x1041);
+                }
             }
-            if (msgCtx->choiceIndex == 2)
-            {
-                if (Flags_GetInfTable(0x30))
+            if (msgCtx->choiceIndex == 2) {
+                if (Flags_GetInfTable(0x30)) {
                     func_80035B18(globalCtx, actor, 0x103B);
-                else
+                } else {
                     func_80035B18(globalCtx, actor, 0x1041);
+                }
             }
             ret = 0;
             break;
         case 0x103E:
-            if (msgCtx->choiceIndex == 0)
+            if (msgCtx->choiceIndex == 0) {
                 func_80035B18(globalCtx, actor, 0x103F);
-            if (msgCtx->choiceIndex == 1)
+            }
+            if (msgCtx->choiceIndex == 1) {
                 func_80035B18(globalCtx, actor, 0x1040);
+            }
             ret = 0;
             break;
         case 0x1041:
-            if (msgCtx->unk_E2FA == 0x1035)
-            {
-                if (msgCtx->choiceIndex == 0)
-                {
+            if (msgCtx->unk_E2FA == 0x1035) {
+                if (msgCtx->choiceIndex == 0) {
                     func_80035B18(globalCtx, actor, 0x1036);
                     Flags_SetInfTable(0x2A);
                 }
-                if (msgCtx->choiceIndex == 1)
-                {
+                if (msgCtx->choiceIndex == 1) {
                     func_80035B18(globalCtx, actor, 0x1037);
                     Flags_SetInfTable(0x2B);
                 }
             }
-            if (msgCtx->unk_E2FA == 0x1038)
-            {
-                if (msgCtx->choiceIndex == 0)
-                {
+            if (msgCtx->unk_E2FA == 0x1038) {
+                if (msgCtx->choiceIndex == 0) {
                     func_80035B18(globalCtx, actor, 0x1039);
                     Flags_SetInfTable(0x2E);
                 }
-                if (msgCtx->choiceIndex == 1)
-                {
+                if (msgCtx->choiceIndex == 1) {
                     func_80035B18(globalCtx, actor, 0x103A);
                     Flags_SetInfTable(0x2F);
                 }
-                if (msgCtx->choiceIndex == 2)
-                {
+                if (msgCtx->choiceIndex == 2) {
                     func_80035B18(globalCtx, actor, 0x103B);
                     Flags_SetInfTable(0x30);
                 }
@@ -5849,81 +5327,88 @@ s32 func_800374E0(GlobalContext* globalCtx, Actor* actor, u16 textId)
             ret = 0;
             break;
         case 0x1062:
-            if (msgCtx->choiceIndex == 0)
+            if (msgCtx->choiceIndex == 0) {
                 func_80035B18(globalCtx, actor, 0x1063);
-            if (msgCtx->choiceIndex == 1)
+            }
+            if (msgCtx->choiceIndex == 1) {
                 func_80035B18(globalCtx, actor, 0x1064);
+            }
             ret = 0;
             break;
         case 0x2030:
         case 0x2031:
-            if (msgCtx->choiceIndex == 0)
-            {
-                if (gSaveContext.rupees >= 10)
-                {
+            if (msgCtx->choiceIndex == 0) {
+                if (gSaveContext.rupees >= 10) {
                     func_80035B18(globalCtx, actor, 0x2034);
                     Rupees_ChangeBy(-10);
-                }
-                else
+                } else {
                     func_80035B18(globalCtx, actor, 0x2032);
+                }
             }
-            if (msgCtx->choiceIndex == 1)
+            if (msgCtx->choiceIndex == 1) {
                 func_80035B18(globalCtx, actor, 0x2032);
+            }
             Flags_SetInfTable(0x9A);
             ret = 0;
             break;
         case 0x2036:
         case 0x2037:
-            if (msgCtx->choiceIndex == 0)
+            if (msgCtx->choiceIndex == 0) {
                 func_80035B18(globalCtx, actor, 0x201F);
-            if (msgCtx->choiceIndex == 1)
+            }
+            if (msgCtx->choiceIndex == 1) {
                 func_80035B18(globalCtx, actor, 0x205A);
+            }
             ret = 0;
             break;
         case 0x2038:
-            if (msgCtx->choiceIndex == 0)
+            if (msgCtx->choiceIndex == 0) {
                 break;
-            if (msgCtx->choiceIndex == 1)
+            }
+            if (msgCtx->choiceIndex == 1) {
                 func_80035B18(globalCtx, actor, 0x205A);
+            }
             ret = 0;
             break;
         case 0x2034:
-            if (msgCtx->choiceIndex != 0)
+            if (msgCtx->choiceIndex != 0) {
                 break;
+            }
             func_80035B18(globalCtx, actor, 0x2035);
             ret = 0;
             break;
         case 0x2043:
-            if (Flags_GetEventChkInf(0x12))
+            if (Flags_GetEventChkInf(0x12)) {
                 break;
+            }
             func_80035B18(globalCtx, actor, 0x2044);
             ret = 0;
             break;
         case 0x205A:
             break;
         case 0x300A:
-            if (msgCtx->choiceIndex == 0)
-            {
-                if (Flags_GetEventChkInf(0x22))
+            if (msgCtx->choiceIndex == 0) {
+                if (Flags_GetEventChkInf(0x22)) {
                     func_80035B18(globalCtx, actor, 0x300B);
-                else
+                } else {
                     func_80035B18(globalCtx, actor, 0x300C);
+                }
             }
-            if (msgCtx->choiceIndex == 1)
+            if (msgCtx->choiceIndex == 1) {
                 func_80035B18(globalCtx, actor, 0x300D);
+            }
             ret = 0;
             break;
         case 0x301B:
-            if (msgCtx->choiceIndex == 0)
-            {
+            if (msgCtx->choiceIndex == 0) {
                 func_80035B18(globalCtx, actor, 0x301D);
             }
-            if (msgCtx->choiceIndex == 1)
-            {
-                if (Flags_GetInfTable(0x113))
+            if (msgCtx->choiceIndex == 1) {
+                if (Flags_GetInfTable(0x113)) {
                     func_80035B18(globalCtx, actor, 0x301F);
-                else
+                } else {
                     func_80035B18(globalCtx, actor, 0x301E);
+                }
             }
             ret = 0;
             break;
@@ -5932,10 +5417,12 @@ s32 func_800374E0(GlobalContext* globalCtx, Actor* actor, u16 textId)
             ret = 0;
             break;
         case 0x400C:
-            if (msgCtx->choiceIndex == 0)
+            if (msgCtx->choiceIndex == 0) {
                 func_80035B18(globalCtx, actor, 0x400D);
-            if (msgCtx->choiceIndex == 1)
+            }
+            if (msgCtx->choiceIndex == 1) {
                 func_80035B18(globalCtx, actor, 0x400E);
+            }
             ret = 0;
             break;
         case 0x7007:
@@ -5955,37 +5442,31 @@ s32 func_800374E0(GlobalContext* globalCtx, Actor* actor, u16 textId)
     return ret;
 }
 
-u16 func_80037C30(GlobalContext* globalCtx, s16 arg1)
-{
+u16 func_80037C30(GlobalContext* globalCtx, s16 arg1) {
     return func_80035BFC(globalCtx, arg1);
 }
 
-s32 func_80037C5C(GlobalContext* globalCtx, s16 arg1, u16 textId)
-{
+s32 func_80037C5C(GlobalContext* globalCtx, s16 arg1, u16 textId) {
     func_80036E50(textId, arg1);
     return 0;
 }
 
-s32 func_80037C94(GlobalContext* globalCtx, Actor* actor, s32 arg2)
-{
+s32 func_80037C94(GlobalContext* globalCtx, Actor* actor, s32 arg2) {
     return func_800374E0(globalCtx, actor, actor->textId);
 }
 
-s32 func_80037CB8(GlobalContext* globalCtx, Actor* actor, s16 arg2)
-{
+s32 func_80037CB8(GlobalContext* globalCtx, Actor* actor, s16 arg2) {
     MessageContext* msgCtx = &globalCtx->msgCtx;
     s32 ret = 0;
 
-    switch (func_8010BDBC(msgCtx))
-    {
+    switch (func_8010BDBC(msgCtx)) {
         case 2:
             func_80037C5C(globalCtx, arg2, actor->textId);
             ret = 1;
             break;
         case 4:
         case 5:
-            if (func_80106BC8(globalCtx) && func_80037C94(globalCtx, actor, arg2))
-            {
+            if (func_80106BC8(globalCtx) && func_80037C94(globalCtx, actor, arg2)) {
                 Audio_PlaySoundGeneral(NA_SE_SY_CANCEL, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
                 msgCtx->msgMode = 0x36;
                 ret = 1;
@@ -5996,58 +5477,57 @@ s32 func_80037CB8(GlobalContext* globalCtx, Actor* actor, s16 arg2)
     return ret;
 }
 
-s32 func_80037D98(GlobalContext* globalCtx, Actor* actor, s16 arg2, s32* arg3)
-{
+s32 func_80037D98(GlobalContext* globalCtx, Actor* actor, s16 arg2, s32* arg3) {
     s16 var;
     s16 sp2C;
     s16 sp2A;
     s16 abs_var;
 
-    if (func_8002F194(actor, globalCtx))
-    {
+    if (func_8002F194(actor, globalCtx)) {
         *arg3 = 1;
         return 1;
     }
 
-    if (*arg3 == 1)
-    {
-        if (func_80037CB8(globalCtx, actor, arg2))
+    if (*arg3 == 1) {
+        if (func_80037CB8(globalCtx, actor, arg2)) {
             *arg3 = 0;
+        }
         return 0;
     }
 
     func_8002F374(globalCtx, actor, &sp2C, &sp2A);
 
-    if (0) ; // Necessary to match
+    if (0) {} // Necessary to match
 
-    if ((sp2C < 0) || (sp2C > 320) || (sp2A < 0) || (sp2A > 240))
+    if ((sp2C < 0) || (sp2C > 320) || (sp2A < 0) || (sp2A > 240)) {
         return 0;
+    }
 
     var = actor->rotTowardsLinkY - actor->shape.rot.y;
     abs_var = ABS(var);
 
-    if (abs_var >= 0x4300)
+    if (abs_var >= 0x4300) {
         return 0;
+    }
 
-    if ((actor->waterSurfaceDist > 25600.0f) && (actor->unk_10C == 0))
+    if ((actor->waterSurfaceDist > 25600.0f) && (actor->unk_10C == 0)) {
         return 0;
+    }
 
-    if (actor->waterSurfaceDist <= 6400.0f)
-    {
-        if (func_8002F2CC(actor, globalCtx, 80.0f))
+    if (actor->waterSurfaceDist <= 6400.0f) {
+        if (func_8002F2CC(actor, globalCtx, 80.0f)) {
             actor->textId = func_80037C30(globalCtx, arg2);
-    }
-    else
-    {
-        if (func_8002F2F4(actor, globalCtx))
+        }
+    } else {
+        if (func_8002F2F4(actor, globalCtx)) {
             actor->textId = func_80037C30(globalCtx, arg2);
+        }
     }
 
     return 0;
 }
 
-s32 func_80037F30(Vec3s* arg0, Vec3s* arg1)
-{
+s32 func_80037F30(Vec3s* arg0, Vec3s* arg1) {
     Math_SmoothScaleMaxMinS(&arg0->y, 0, 6, 6200, 100);
     Math_SmoothScaleMaxMinS(&arg0->x, 0, 6, 6200, 100);
     Math_SmoothScaleMaxMinS(&arg1->y, 0, 6, 6200, 100);
@@ -6055,8 +5535,7 @@ s32 func_80037F30(Vec3s* arg0, Vec3s* arg1)
     return 1;
 }
 
-s32 func_80037FC8(Actor* actor, Vec3f* arg1, Vec3s* arg2, Vec3s* arg3)
-{
+s32 func_80037FC8(Actor* actor, Vec3f* arg1, Vec3s* arg2, Vec3s* arg3) {
     s16 sp36;
     s16 sp34;
     s16 var;
@@ -6070,8 +5549,9 @@ s32 func_80037FC8(Actor* actor, Vec3f* arg1, Vec3s* arg2, Vec3s* arg3)
     var = Math_SmoothScaleMaxMinS(&arg2->y, sp34, 6, 2000, 1);
     arg2->y = (arg2->y < -8000) ? -8000 : ((arg2->y > 8000) ? 8000 : arg2->y);
 
-    if (var && (ABS(arg2->y) < 8000))
+    if (var && (ABS(arg2->y) < 8000)) {
         return 0;
+    }
 
     Math_SmoothScaleMaxMinS(&arg3->y, sp34 - arg2->y, 4, 2000, 1);
     arg3->y = (arg3->y < -12000) ? -12000 : ((arg3->y > 12000) ? 12000 : arg3->y);
@@ -6079,8 +5559,7 @@ s32 func_80037FC8(Actor* actor, Vec3f* arg1, Vec3s* arg2, Vec3s* arg3)
     return 1;
 }
 
-s32 func_80038154(GlobalContext* globalCtx, Actor* actor, Vec3s* arg2, Vec3s* arg3, f32 arg4)
-{
+s32 func_80038154(GlobalContext* globalCtx, Actor* actor, Vec3s* arg2, Vec3s* arg3, f32 arg4) {
     Player* player = PLAYER;
     s32 pad;
     Vec3f sp2C;
@@ -6090,29 +5569,27 @@ s32 func_80038154(GlobalContext* globalCtx, Actor* actor, Vec3s* arg2, Vec3s* ar
     actor->posRot2.pos = actor->posRot.pos;
     actor->posRot2.pos.y += arg4;
 
-    if (!(((globalCtx->csCtx.state != 0) || (D_8011D394 != 0)) && (gSaveContext.entrance_index == 0x00EE)))
-    {
+    if (!(((globalCtx->csCtx.state != 0) || (D_8011D394 != 0)) && (gSaveContext.entrance_index == 0x00EE))) {
         var = actor->rotTowardsLinkY - actor->shape.rot.y;
         abs_var = ABS(var);
-        if (abs_var >= 0x4300)
-        {
+        if (abs_var >= 0x4300) {
             func_80037F30(arg2, arg3);
             return 0;
         }
     }
 
-    if (((globalCtx->csCtx.state != 0) || (D_8011D394 != 0)) && (gSaveContext.entrance_index == 0x00EE))
+    if (((globalCtx->csCtx.state != 0) || (D_8011D394 != 0)) && (gSaveContext.entrance_index == 0x00EE)) {
         sp2C = globalCtx->view.eye;
-    else
+    } else {
         sp2C = player->actor.posRot2.pos;
+    }
 
     func_80037FC8(actor, &sp2C, arg2, arg3);
 
     return 1;
 }
 
-s32 func_80038290(GlobalContext* globalCtx, Actor* actor, Vec3s* arg2, Vec3s* arg3, Vec3f arg4)
-{
+s32 func_80038290(GlobalContext* globalCtx, Actor* actor, Vec3s* arg2, Vec3s* arg3, Vec3f arg4) {
     Player* player = PLAYER;
     s32 pad;
     Vec3f sp24;
@@ -6121,21 +5598,20 @@ s32 func_80038290(GlobalContext* globalCtx, Actor* actor, Vec3s* arg2, Vec3s* ar
 
     actor->posRot2.pos = arg4;
 
-    if (!(((globalCtx->csCtx.state != 0) || (D_8011D394 != 0)) && (gSaveContext.entrance_index == 0x00EE)))
-    {
+    if (!(((globalCtx->csCtx.state != 0) || (D_8011D394 != 0)) && (gSaveContext.entrance_index == 0x00EE))) {
         var = actor->rotTowardsLinkY - actor->shape.rot.y;
         abs_var = ABS(var);
-        if (abs_var >= 0x4300)
-        {
+        if (abs_var >= 0x4300) {
             func_80037F30(arg2, arg3);
             return 0;
         }
     }
 
-    if (((globalCtx->csCtx.state != 0) || (D_8011D394 != 0)) && (gSaveContext.entrance_index == 0x00EE))
+    if (((globalCtx->csCtx.state != 0) || (D_8011D394 != 0)) && (gSaveContext.entrance_index == 0x00EE)) {
         sp24 = globalCtx->view.eye;
-    else
+    } else {
         sp24 = player->actor.posRot2.pos;
+    }
 
     func_80037FC8(actor, &sp24, arg2, arg3);
 
diff --git a/src/code/z_actor_dlftbls.c b/src/code/z_actor_dlftbls.c
index 2a15f876d..29a18cf99 100644
--- a/src/code/z_actor_dlftbls.c
+++ b/src/code/z_actor_dlftbls.c
@@ -2,24 +2,19 @@
 #include <global.h>
 #include <initvars.h>
 
-#define ACTOR_OVERLAY(name, allocType)                                  \
-    {                                                                       \
-        (u32)_ovl_##name##SegmentRomStart, (u32)_ovl_##name##SegmentRomEnd, \
-        _ovl_##name##SegmentStart, _ovl_##name##SegmentEnd,                 \
-        NULL, &name##_InitVars, #name, allocType, 0                         \
+#define ACTOR_OVERLAY(name, allocType)                                                                  \
+    {                                                                                                   \
+        (u32) _ovl_##name##SegmentRomStart, (u32)_ovl_##name##SegmentRomEnd, _ovl_##name##SegmentStart, \
+            _ovl_##name##SegmentEnd, NULL, &name##_InitVars, #name, allocType, 0                        \
     }
 
-#define ACTOR_OVERLAY_INTERNAL(name, allocType)     \
-    {                                                   \
-        0, 0,                                           \
-        NULL, NULL,                                     \
-        NULL, &name##_InitVars, #name, allocType, 0     \
-    }
+#define ACTOR_OVERLAY_INTERNAL(name, allocType) \
+    { 0, 0, NULL, NULL, NULL, &name##_InitVars, #name, allocType, 0 }
 
-#define ACTOR_OVERLAY_UNSET { 0 }
+#define ACTOR_OVERLAY_UNSET \
+    { 0 }
 
-ActorOverlay gActorOverlayTable[] =
-{
+ActorOverlay gActorOverlayTable[] = {
     ACTOR_OVERLAY_INTERNAL(Player, ALLOCTYPE_NORMAL),
     ACTOR_OVERLAY_UNSET,
     ACTOR_OVERLAY(En_Test, ALLOCTYPE_NORMAL),
@@ -497,26 +492,21 @@ s32 gMaxProfile = 0;
 
 static FaultClient sFaultClient;
 
-void ActorOverlayTable_LogPrint(void)
-{
+void ActorOverlayTable_LogPrint(void) {
     ActorOverlay* overlayEntry;
     u32 i;
 
     osSyncPrintf("actor_dlftbls %u\n", gMaxProfile);
     osSyncPrintf("RomStart RomEnd   SegStart SegEnd   allocp   profile  segname\n");
 
-    for (i = 0, overlayEntry = &gActorOverlayTable[0]; i < gMaxProfile; i++, overlayEntry++)
-    {
-        osSyncPrintf("%08x %08x %08x %08x %08x %08x %s\n",
-                     overlayEntry->vromStart, overlayEntry->vromEnd,
-                     overlayEntry->vramStart, overlayEntry->vramEnd,
-                     overlayEntry->loadedRamAddr, &overlayEntry->initInfo->id,
-                     overlayEntry->name != NULL ? overlayEntry->name : "?");
+    for (i = 0, overlayEntry = &gActorOverlayTable[0]; i < gMaxProfile; i++, overlayEntry++) {
+        osSyncPrintf("%08x %08x %08x %08x %08x %08x %s\n", overlayEntry->vromStart, overlayEntry->vromEnd,
+                     overlayEntry->vramStart, overlayEntry->vramEnd, overlayEntry->loadedRamAddr,
+                     &overlayEntry->initInfo->id, overlayEntry->name != NULL ? overlayEntry->name : "?");
     }
 }
 
-void ActorOverlayTable_FaultPrint(void* arg0, void* arg1)
-{
+void ActorOverlayTable_FaultPrint(void* arg0, void* arg1) {
     ActorOverlay* overlayEntry;
     u32 overlaySize;
     s32 i;
@@ -526,26 +516,22 @@ void ActorOverlayTable_FaultPrint(void* arg0, void* arg1)
     FaultDrawer_Printf("actor_dlftbls %u\n", gMaxProfile);
     FaultDrawer_Printf("No. RamStart- RamEnd cn  Name\n");
 
-    for (i = 0, overlayEntry = &gActorOverlayTable[0]; i < gMaxProfile; i++, overlayEntry++)
-    {
+    for (i = 0, overlayEntry = &gActorOverlayTable[0]; i < gMaxProfile; i++, overlayEntry++) {
         overlaySize = (u32)overlayEntry->vramEnd - (u32)overlayEntry->vramStart;
-        if (overlayEntry->loadedRamAddr != NULL)
-        {
-            FaultDrawer_Printf("%3d %08x-%08x %3d %s\n",
-                               i, overlayEntry->loadedRamAddr, (u32)overlayEntry->loadedRamAddr + overlaySize,
-                               overlayEntry->nbLoaded, overlayEntry->name != NULL ? overlayEntry->name : "");
+        if (overlayEntry->loadedRamAddr != NULL) {
+            FaultDrawer_Printf("%3d %08x-%08x %3d %s\n", i, overlayEntry->loadedRamAddr,
+                               (u32)overlayEntry->loadedRamAddr + overlaySize, overlayEntry->nbLoaded,
+                               overlayEntry->name != NULL ? overlayEntry->name : "");
         }
     }
 }
 
-void ActorOverlayTable_Init(void)
-{
+void ActorOverlayTable_Init(void) {
     gMaxProfile = ACTOR_DLF_MAX;
     Fault_AddClient(&sFaultClient, ActorOverlayTable_FaultPrint, NULL, NULL);
 }
 
-void ActorOverlayTable_Cleanup(void)
-{
+void ActorOverlayTable_Cleanup(void) {
     Fault_RemoveClient(&sFaultClient);
     gMaxProfile = 0;
 }
diff --git a/src/code/z_bgcheck.c b/src/code/z_bgcheck.c
index d36b154c8..12c66c975 100644
--- a/src/code/z_bgcheck.c
+++ b/src/code/z_bgcheck.c
@@ -3,47 +3,41 @@
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_80038600.s")
 
-void func_80038708(s16* puParm1, s16* puParm2, u16 uParm3)
-{
-  *puParm1 = *puParm2;
-  puParm1[1] = uParm3;
+void func_80038708(s16* puParm1, s16* puParm2, u16 uParm3) {
+    *puParm1 = *puParm2;
+    puParm1[1] = uParm3;
 }
 
-void func_8003871C(u16* puParm1)
-{
-  *puParm1 = 0xFFFF;
+void func_8003871C(u16* puParm1) {
+    *puParm1 = 0xFFFF;
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_80038728.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_80038780.s")
 
-void func_800387FC(u32 uParm1, u32* puParm2)
-{  
-  *puParm2 = 0;
-  puParm2[1] = 0;
+void func_800387FC(u32 uParm1, u32* puParm2) {
+    *puParm2 = 0;
+    puParm2[1] = 0;
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_8003880C.s")
 
-void func_80038870(int iParm1)
-{
-  *(u32*)(iParm1 + 4) = 0;
+void func_80038870(int iParm1) {
+    *(u32*)(iParm1 + 4) = 0;
 }
 
-u32 func_80038878(s32 iParm1)
-{
-  u32 uVar1;
-  
-  uVar1 = *(u32*)(iParm1 + 4) & 0xffff;
-  *(int *)(iParm1 + 4) = *(u32*)(iParm1 + 4) + 1;
-  
-  if (*(int *)(iParm1 + 8) <= (int)uVar1) 
-  {
-    return 0xffff;
-  }
-
-  return uVar1;
+u32 func_80038878(s32 iParm1) {
+    u32 uVar1;
+
+    uVar1 = *(u32*)(iParm1 + 4) & 0xffff;
+    *(int*)(iParm1 + 4) = *(u32*)(iParm1 + 4) + 1;
+
+    if (*(int*)(iParm1 + 8) <= (int)uVar1) {
+        return 0xffff;
+    }
+
+    return uVar1;
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_800388A8.s")
@@ -56,7 +50,6 @@ u32 func_80038878(s32 iParm1)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_80038A28.s")
 
-
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_80038B7C.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_80038BE0.s")
@@ -175,12 +168,11 @@ u32 func_80038878(s32 iParm1)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_8003E214.s")
 
-void func_8003E398(u16* puParm1)
-{
-  *puParm1 = 0;
-  puParm1[1] = 0;
-  *(u32*)(puParm1 + 2) = 0;
-  *(u32*)(puParm1 + 4) = 0;
+void func_8003E398(u16* puParm1) {
+    *puParm1 = 0;
+    puParm1[1] = 0;
+    *(u32*)(puParm1 + 2) = 0;
+    *(u32*)(puParm1 + 4) = 0;
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_8003E3AC.s")
@@ -195,15 +187,12 @@ void func_8003E398(u16* puParm1)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_8003E688.s")
 
-void func_8003E6C4(u16* puParm1)
-{
-  *puParm1 = 0;
-  func_8003E688();
+void func_8003E6C4(u16* puParm1) {
+    *puParm1 = 0;
+    func_8003E688();
 }
 
-
-void func_8003E6E4(u16* a0)
-{
+void func_8003E6E4(u16* a0) {
     *a0 = 0;
 }
 
@@ -211,21 +200,17 @@ void func_8003E6E4(u16* a0)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_8003E750.s")
 
-void func_8003E804(int iParm1)
-{
-  func_8003E5B4(iParm1 + 0x14, iParm1 + 0x34);
+void func_8003E804(int iParm1) {
+    func_8003E5B4(iParm1 + 0x14, iParm1 + 0x34);
 }
 
-
-void func_8003E82C(u32* a0)
-{
+void func_8003E82C(u32* a0) {
     *a0 = 0;
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_8003E834.s")
 
-void func_8003E888(u32* a0)
-{
+void func_8003E888(u32* a0) {
     *a0 = 0;
 }
 
@@ -235,8 +220,7 @@ void func_8003E888(u32* a0)
 
 /*
 NON-MATCHING
-void func_8003E8EC(u32 uParm1, u32* iParm2)
-{
+void func_8003E8EC(u32 uParm1, u32* iParm2) {
     iParm2[0x06] = iParm2[0x0E];
     iParm2[0x05] = iParm2[0x0D];
     iParm2[0x07] = iParm2[0x0F];
@@ -246,30 +230,28 @@ void func_8003E8EC(u32 uParm1, u32* iParm2)
     iParm2[0x0B] = iParm2[0x13];
     iParm2[0x0C] = iParm2[0x14];
 
-   
+
    //int i;
-   //for (i = 0; i < 4; i++)
-   //{
+   //for (i = 0; i < 4; i++) {
        //iParm2[0x06 + (i * 2)] = iParm2[0x0E + (i * 2)];
        //iParm2[0x07 + (i * 2)] = iParm2[0x0D + (i * 2)];
    //}
 }
 */
 
-u32 func_8003E934(int iParm1)
-{
-  if (!((-1 < iParm1) && (iParm1 < 0x32)))
-    return 0;
+u32 func_8003E934(int iParm1) {
+    if (!((-1 < iParm1) && (iParm1 < 0x32))) {
+        return 0;
+    }
 
-  return 1;
+    return 1;
 }
 
-void func_8003E954(u32 uParm1, u8* puParm2)
-{
-  *puParm2 = 1;
-  func_8003E82C(puParm2 + 0x13f0);
-  func_8003E888(puParm2 + 0x13f4);
-  func_800387FC(uParm1, puParm2 + 0x13f8);
+void func_8003E954(u32 uParm1, u8* puParm2) {
+    *puParm2 = 1;
+    func_8003E82C(puParm2 + 0x13f0);
+    func_8003E888(puParm2 + 0x13f4);
+    func_800387FC(uParm1, puParm2 + 0x13f8);
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_8003E9A0.s")
@@ -323,19 +305,16 @@ void func_8003E954(u32 uParm1, u8* puParm2)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_800418D0.s")
 
 #ifdef NON_MATCHING
-void func_80041978(int iParm1, int iParm2)
-{
-  u8* puVar1;
-
-  puVar1 = *(u8 **)(iParm1 + 8);
-  if (puVar1 < puVar1 + iParm2) 
-  {
-    *puVar1 = 0;
-    while (puVar1++ < (u8*)(*(int *)(iParm1 + 8) + iParm2))
-    {
-      *puVar1 = 0;
+void func_80041978(int iParm1, int iParm2) {
+    u8* puVar1;
+
+    puVar1 = *(u8**)(iParm1 + 8);
+    if (puVar1 < puVar1 + iParm2) {
+        *puVar1 = 0;
+        while (puVar1++ < (u8*)(*(int*)(iParm1 + 8) + iParm2)) {
+            *puVar1 = 0;
+        }
     }
-  }
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_80041978.s")
@@ -343,12 +322,11 @@ void func_80041978(int iParm1, int iParm2)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_800419B0.s")
 
-u32 func_80041A28(CollisionContext *a0, u32 a1, u32 a2)
-{
-  u32 uVar1;
-  
-  uVar1 = func_800419B0(a0, a1, a2, 0);
-  return uVar1 & 0xff;
+u32 func_80041A28(CollisionContext* a0, u32 a1, u32 a2) {
+    u32 uVar1;
+
+    uVar1 = func_800419B0(a0, a1, a2, 0);
+    return uVar1 & 0xff;
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_80041A4C.s")
@@ -365,12 +343,11 @@ u32 func_80041A28(CollisionContext *a0, u32 a1, u32 a2)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_80041D4C.s")
 
-u32 func_80041D94(u32 a0, u32 a1, u32 a2)
-{
-  u32 uVar1;
-  
-  uVar1 = func_800419B0(a0, a1, a2, 0);
-  return uVar1 >> 0x15 & 0x1f;
+u32 func_80041D94(u32 a0, u32 a1, u32 a2) {
+    u32 uVar1;
+
+    uVar1 = func_800419B0(a0, a1, a2, 0);
+    return uVar1 >> 0x15 & 0x1f;
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_80041DB8.s")
@@ -385,12 +362,11 @@ u32 func_80041D94(u32 a0, u32 a1, u32 a2)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_80041EEC.s")
 
-u32 func_80041F10(u32 a0, u32 a1, u32 a2)
-{
-  u32 uVar1;
-  
-  uVar1 = func_800419B0(a0, a1, a2, 1);
-  return uVar1 & 0xf;
+u32 func_80041F10(u32 a0, u32 a1, u32 a2) {
+    u32 uVar1;
+
+    uVar1 = func_800419B0(a0, a1, a2, 1);
+    return uVar1 & 0xf;
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_80041F34.s")
@@ -409,29 +385,28 @@ u32 func_80041F10(u32 a0, u32 a1, u32 a2)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_800420E4.s")
 
-u32 func_80042108(u32 a0, u32 a1, u32 a2)
-{
-  u32 result;
-  s32 var1;
+u32 func_80042108(u32 a0, u32 a1, u32 a2) {
+    u32 result;
+    s32 var1;
 
-  var1 = func_800419B0(a0, a1, a2, 1);
+    var1 = func_800419B0(a0, a1, a2, 1);
 
-  if (var1 << 4 < 0)
-    result = 1;
-  else
-    result = 0;
+    if (var1 << 4 < 0) {
+        result = 1;
+    } else {
+        result = 0;
+    }
 
-  return result;
+    return result;
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_8004213C.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_80042244.s")
 
-u8 func_80042538(CollisionContext *colCtx, s32 iParm2)
-{
+u8 func_80042538(CollisionContext* colCtx, s32 iParm2) {
     u32 var1 = *(u32*)(iParm2 + 0xc);
-  return var1;
+    return var1;
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_80042548.s")
@@ -451,4 +426,3 @@ u8 func_80042538(CollisionContext *colCtx, s32 iParm2)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_80042EF8.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/func_80042FC4.s")
-
diff --git a/src/code/z_camera.c b/src/code/z_camera.c
index e1bece0fa..b48b58321 100644
--- a/src/code/z_camera.c
+++ b/src/code/z_camera.c
@@ -2,20 +2,19 @@
 #include <global.h>
 #include <vt.h>
 
-// Non-matchings functions marked with CLOSE are either a matter of regalloc or stack size and can possibly be fixed with the permutator.
+// Non-matchings functions marked with CLOSE are either a matter of regalloc or stack size and can possibly be fixed
+// with the permutator.
 
-typedef struct
-{
+typedef struct {
     Vec3f unk_00;
     Vec3f unk_0C;
-    CollisionPoly *unk_18;
+    CollisionPoly* unk_18;
     char unk_1C[0x8];
     s32 unk_24;
 } struct_80043D18;
 
 // names for this struct's values come from a debug function, may want to rename
-typedef struct
-{
+typedef struct {
     s8 code;
     s8 z;
     u16 T;
@@ -23,88 +22,77 @@ typedef struct
     Vec3s pos;
 } SplineData; // originally called SplinedatZ
 
-
 // 47 lines
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_800437F0.s")
 // had an attempt at this but didn't get very close
 
-f32 func_8004389C(f32 a, f32 b, f32 c, f32 d)
-{
-  f32 temp1 = a - b;
-  f32 temp2;
-  f32 ret;
-  
-  if (fabsf(temp1) >= d)
-  {
-    temp2 = temp1 * c;
-    ret = b + temp2;
-  }
-  else
-    ret = a;
-
-  return ret;
+f32 func_8004389C(f32 a, f32 b, f32 c, f32 d) {
+    f32 temp1 = a - b;
+    f32 temp2;
+    f32 ret;
+
+    if (fabsf(temp1) >= d) {
+        temp2 = temp1 * c;
+        ret = b + temp2;
+    } else {
+        ret = a;
+    }
+
+    return ret;
 }
 
-f32 func_800438DC(f32 a, f32 b, f32 c, f32 d)
-{
-  f32 temp1 = a - b;
-  f32 temp2;
-  f32 ret;
-  
-  if (fabsf(temp1) >= d)
-  {
-    temp2 = temp1 * c;
-    ret = b + temp2;
-  }
-  else
-    ret = b;
-
-  return ret;
+f32 func_800438DC(f32 a, f32 b, f32 c, f32 d) {
+    f32 temp1 = a - b;
+    f32 temp2;
+    f32 ret;
+
+    if (fabsf(temp1) >= d) {
+        temp2 = temp1 * c;
+        ret = b + temp2;
+    } else {
+        ret = b;
+    }
+
+    return ret;
 }
 
-s16 func_8004391C(s16 a, s16 b, f32 c, s16 d)
-{
-  s16 temp1 = a - b;
-  s16 temp2;
-  s32 ret;
-  
-  if (ABS(temp1) >= d)
-  {
-    temp2 = temp1 * c + 0.5f;
-    ret = b + temp2;
-  }
-  else
-    ret = a;
-
-  return ret;
+s16 func_8004391C(s16 a, s16 b, f32 c, s16 d) {
+    s16 temp1 = a - b;
+    s16 temp2;
+    s32 ret;
+
+    if (ABS(temp1) >= d) {
+        temp2 = temp1 * c + 0.5f;
+        ret = b + temp2;
+    } else {
+        ret = a;
+    }
+
+    return ret;
 }
 
-s16 func_800439AC(s16 a, s16 b, f32 c, s16 d)
-{
-  s16 temp1 = a - b;
-  s16 temp2;
-  s32 ret;
-  
-  if (ABS(temp1) >= d)
-  {
-    temp2 = temp1 * c + 0.5f;
-    ret = b + temp2;
-  }
-  else
-    ret = b;
-
-  return ret;
+s16 func_800439AC(s16 a, s16 b, f32 c, s16 d) {
+    s16 temp1 = a - b;
+    s16 temp2;
+    s32 ret;
+
+    if (ABS(temp1) >= d) {
+        temp2 = temp1 * c + 0.5f;
+        ret = b + temp2;
+    } else {
+        ret = b;
+    }
+
+    return ret;
 }
 
-void func_80043A3C(Vec3f *a, Vec3f *b, f32 c, f32 d, f32 e)
-{
+void func_80043A3C(Vec3f* a, Vec3f* b, f32 c, f32 d, f32 e) {
     b->x = func_8004389C(a->x, b->x, d, e);
     b->y = func_8004389C(a->y, b->y, c, e);
     b->z = func_8004389C(a->z, b->z, d, e);
 }
 
-void func_80043ABC(Camera *camera)
-{
+void func_80043ABC(Camera* camera) {
     camera->unk_C0.z = 100.0f;
     camera->unk_C0.y = OREG(7);
     camera->unk_C0.x = OREG(6);
@@ -113,8 +101,7 @@ void func_80043ABC(Camera *camera)
     camera->unk_CC.z = OREG(4) * 0.01f;
 }
 
-void func_80043B60(Camera *camera)
-{
+void func_80043B60(Camera* camera) {
     camera->unk_C0.x = OREG(27);
     camera->unk_C0.z = OREG(27);
     camera->unk_C0.y = OREG(27);
@@ -123,8 +110,7 @@ void func_80043B60(Camera *camera)
     camera->unk_CC.z = 0.001f;
 }
 
-Vec3f *func_80043BC4(Vec3f *a, Vec3s *b)
-{
+Vec3f* func_80043BC4(Vec3f* a, Vec3s* b) {
     Vec3f sp4;
 
     sp4.x = b->x;
@@ -135,21 +121,19 @@ Vec3f *func_80043BC4(Vec3f *a, Vec3s *b)
     return a;
 }
 
-Vec3f *func_80043C28(Vec3f *a, Vec3f *b, struct_80045714 *c)
-{
+Vec3f* func_80043C28(Vec3f* a, Vec3f* b, struct_80045714* c) {
     Vec3f sp24, sp18;
     func_8007C25C(&sp18, c);
 
     sp24.x = b->x + sp18.x;
     sp24.y = b->y + sp18.y;
     sp24.z = b->z + sp18.z;
-    
+
     *a = sp24;
     return a;
 }
 
-Vec3f *func_80043CAC(Vec3f *a, Vec3f *b, Vec3f *c, f32 d)
-{
+Vec3f* func_80043CAC(Vec3f* a, Vec3f* b, Vec3f* c, f32 d) {
     Vec3f sp4;
 
     sp4.x = b->x + (c->x * d);
@@ -160,12 +144,11 @@ Vec3f *func_80043CAC(Vec3f *a, Vec3f *b, Vec3f *c, f32 d)
     return a;
 }
 
-s32 func_80043D18(Camera *camera, Vec3f *b, struct_80043D18 *c)
-{
-    CollisionContext *colCtx;
+s32 func_80043D18(Camera* camera, Vec3f* b, struct_80043D18* c) {
+    CollisionContext* colCtx;
     Vec3f sp68, sp5C, sp50;
     f32 temp_ret;
-    CollisionPoly *sp48;
+    CollisionPoly* sp48;
     s32 sp44;
     struct_80045714 sp3C;
 
@@ -173,47 +156,44 @@ s32 func_80043D18(Camera *camera, Vec3f *b, struct_80043D18 *c)
     func_8007C490(&sp3C, b, &c->unk_00);
     sp3C.unk_00 += 8.0f;
     func_80043C28(&sp5C, b, &sp3C);
-    
-    if (func_8003DD6C(colCtx, b, &sp5C, &sp68, &c->unk_18, 1, 1, 1, -1, &c->unk_24) == 0)
-    {
+
+    if (func_8003DD6C(colCtx, b, &sp5C, &sp68, &c->unk_18, 1, 1, 1, -1, &c->unk_24) == 0) {
         func_8007C0F8(&sp50, b, &c->unk_00);
-        
+
         c->unk_0C.x = -sp50.x;
         c->unk_0C.y = -sp50.y;
         c->unk_0C.z = -sp50.z;
-        
+
         sp68 = c->unk_00;
         sp68.y += 5.0f;
         temp_ret = func_8003CCA4(colCtx, &sp48, &sp44, &sp68);
-        
-        if ((c->unk_00.y - temp_ret) > 5.0f)
-        {
+
+        if ((c->unk_00.y - temp_ret) > 5.0f) {
             c->unk_00.x += c->unk_0C.x;
             c->unk_00.y += c->unk_0C.y;
             c->unk_00.z += c->unk_0C.z;
             return 0;
         }
-        
+
         c->unk_18 = sp48;
         sp68.y = temp_ret + 1.0f;
         c->unk_24 = sp44;
     }
-    
+
     c->unk_0C.x = c->unk_18->norm.x * (1.f / 32767);
     c->unk_0C.y = c->unk_18->norm.y * (1.f / 32767);
     c->unk_0C.z = c->unk_18->norm.z * (1.f / 32767);
     c->unk_00.x = c->unk_0C.x + sp68.x;
     c->unk_00.y = c->unk_0C.y + sp68.y;
     c->unk_00.z = c->unk_0C.z + sp68.z;
-    
+
     return sp44 + 1;
 }
 
-void func_80043F34(Camera *camera, Vec3f *b, Vec3f *c)
-{
+void func_80043F34(Camera* camera, Vec3f* b, Vec3f* c) {
     struct_80043D18 sp20;
     Vec3s unused;
-    
+
     sp20.unk_00 = *c;
     func_80043D18(camera, b, &sp20);
     *c = sp20.unk_00;
@@ -222,32 +202,31 @@ void func_80043F34(Camera *camera, Vec3f *b, Vec3f *c)
 // 242 lines
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_80043F94.s")
 
-void func_80044340(Camera *camera, Vec3f *b, Vec3f *c)
-{
+void func_80044340(Camera* camera, Vec3f* b, Vec3f* c) {
     struct_80043D18 sp20;
     Vec3s unused;
-    
+
     sp20.unk_00 = *c;
     func_80043F94(camera, b, &sp20);
     *c = sp20.unk_00;
 }
 
-#ifdef NON_MATCHING
 f32 func_80038B7C();
+
+#ifdef NON_MATCHING
 // ordering
-s32 func_800443A0(Camera *camera, Vec3f *b, Vec3f *c)
-{
+s32 func_800443A0(Camera* camera, Vec3f* b, Vec3f* c) {
     s32 sp4C;
     Vec3f sp40;
     s32 sp3C;
     s32 sp38;
-    CollisionPoly *sp34;
-    
+    CollisionPoly* sp34;
+
     sp34 = NULL; // this is moved to the top when it should be done in the middle of the function args being loaded
-    if (func_8003DD6C(&camera->globalCtx->colCtx, b, c, &sp40, &sp34, 1, 1, 1, 0, &sp38) != 0)
-    {
-        if (func_80038B7C(sp34, b) < 0.0f)
+    if (func_8003DD6C(&camera->globalCtx->colCtx, b, c, &sp40, &sp34, 1, 1, 1, 0, &sp38) != 0) {
+        if (func_80038B7C(sp34, b) < 0.0f) {
             return 1;
+        }
     }
     return 0;
 }
@@ -255,21 +234,17 @@ s32 func_800443A0(Camera *camera, Vec3f *b, Vec3f *c)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_800443A0.s")
 #endif
 
-f32 func_8003C940(CollisionContext *, CollisionPoly **, s32 *, Vec3f *);
-f32 func_80044434(Camera *camera, Vec3f *b, Vec3f *c, s32 *d)
-{
+f32 func_8003C940(CollisionContext*, CollisionPoly**, s32*, Vec3f*);
+f32 func_80044434(Camera* camera, Vec3f* b, Vec3f* c, s32* d) {
     s32 sp2C; // unused
-    CollisionPoly *sp28;
+    CollisionPoly* sp28;
     f32 temp_ret = func_8003C940(&camera->globalCtx->colCtx, &sp28, d, c);
-    
-    if (temp_ret == -32000.0f)
-    {
+
+    if (temp_ret == -32000.0f) {
         b->x = 0.0f;
         b->z = 0.0f;
         b->y = 1.0f;
-    }
-    else
-    {
+    } else {
         b->x = sp28->norm.x * (1.f / 32767);
         b->y = sp28->norm.y * (1.f / 32767);
         b->z = sp28->norm.z * (1.f / 32767);
@@ -278,32 +253,28 @@ f32 func_80044434(Camera *camera, Vec3f *b, Vec3f *c, s32 *d)
     return temp_ret;
 }
 
-void func_80044510(Camera *camera, Vec3f *b)
-{
+void func_80044510(Camera* camera, Vec3f* b) {
     Vec3f sp2C, sp20;
     s32 sp1C;
 
     sp2C = *b;
     sp2C.y += 80.0f;
-    
+
     func_80044434(camera, &sp20, &sp2C, &sp1C);
 }
 
 // 125 lines (loop)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_80044568.s")
 
-s16 func_80044740(Camera *camera, s32 b)
-{
+s16 func_80044740(Camera* camera, s32 b) {
     return func_80041A4C(&camera->globalCtx->colCtx, b, 50);
 }
 
-void func_8004476C(Camera *camera)
-{
+void func_8004476C(Camera* camera) {
     func_80041C10(&camera->globalCtx->colCtx, camera->unk_148, 50);
 }
 
-s32 func_8004479C(Camera *camera, s32 *b, Vec3f *c)
-{
+s32 func_8004479C(Camera* camera, s32* b, Vec3f* c) {
     s32 temp_ret;
     PosRot sp20;
     s32 ret;
@@ -311,78 +282,75 @@ s32 func_8004479C(Camera *camera, s32 *b, Vec3f *c)
     func_8002EF44(&sp20, &camera->player->actor);
     temp_ret = func_80041A28(&camera->globalCtx->colCtx, c, *b);
 
-    if (func_80041A4C(&camera->globalCtx->colCtx, temp_ret, *b) == 0)
+    if (func_80041A4C(&camera->globalCtx->colCtx, temp_ret, *b) == 0) {
         ret = -1;
-    else
+    } else {
         ret = temp_ret;
+    }
     return ret;
 }
 
-s32 func_8004481C(Camera *camera, s16 *arg1)
-{
-    CollisionPoly *sp44;
+s32 func_8004481C(Camera* camera, s16* arg1) {
+    CollisionPoly* sp44;
     s32 sp40; // unused
     s32 sp3C;
     PosRot sp28;
 
     func_8002EF44(&sp28, &camera->player->actor);
     sp28.pos.y += func_8002DC84(camera->player);
-    if (func_8003C940(&camera->globalCtx->colCtx, &sp44, &sp3C, &sp28.pos) == -32000.0f)
-    {
+    if (func_8003C940(&camera->globalCtx->colCtx, &sp44, &sp3C, &sp28.pos) == -32000.0f) {
         return 0;
     }
     *arg1 = func_80041B80(&camera->globalCtx->colCtx, sp44, sp3C);
     return func_80041C98(&camera->globalCtx->colCtx, sp44, sp3C);
 }
 
-s32 func_800448CC(Camera *camera, f32 *b)
-{
+s32 func_800448CC(Camera* camera, f32* b) {
     PosRot sp34;
     s32 sp30;
     s32 temp_ret;
 
     func_8002EF44(&sp34, &camera->player->actor);
     *b = sp34.pos.y;
-    
-    if (func_8004213C(camera->globalCtx, &camera->globalCtx->colCtx, sp34.pos.x, sp34.pos.z, b, &sp30) == 0)
-    {
+
+    if (func_8004213C(camera->globalCtx, &camera->globalCtx->colCtx, sp34.pos.x, sp34.pos.z, b, &sp30) == 0) {
         *b = -32000.0f;
         return -1;
     }
-    if (!(camera->player->stateFlags1 & 0x8000000))
-    {
+    if (!(camera->player->stateFlags1 & 0x8000000)) {
         *b = -32000.0f;
         return -1;
     }
-    
+
     temp_ret = func_80042538(&camera->globalCtx->colCtx, sp30);
-    if ((temp_ret <= 0) || (func_80042548(&camera->globalCtx->colCtx, sp30) <= 0))
+    if ((temp_ret <= 0) || (func_80042548(&camera->globalCtx->colCtx, sp30) <= 0)) {
         return -2;
-    
+    }
+
     return temp_ret;
 }
 
-f32 func_800449AC(Camera *camera, Vec3f *b, s32 *arg2)
-{
+f32 func_800449AC(Camera* camera, Vec3f* b, s32* arg2) {
     PosRot sp2C;
     f32 sp28;
     s32 sp24;
 
     func_8002EF44(&sp2C, &camera->player->actor);
     sp28 = sp2C.pos.y;
-    
-    if (func_8004213C(camera->globalCtx, &camera->globalCtx->colCtx, b->x, b->z, &sp28, &sp24) == 0)
+
+    if (func_8004213C(camera->globalCtx, &camera->globalCtx->colCtx, b->x, b->z, &sp28, &sp24) == 0) {
         return -32000.f;
-    if (sp28 < b->y)
+    }
+    if (sp28 < b->y) {
         return -32000.f;
+    }
 
     *arg2 = func_8004259C(&camera->globalCtx->colCtx, sp24);
     return sp28;
 }
 
-s16 func_80044A74(Vec3f *a, Vec3f *b)
-{
-    return func_800FD250(b->x - a->x, b->z - a->z) * (180 / M_PI) * (32767.5f / 180) + 0.5f;
+s16 func_80044A74(Vec3f* a, Vec3f* b) {
+    return Math_atan2f(b->x - a->x, b->z - a->z) * (180 / M_PI) * (32767.5f / 180) + 0.5f;
 }
 
 // 234 lines
@@ -391,17 +359,17 @@ s16 func_80044A74(Vec3f *a, Vec3f *b)
 // 143 lines (extremely confusing)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_80044E68.s")
 
-f32 func_800450A4(Camera *camera, f32 b)
-{
+f32 func_800450A4(Camera* camera, f32 b) {
     f32 ret;
-    
-    if (camera->unk_100 < (OREG(41) * 0.01f))
+
+    if (camera->unk_100 < (OREG(41) * 0.01f)) {
         ret = OREG(41) * 0.01f;
-    else if (b <= camera->unk_100)
+    } else if (b <= camera->unk_100) {
         ret = b;
-    else
+    } else {
         ret = OREG(42) * 0.01f * camera->unk_100;
-    
+    }
+
     return ret;
 }
 
@@ -414,17 +382,15 @@ f32 func_800450A4(Camera *camera, f32 b)
 // 76 lines (unknown types)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_80045350.s")
 
-void *func_8004545C(Vec3f *a, s32 b, s32 c, struct_80043D18 *d, struct_80043D18 *e)
-{
+void* func_8004545C(Vec3f* a, s32 b, s32 c, struct_80043D18* d, struct_80043D18* e) {
     Vec3f sp24;
 
-    if (func_800427B4(d->unk_18, e->unk_18, b, c, &sp24) == 0)
-    {
+    if (func_800427B4(d->unk_18, e->unk_18, b, c, &sp24) == 0) {
         osSyncPrintf(VT_COL(YELLOW, BLACK) "camera: corner check no cross point %x %x\n" VT_RST, d, e);
         *a = d->unk_00;
         return a;
     }
-    
+
     *a = sp24;
     return a;
 }
@@ -434,8 +400,7 @@ void *func_8004545C(Vec3f *a, s32 b, s32 c, struct_80043D18 *d, struct_80043D18
 
 #ifdef NON_MATCHING
 // CLOSE: stack is 4 bytes too big
-f32 func_80045714(Vec3f *a, s16 b, s16 c, f32 arg3)
-{
+f32 func_80045714(Vec3f* a, s16 b, s16 c, f32 arg3) {
     struct_80045714 sp1C;
     f32 sp18;
 
@@ -445,131 +410,126 @@ f32 func_80045714(Vec3f *a, s16 b, s16 c, f32 arg3)
     return Math_Coss(b - c) * (sp18 * arg3);
 }
 #else
-f32 func_80045714(Vec3f *a, s16 b, s16 c, f32 arg3);
+f32 func_80045714(Vec3f* a, s16 b, s16 c, f32 arg3);
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_80045714.s")
 #endif
 
-#ifdef NON_MATCHING
 f32 func_8007C0A8(f32, f32);
-// CLOSE: stack is slightly off, probably a temp var
-s32 func_800457A8(Camera *camera, struct_80045714 *b, f32 c, s16 d)
-{
+
+s32 func_800457A8(Camera* camera, struct_80045714* b, f32 c, s16 d) {
     f32 unused;
     Vec3f sp50;
     Vec3f sp44;
     s32 unused2;
+    PosRot* sp2C;
     f32 temp_ret;
-    PosRot *sp2C;
-    
+
     temp_ret = func_8002DC84(camera->player);
 
     sp50.x = 0.f;
     sp50.z = 0.f;
     sp50.y = temp_ret + c;
-    
+
     sp2C = &camera->unk_94;
-    if (d != 0)
-    {
+    if (d != 0) {
         sp50.y -= func_8007C0A8(func_80045714(&camera->unk_108, sp2C->rot.y, b->unk_06, OREG(9)), temp_ret);
     }
     func_80043A3C(&sp50, &camera->unk_E4, camera->unk_CC.y, camera->unk_CC.x, 0.1f);
-    
+
     sp44.x = sp2C->pos.x + camera->unk_E4.x;
     sp44.y = sp2C->pos.y + camera->unk_E4.y;
     sp44.z = sp2C->pos.z + camera->unk_E4.z;
     func_80043A3C(&sp44, &camera->unk_50, camera->unk_100, camera->unk_100, 0.2f);
-    
+
     return 1;
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_800457A8.s")
-#endif
+
+f32 func_8007C028(Vec3f*, Vec3f*);
 
 #ifdef NON_MATCHING
-f32 func_8007C028(Vec3f *, Vec3f *);
-// CLOSE: regalloc, plus stack is slightly off, probably a temp var
-s32 func_800458D4(Camera *camera, struct_80045714 *b, f32 c, f32 *d, s16 e)
-{
+// CLOSE: regalloc
+s32 func_800458D4(Camera* camera, struct_80045714* b, f32 c, f32* d, s16 e) {
     f32 phi_f2;
     Vec3f sp60;
     Vec3f sp54;
     f32 temp_ret;
-    PosRot *temp_s1;
+    PosRot* temp_s1;
     f32 sp48;
-    Vec3f sp3C; // unused
+    s32 pad[2];
 
     sp60.y = func_8002DC84(camera->player) + c;
     sp60.x = 0.0f;
     sp60.z = 0.0f;
-    
+
     temp_s1 = &camera->unk_94;
-    if (e != 0)
+    if (e != 0) {
         sp60.y -= func_80045714(&camera->unk_108, temp_s1->rot.y, b->unk_06, OREG(9));
-    
+    }
+
     sp48 = temp_s1->pos.y - *d;
-    temp_ret = func_800FD250(sp48, func_8007C028(&camera->unk_50, &camera->unk_5C)); // f2 and f14 are swapped
-    
-    if (OREG(32) * (M_PI / 180) < temp_ret)
+    temp_ret = Math_atan2f(sp48, func_8007C028(&camera->unk_50, &camera->unk_5C)); // f2 and f14 are swapped
+
+    if (OREG(32) * (M_PI / 180) < temp_ret) {
         phi_f2 = 1.0f - sinf(temp_ret - OREG(32) * (M_PI / 180));
-    else if (OREG(33) * (M_PI / 180) > temp_ret)
+    } else if (OREG(33) * (M_PI / 180) > temp_ret) {
         phi_f2 = 1.0f - sinf(OREG(33) * (M_PI / 180) - temp_ret);
-    else
+    } else {
         phi_f2 = 1.0f;
-    
+    }
+
     sp60.y -= sp48 * phi_f2;
     func_80043A3C(&sp60, &camera->unk_E4, OREG(29) * 0.01f, OREG(30) * 0.01f, 0.1f);
-    
+
     sp54.x = temp_s1->pos.x + camera->unk_E4.x;
     sp54.y = temp_s1->pos.y + camera->unk_E4.y;
     sp54.z = temp_s1->pos.z + camera->unk_E4.z;
     func_80043A3C(&sp54, &camera->unk_50, camera->unk_100, camera->unk_100, 0.2f);
-    
+
     return 1;
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_800458D4.s")
 #endif
 
-s32 func_80045B08(Camera *camera, struct_80045714 *b, f32 c, s16 d)
-{
+s32 func_80045B08(Camera* camera, struct_80045714* b, f32 c, s16 d) {
     f32 phi_f2;
     Vec3f sp48;
     Vec3f sp3C;
     f32 sp38; // unused
     f32 temp_ret;
-    PosRot *temp_s1;
+    PosRot* temp_s1;
 
     sp48.y = func_8002DC84(camera->player) + c;
     sp48.x = 0.0f;
     sp48.z = 0.0f;
-    
-    temp_ret = Math_Sins((s32) d);
+
+    temp_ret = Math_Sins((s32)d);
     temp_s1 = &camera->unk_94;
-    
-    if (temp_ret < 0.0f)
+
+    if (temp_ret < 0.0f) {
         phi_f2 = Math_Coss(temp_s1->rot.y - b->unk_06);
-    else
+    } else {
         phi_f2 = -Math_Coss(temp_s1->rot.y - b->unk_06);
-    
+    }
+
     sp48.y -= temp_ret * phi_f2 * OREG(9);
     func_80043A3C(&sp48, &camera->unk_E4, camera->unk_CC.y, camera->unk_CC.x, 0.1f);
-    
+
     sp3C.x = temp_s1->pos.x + camera->unk_E4.x;
     sp3C.y = temp_s1->pos.y + camera->unk_E4.y;
     sp3C.z = temp_s1->pos.z + camera->unk_E4.z;
     func_80043A3C(&sp3C, &camera->unk_50, camera->unk_100, camera->unk_100, 0.2f);
-    
+
     return 1;
 }
 
-#ifdef NON_MATCHING
+/*
 // someone who's not me can have fun with this function
-s32 func_80045C74(Camera *camera, struct_80045714 *b, f32 c, f32 *d, s16 arg4)
-{
+s32 func_80045C74(Camera* camera, struct_80045714* b, f32 c, f32* d, s16 arg4) {
     Vec3f sp70;
     Vec3f sp64;
     f32 sp54;
-    PosRot *sp3C;
+    PosRot* sp3C;
     f32 temp;
     f32 temp_f2;
     f32 temp_ret_3;
@@ -579,217 +539,186 @@ s32 func_80045C74(Camera *camera, struct_80045714 *b, f32 c, f32 *d, s16 arg4)
     sp70.y = func_8002DC84(camera->player) + c;
     sp70.x = 0.0f;
     sp70.z = 0.0f;
-    
-    if (PREG(76) != 0)
-    {
-        if (arg4 != 0)
-        {
+
+    if (PREG(76) != 0) {
+        if (arg4 != 0) {
             sp70.y -= func_80045714(&camera->unk_108, sp3C->rot.y, b->unk_06, OREG(9));
         }
     }
-    
+
     sp3C = &camera->unk_94;
-    
-    if ((sp3C->pos.y == camera->unk_104) || (camera->player->actor.gravity > -0.1f) || (camera->player->stateFlags1 & 0x200000))
-    {
+
+    if ((sp3C->pos.y == camera->unk_104) || (camera->player->actor.gravity > -0.1f) ||
+        (camera->player->stateFlags1 & 0x200000)) {
         *d = func_8004389C(sp3C->pos.y, *d, OREG(43) * 0.01f, 0.1f);
         sp70.y -= sp3C->pos.y - *d;
         func_80043A3C(&sp70, &camera->unk_E4, camera->unk_CC.y, camera->unk_CC.x, 0.1f);
-    }
-    else
-    {
+    } else {
         temp = sp3C->pos.y - *d;
-        if (PREG(75) == 0)
-        {
+        if (PREG(75) == 0) {
             sp54 = func_8007C028(&camera->unk_50, &camera->unk_5C);
-            func_800FD250(temp, sp54);
-            temp_f2 = func_800FCE80(camera->unk_FC * 0.4f * (M_PI / 180)) * sp54;
-            
-            if (temp > temp_f2)
-            {
+            Math_atan2f(temp, sp54);
+            temp_f2 = Math_tanf(camera->unk_FC * 0.4f * (M_PI / 180)) * sp54;
+
+            if (temp > temp_f2) {
                 *d += temp - temp_f2;
                 phi_f20 = temp_f2;
-            }
-            else
-            {
+            } else {
                 phi_f20 = temp;
-                if (temp < -temp_f2)
-                {
+                if (temp < -temp_f2) {
                     *d += temp + temp_f2;
                     phi_f20 = -temp_f2;
                 }
             }
             sp70.y -= phi_f20;
-        }
-        else
-        {
-            temp_ret_3 = func_800FD250(temp, func_8007C028(&camera->unk_50, &camera->unk_5C));
-            
+        } else {
+            temp_ret_3 = Math_atan2f(temp, func_8007C028(&camera->unk_50, &camera->unk_5C));
+
             if (OREG(32) * (M_PI / 180) < temp_ret_3)
                 phi_f16 = 1.0f - sinf(temp_ret_3 - OREG(32) * (M_PI / 180));
             else if (temp_ret_3 < OREG(33) * (M_PI / 180))
                 phi_f16 = 1.0f - sinf(OREG(33) * (M_PI / 180) - temp_ret_3);
             else
                 phi_f16 = 1.0f;
-            }
-            
+
             sp70.y -= temp * phi_f16;
         }
-        
+
         func_80043A3C(&sp70, &camera->unk_E4, OREG(29) * 0.01f, OREG(30) * 0.01f, 0.1f);
         camera->unk_CC.y = OREG(29) * 0.01f;
         camera->unk_CC.x = OREG(30) * 0.01f;
     }
-    
+
     sp64.x = sp3C->pos.x + camera->unk_E4.x;
     sp64.y = sp3C->pos.y + camera->unk_E4.y;
     sp64.z = sp3C->pos.z + camera->unk_E4.z;
     func_80043A3C(&sp64, &camera->unk_50, camera->unk_100, camera->unk_100, 0.2f);
-    
+
     return 1;
 }
-#else
+*/
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_80045C74.s")
-#endif
 
 // 421 lines
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_800460A8.s")
 
-s32 func_800466F8(Camera *camera, struct_80045714 *b, f32 c, f32 *d, s16 e)
-{
+s32 func_800466F8(Camera* camera, struct_80045714* b, f32 c, f32* d, s16 e) {
     s32 phi_v0;
     Vec3f sp60;
     Vec3f sp54;
     f32 sp50; // unused
     f32 sp4C; // unused
     f32 sp48; // I doubt this is a Vec3f
-    Player *sp44;
+    Player* sp44;
     PosRot sp30;
 
     sp48 = func_8002DC84(camera->player);
     sp44 = camera->player;
     func_8002EF44(&sp30, sp44->rideActor);
-    
-    if ((*(s32 *)((s32)(sp44->rideActor) + 0x1F0) & 4) != 0) // actors aren't this big, is rideActor a different type?
+
+    if ((*(s32*)((s32)(sp44->rideActor) + 0x1F0) & 4) != 0) { // actors aren't this big, is rideActor a different type?
         phi_v0 = 1;
-    else
+    } else {
         phi_v0 = 0;
-    
-    if (phi_v0 != 0)
-    {
+    }
+
+    if (phi_v0 != 0) {
         sp30.pos.y -= 49.f;
         *d = func_8004389C(sp30.pos.y, *d, 0.1f, 0.2f);
         camera->unk_100 = func_8004389C(0.4f, camera->unk_100, 0.2f, 0.02f);
-    }
-    else
-    {
+    } else {
         *d = func_8004389C(sp30.pos.y, *d, 0.5f, 0.2f);
     }
-    
+
     sp60.x = 0.0f;
     sp60.z = 0.0f;
     sp60.y = sp48 + c;
-    
-    if (e != 0)
+
+    if (e != 0) {
         sp60.y -= func_80045714(&camera->unk_108, camera->unk_94.rot.y, b->unk_06, OREG(9));
-    
+    }
+
     func_80043A3C(&sp60, &camera->unk_E4, camera->unk_CC.y, camera->unk_CC.x, 0.1f);
-    
+
     sp54.x = camera->unk_E4.x + sp30.pos.x;
     sp54.y = camera->unk_E4.y + sp30.pos.y;
     sp54.z = camera->unk_E4.z + sp30.pos.z;
     func_80043A3C(&sp54, &camera->unk_50, camera->unk_100, camera->unk_100, 0.2f);
-    
+
     return 1;
 }
 
-void func_800468CC(Camera *camera, f32 b, f32 c, f32 d)
-{
+void func_800468CC(Camera* camera, f32 b, f32 c, f32 d) {
     f32 sp1C;
     f32 phi_f12;
 
-    if (b < c)
-    {
+    if (b < c) {
         sp1C = c;
         phi_f12 = OREG(6);
-    }
-    else if (d < b)
-    {
+    } else if (d < b) {
         sp1C = d;
         phi_f12 = OREG(6);
-    }
-    else
-    {
+    } else {
         sp1C = b;
         phi_f12 = 1.0f;
     }
-    
+
     camera->unk_C0.x = func_8004389C(phi_f12, camera->unk_C0.x, OREG(25) * 0.01f, 0.1f);
     func_8004389C(sp1C, camera->unk_DC, 1.f / camera->unk_C0.x, 0.2f);
 }
 
-void func_800469C0(Camera *camera, f32 b, f32 c, f32 d, s16 e)
-{
+void func_800469C0(Camera* camera, f32 b, f32 c, f32 d, s16 e) {
     f32 sp1C;
     f32 phi_f12;
 
-    if (b < c)
-    {
+    if (b < c) {
         sp1C = c;
-        
-        if (e != 0)
+
+        if (e != 0) {
             phi_f12 = OREG(6) * 0.5f;
-        else
+        } else {
             phi_f12 = OREG(6);
-    }
-    else if (d < b)
-    {
+        }
+    } else if (d < b) {
         sp1C = d;
-        
-        if (e != 0)
+
+        if (e != 0) {
             phi_f12 = OREG(6) * 0.5f;
-        else
+        } else {
             phi_f12 = OREG(6);
-    }
-    else
-    {
+        }
+    } else {
         sp1C = b;
-        
-        if (e != 0)
+
+        if (e != 0) {
             phi_f12 = OREG(6);
-        else
+        } else {
             phi_f12 = 1.0f;
+        }
     }
-    
+
     camera->unk_C0.x = func_8004389C(phi_f12, camera->unk_C0.x, OREG(25) * 0.01f, 0.1f);
     func_8004389C(sp1C, camera->unk_DC, 1.f / camera->unk_C0.x, 0.2f);
 }
 
 #ifdef NON_MATCHING
 // lots of regalloc and stack issues, but that's it
-void func_80046B44(Camera *camera, s16 b, s16 c, s16 d)
-{
+void func_80046B44(Camera* camera, s16 b, s16 c, s16 d) {
     s16 sp1C;
     s16 phi_v1;
     s16 phi_v0;
     f32 phi_a2;
 
     phi_v1 = ABS(b);
-    if (d > 0)
-    {
+    if (d > 0) {
         phi_v0 = Math_Coss(d) * d;
-    }
-    else
-    {
+    } else {
         phi_v0 = d;
     }
     sp1C = c - phi_v0;
-    if (ABS(sp1C) < phi_v1)
-    {
+    if (ABS(sp1C) < phi_v1) {
         phi_a2 = (1.0f / camera->unk_C0.y) * 3.0f;
-    }
-    else
-    {
+    } else {
         phi_a2 = (1.0f / camera->unk_C0.y) * func_800437F0(0.8f, 1.0f - phi_v0 * (1.0f / OREG(5)));
     }
     func_8004391C(sp1C, b, phi_a2, 0xa);
@@ -800,33 +729,28 @@ void func_80046B44(Camera *camera, s16 b, s16 c, s16 d)
 
 #ifdef NON_MATCHING
 // stack, regalloc, tiny bit of ordering
-s16 func_80046CB4(Camera *camera, s16 b, s16 c, f32 d, f32 e)
-{
+s16 func_80046CB4(Camera* camera, s16 b, s16 c, f32 d, f32 e) {
     f32 sp34;
     s16 sp1C;
     f32 temp_ret;
     f32 phi_f14;
-	s16 temp;
+    s16 temp;
 
-    if (camera->unk_D8 > 0.001f)
-    {
-		temp = b - 0x7fff; // this is probably some kind of cast that I'm too stupid to know
+    if (camera->unk_D8 > 0.001f) {
+        temp = b - 0x7fff; // this is probably some kind of cast that I'm too stupid to know
         sp1C = c - temp;
         phi_f14 = (s16)(sp1C - 0x7fff) * 0.00003051851f;
-    }
-    else
-    {
-		temp = b - 0x7fff;
+    } else {
+        temp = b - 0x7fff;
         sp1C = c - temp;
         phi_f14 = OREG(48) * 0.01f;
     }
     temp_ret = func_800437F0(d, phi_f14);
     sp34 = ((1.0f - temp_ret) * e) + temp_ret;
-    if (sp34 < 0.0f)
-    {
+    if (sp34 < 0.0f) {
         sp34 = 0.0f;
     }
-	// ordering stuff here
+    // ordering stuff here
     return (s16)((sp1C * sp34) * (1.0f / camera->unk_C0.z) * func_800437F0(0.5f, camera->unk_E0)) + b;
 }
 #else
@@ -836,8 +760,7 @@ s16 func_80046CB4(Camera *camera, s16 b, s16 c, f32 d, f32 e)
 // 364 lines
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_80046E20.s")
 
-s32 func_80047394(Camera *camera)
-{
+s32 func_80047394(Camera* camera) {
     return 1;
 }
 
@@ -850,13 +773,11 @@ s32 func_80047394(Camera *camera)
 // Very long function (1,444 lines), 1 jtbl
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_80052E0C.s")
 
-void Camera_DebugPrintSplineArray(char* name, s16 length, SplineData splines[])
-{
+void Camera_DebugPrintSplineArray(char* name, s16 length, SplineData splines[]) {
     s32 i;
-    
+
     osSyncPrintf("static SplinedatZ  %s[] = {\n", name);
-    for (i = 0; i < length; i++)
-    {
+    for (i = 0; i < length; i++) {
         osSyncPrintf("    /* key frame %2d */ {\n", i);
         osSyncPrintf("    /*     code     */ %d,\n", splines[i].code);
         osSyncPrintf("    /*     z        */ %d,\n", splines[i].z);
@@ -868,8 +789,7 @@ void Camera_DebugPrintSplineArray(char* name, s16 length, SplineData splines[])
     osSyncPrintf("};\n\n");
 }
 
-void Camera_Vec3fCopy(Vec3f *src, Vec3f *dst)
-{
+void Camera_Vec3fCopy(Vec3f* src, Vec3f* dst) {
     dst->x = src->x;
     dst->y = src->y;
     dst->z = src->z;
@@ -881,54 +801,38 @@ void Camera_Vec3fCopy(Vec3f *src, Vec3f *dst)
 // 225 lines
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_80057C6C.s")
 
-#ifdef NON_MATCHING
-// still needs a bit of work, but should be functionally equivalent
-void func_80057FC4(Camera *camera)
-{
-    if (camera != &camera->globalCtx->cameraCtx.activeCameras[0])
-    {
-        camera->unk_142 = 33;
+s32 func_8005AD40(Camera* camera, s32 a, s16 b, f32 c, s16 d, s16 e, s16 f);
+
+void func_80057FC4(Camera* camera) {
+    if (camera != &camera->globalCtx->cameraCtx.activeCameras[0]) {
+        camera->unk_154 = camera->unk_142 = 33;
         camera->unk_14C &= ~0x4;
-        camera->unk_154 = camera->unk_142; // compiler uses the same temp reg, but it should load from 142 right after being saved to
-        // maybe try camera->unk_154 = camera->unk_142 = 33 and make them have differing signs?
-        return;
-    }
-    // try putting these in a bunch of if else statements
-    if (*camera->globalCtx->roomCtx.curRoom.unk_08 != 1)
-    {
-        if (camera->globalCtx->roomCtx.curRoom.unk_03 != 0)
-        {
-            if (camera->globalCtx->roomCtx.curRoom.unk_03 == 1)
-            {
+    } else if (camera->globalCtx->roomCtx.curRoom.mesh->polygon.type != 1) {
+        switch (camera->globalCtx->roomCtx.curRoom.unk_03) {
+            case 1:
                 func_8005AD40(camera, 0, -99, 0, 0, 18, 10);
-                camera->unk_142 = 3;
-                camera->unk_154 = camera->unk_142;
-                return;
-            }
-            osSyncPrintf("camera: room type: default set etc (%d)\n", camera->globalCtx->roomCtx.curRoom.unk_03);
-            func_8005AD40(camera, 0, -99, 0, 0, 18, 10);
-            camera->unk_142 = 1;
-            camera->unk_154 = camera->unk_142;
-            return;
+                camera->unk_154 = camera->unk_142 = 3;
+                break;
+            case 0:
+                osSyncPrintf("camera: room type: default set field\n");
+                func_8005AD40(camera, 0, -99, 0, 0, 18, 10);
+                camera->unk_154 = camera->unk_142 = 1;
+                break;
+            default:
+                osSyncPrintf("camera: room type: default set etc (%d)\n", camera->globalCtx->roomCtx.curRoom.unk_03);
+                func_8005AD40(camera, 0, -99, 0, 0, 18, 10);
+                camera->unk_154 = camera->unk_142 = 1;
+                camera->unk_14C |= 4;
+                break;
         }
-        osSyncPrintf("camera: room type: default set field\n");
-        func_8005AD40(camera, 0, -99, 0, 0, 18, 10);
-        camera->unk_142 = 1;
-        camera->unk_14C |= 4;
-        camera->unk_154 = camera->unk_142;
-        return;
+    } else {
+        osSyncPrintf("camera: room type: prerender\n");
+        camera->unk_154 = camera->unk_142 = 33;
+        camera->unk_14C &= ~0x4;
     }
-    osSyncPrintf("camera: room type: prerender\n");
-    camera->unk_142 = 0x21;
-    camera->unk_14C &= 0xfffb;
-    camera->unk_154 = camera->unk_142;
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_80057FC4.s")
-#endif
 
-void Camera_Stub80058140(Camera *camera)
-{
+void Camera_Stub80058140(Camera* camera) {
 }
 
 // 135 lines (has lwl/lwr)
@@ -943,13 +847,13 @@ void Camera_Stub80058140(Camera *camera)
 // 296 lines
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_800588B4.s")
 
-s32 func_80058CF8(Camera *camera)
-{
+s32 func_80058CF8(Camera* camera) {
     camera->unk_152 &= ~1;
-    
-    if (camera->globalCtx->roomCtx.curRoom.unk_02 == 3)
+
+    if (camera->globalCtx->roomCtx.curRoom.unk_02 == 3) {
         camera->unk_152 |= 1;
-    
+    }
+
     return 1;
 }
 
@@ -962,49 +866,47 @@ s32 func_80058CF8(Camera *camera)
 // Long function, 866 lines (lots of debug symbols)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_800591EC.s")
 
-void func_80059EC8(Camera *camera)
-{
-    Camera *sp24 = camera->globalCtx->cameraCtx.activeCameraPtrs[0];
-    Player *player = (Player *)camera->globalCtx->actorCtx.actorList[2].first;
-    
-    if (camera->unk_160 == 0)
-    {
+void func_80059EC8(Camera* camera) {
+    Camera* sp24 = camera->globalCtx->cameraCtx.activeCameraPtrs[0];
+    Player* player = (Player*)camera->globalCtx->actorCtx.actorList[2].first;
+
+    if (camera->unk_160 == 0) {
         func_800C0314(camera->globalCtx, camera->unk_162, 7);
-        
-        if ((camera->unk_162 == 0) && (camera->unk_168 != 0))
-        {
+
+        if ((camera->unk_162 == 0) && (camera->unk_168 != 0)) {
             player->actor.freeze = 0;
             player->stateFlags1 &= ~0x20000000;
-            
-            if (player->action != 0)
-            {
+
+            if (player->action != 0) {
                 func_8002DF54(camera->globalCtx, &player->actor, 7);
                 osSyncPrintf("camera: player demo end!!\n");
             }
-            
+
             sp24->unk_14C |= 8;
         }
 
-        if (camera->globalCtx->cameraCtx.activeCameraPtrs[camera->unk_14E]->unk_162 == camera->unk_164)
+        if (camera->globalCtx->cameraCtx.activeCameraPtrs[camera->unk_14E]->unk_162 == camera->unk_164) {
             camera->globalCtx->cameraCtx.activeCameraPtrs[camera->unk_14E]->unk_162 = camera->unk_162;
-        
-        if (camera->globalCtx->cameraCtx.activeCameraPtrs[camera->unk_162]->unk_14E == camera->unk_164)
+        }
+
+        if (camera->globalCtx->cameraCtx.activeCameraPtrs[camera->unk_162]->unk_14E == camera->unk_164) {
             camera->globalCtx->cameraCtx.activeCameraPtrs[camera->unk_162]->unk_14E = camera->unk_14E;
+        }
 
-        if (camera->globalCtx->cameraCtx.activeCameraPtrs[camera->unk_162]->unk_164 == 0)
+        if (camera->globalCtx->cameraCtx.activeCameraPtrs[camera->unk_162]->unk_164 == 0) {
             camera->globalCtx->cameraCtx.activeCameraPtrs[camera->unk_162]->unk_15E = 0;
-        
+        }
+
         camera->unk_162 = 0;
         camera->unk_14E = camera->unk_162;
         camera->unk_160 = -1;
         camera->globalCtx->unk_10B05 = 0;
-        
+
         func_800C0384(camera->globalCtx, camera->unk_164);
     }
 }
 
-s32 func_8005A02C(Camera *camera)
-{
+s32 func_8005A02C(Camera* camera) {
     camera->unk_14C |= 0xC;
     camera->unk_14C &= ~(0x1000 | 0x8);
     return 1;
@@ -1013,8 +915,7 @@ s32 func_8005A02C(Camera *camera)
 // 275 lines (has 2 jtbls)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_8005A04C.s")
 
-void func_8005A444(Camera *camera, s16 b)
-{
+void func_8005A444(Camera* camera, s16 b) {
     func_8005A04C(camera, b, 0);
 }
 
@@ -1024,8 +925,7 @@ void func_8005A444(Camera *camera, s16 b)
 // 154 lines (unknown arrays)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_8005A548.s")
 
-s32 func_8005A77C(Camera *camera, s16 b)
-{
+s32 func_8005A77C(Camera* camera, s16 b) {
     return func_8005A548(camera, b, 0);
 }
 
@@ -1047,95 +947,83 @@ s32 func_8005A77C(Camera *camera, s16 b)
 // 118 lines (has 1 jtbl)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_camera/func_8005AA90.s")
 
-s32 func_8005AC48(Camera *camera, s16 b)
-{
+s32 func_8005AC48(Camera* camera, s16 b) {
     camera->unk_14C = b;
     return 1;
 }
 
-s32 func_8005AC60(Camera *camera)
-{
+s32 func_8005AC60(Camera* camera) {
     camera->unk_15E = 0;
     return 1;
 }
 
-s32 func_8005AC6C(Camera *camera, s32 b, s32 c, Player *d, s16 e)
-{
+s32 func_8005AC6C(Camera* camera, s32 b, s32 c, Player* d, s16 e) {
     PosRot sp24;
 
     camera->unk_124 = b;
     camera->unk_128 = c;
     camera->unk_12C = e;
-    
-    if (camera->unk_12C != 0)
-    {
+
+    if (camera->unk_12C != 0) {
         camera->player = d;
         func_8002EF44(&sp24, &d->actor);
         camera->unk_94 = sp24;
-        
+
         camera->unk_156 = -1;
         camera->unk_D8 = 0.0f;
         camera->unk_E0 = 0.0f;
     }
-    
+
     return 1;
 }
 
-s16 func_8005ACFC(Camera *camera, s16 b)
-{
+s16 func_8005ACFC(Camera* camera, s16 b) {
     camera->unk_14C |= b;
     return camera->unk_14C;
 }
 
-s16 func_8005AD1C(Camera *camera, s16 b)
-{
+s16 func_8005AD1C(Camera* camera, s16 b) {
     camera->unk_14C &= ~b;
     return camera->unk_14C;
 }
 
-s32 func_8005AD40(Camera *camera, s32 a, s16 b, s16 c, s16 d, s16 e, s16 f)
-{
-    if ((camera->unk_142 == 43) || (camera->unk_142 == 29))
+s32 func_8005AD40(Camera* camera, s32 a, s16 b, f32 c, s16 d, s16 e, s16 f) {
+    if ((camera->unk_142 == 43) || (camera->unk_142 == 29)) {
         return 0;
-    
+    }
+
     camera->unk_00 = a;
     camera->unk_06 = d;
     camera->unk_08 = e;
     camera->unk_0A = f;
     camera->unk_04 = b;
-    
-    if (b == -99)
-    {
+
+    if (b == -99) {
         func_80045128(camera, camera->unk_144);
         return -99;
     }
-    
-    if (b == -1)
-    {
+
+    if (b == -1) {
         func_8005A77C(camera, 29);
         osSyncPrintf(".... change default door camera (set %d)\n", 29);
-    }
-    else
-    {
+    } else {
         s32 ret = func_80044740(camera, b);
         camera->unk_14A |= 0x40;
-        
-        if (func_8005A77C(camera, ret) >= 0)
-        {
+
+        if (func_8005A77C(camera, ret) >= 0) {
             camera->unk_148 = b;
             camera->unk_14A |= 4;
         }
-        
+
         // this is likely important for labelling unk_148 and unk_142
         osSyncPrintf("....change door camera ID %d (set %d)\n", camera->unk_148, camera->unk_142);
     }
-    
+
     func_80045128(camera, camera->unk_144);
     return -1;
 }
 
-s32 func_8005AE64(Camera *camera, Camera *otherCamera)
-{
+s32 func_8005AE64(Camera* camera, Camera* otherCamera) {
     s32 unused;
     Vec3f sp30;
 
@@ -1144,7 +1032,7 @@ s32 func_8005AE64(Camera *camera, Camera *otherCamera)
     camera->unk_E4.z = 0.0f;
     camera->unk_100 = 0.1f;
     camera->unk_50 = otherCamera->unk_50;
-    
+
     sp30 = otherCamera->unk_5C;
     camera->unk_74 = sp30;
     camera->unk_5C = sp30;
@@ -1153,9 +1041,8 @@ s32 func_8005AE64(Camera *camera, Camera *otherCamera)
     camera->unk_FC = otherCamera->unk_FC;
     camera->unk_15A = otherCamera->unk_15A;
     func_80043B60(camera);
-    
-    if (camera->player != NULL)
-    {
+
+    if (camera->player != NULL) {
         func_8002EF14(&camera->unk_94, &camera->player->actor);
         camera->unk_E4.x = camera->unk_50.x - camera->unk_94.pos.x;
         camera->unk_E4.y = camera->unk_50.y - camera->unk_94.pos.y;
@@ -1167,39 +1054,40 @@ s32 func_8005AE64(Camera *camera, Camera *otherCamera)
     return 1;
 }
 
-s32 func_8005AFA8()
-{
+s32 func_8005AFA8() {
     return D_8011D394;
 }
 
-Vec3f *func_8005AFB4(Vec3f *dst, Camera *camera)
-{
+Vec3f* func_8005AFB4(Vec3f* dst, Camera* camera) {
     *dst = camera->unk_80;
     return dst;
 }
 
-void Camera_SetCameraData(Camera *camera, s16 b, s32 c, s32 d, s16 e, s16 f) // Unused
-{
-    if (b & 0x1)
+// Unused
+void Camera_SetCameraData(Camera* camera, s16 b, s32 c, s32 d, s16 e, s16 f) {
+    if (b & 0x1) {
         camera->unk_124 = c;
-    
-    if (b & 0x2)
+    }
+
+    if (b & 0x2) {
         camera->unk_128 = d;
-    
-    if (b & 0x4)
+    }
+
+    if (b & 0x4) {
         camera->unk_12C = e;
-    
-    if (b & 0x8)
+    }
+
+    if (b & 0x8) {
         camera->unk_12E = f;
-    
-    if (b & 0x10)
+    }
+
+    if (b & 0x10) {
         osSyncPrintf(VT_COL(RED, WHITE) "camera: setCameraData: last argument not alive!\n" VT_RST, b);
+    }
 }
 
-s32 func_8005B044()
-{
-    if (QREG(0) == 0)
-    {
+s32 func_8005B044() {
+    if (QREG(0) == 0) {
         QREG(2) = 1;
         QREG(10) = -1;
         QREG(11) = 100;
@@ -1228,25 +1116,22 @@ s32 func_8005B044()
         QREG(57) = 30;
         QREG(58) = 0;
     }
-    
+
     QREG(65) = 50;
     return 1;
 }
 
-s32 func_8005B198()
-{
+s32 func_8005B198() {
     return D_8011D3AC;
 }
 
-s16 func_8005B1A4(Camera *camera)
-{
+s16 func_8005B1A4(Camera* camera) {
     camera->unk_14C |= 0x8;
-    
-    if ((camera->unk_164 == 0) && (camera->globalCtx->cameraCtx.unk_5C0 != 0))
-    {
+
+    if ((camera->unk_164 == 0) && (camera->globalCtx->cameraCtx.unk_5C0 != 0)) {
         camera->globalCtx->cameraCtx.activeCameraPtrs[camera->globalCtx->cameraCtx.unk_5C0]->unk_14C |= 0x8;
         return camera->globalCtx->cameraCtx.unk_5C0;
     }
-    
+
     return camera->unk_164;
 }
diff --git a/src/code/z_cheap_proc.c b/src/code/z_cheap_proc.c
new file mode 100644
index 000000000..3b83d1b71
--- /dev/null
+++ b/src/code/z_cheap_proc.c
@@ -0,0 +1,30 @@
+#include <ultra64.h>
+#include <global.h>
+
+void Gfx_DrawDListOpa(GlobalContext* globalCtx, u32 dlist) {
+    GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
+    Gfx* dispRefs[4];
+
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 214);
+
+    func_80093D18(globalCtx->state.gfxCtx);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_cheap_proc.c", 216),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPDisplayList(gfxCtx->polyOpa.p++, dlist);
+
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 219);
+}
+
+void Gfx_DrawDListXlu(GlobalContext* globalCtx, u32 dlist) {
+    GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
+    Gfx* dispRefs[4];
+
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 228);
+
+    func_80093D84(globalCtx->state.gfxCtx);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_cheap_proc.c", 230),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPDisplayList(gfxCtx->polyXlu.p++, dlist);
+
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 233);
+}
diff --git a/src/code/z_collision_check.c b/src/code/z_collision_check.c
index 116059b18..b8a70550d 100644
--- a/src/code/z_collision_check.c
+++ b/src/code/z_collision_check.c
@@ -7,15 +7,13 @@
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/func_8005B65C.s")
 
-s32 func_8005B6A0(GlobalContext* globalCtx, Collider* collision)
-{
+s32 func_8005B6A0(GlobalContext* globalCtx, Collider* collision) {
     return 1;
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/func_8005B6B0.s")
 
-s32 func_8005B6EC(GlobalContext* globalCtx, Collider* collision, Actor* actor, ColliderBodyInfo* src)
-{
+s32 func_8005B6EC(GlobalContext* globalCtx, Collider* collision, Actor* actor, ColliderBodyInfo* src) {
     collision->actor = actor;
     collision->unk_14 = src->unk_00;
     collision->colliderFlags = src->colliderFlags;
@@ -26,8 +24,7 @@ s32 func_8005B6EC(GlobalContext* globalCtx, Collider* collision, Actor* actor, C
     return 1;
 }
 
-s32 func_8005B72C(GlobalContext* globalCtx, Collider* collision, Actor* actor, ColliderBodyInfo* src)
-{
+s32 func_8005B72C(GlobalContext* globalCtx, Collider* collision, Actor* actor, ColliderBodyInfo* src) {
     collision->actor = actor;
     collision->unk_14 = src->unk_00;
     collision->colliderFlags = src->colliderFlags;
@@ -38,20 +35,17 @@ s32 func_8005B72C(GlobalContext* globalCtx, Collider* collision, Actor* actor, C
     return 1;
 }
 
-void func_8005B76C(GlobalContext* globalCtx, Collider* collision)
-{
+void func_8005B76C(GlobalContext* globalCtx, Collider* collision) {
     collision->at = NULL;
     collision->colliderFlags &= ~0x6;
 }
 
-void func_8005B784(GlobalContext* globalCtx, Collider* collision)
-{
+void func_8005B784(GlobalContext* globalCtx, Collider* collision) {
     collision->ac = NULL;
     collision->collideFlags &= ~0x82;
 }
 
-void func_8005B79C(GlobalContext* globalCtx, Collider* collision)
-{
+void func_8005B79C(GlobalContext* globalCtx, Collider* collision) {
     collision->ot = NULL;
     collision->maskA &= ~0x2;
     collision->maskB &= ~0x1;
@@ -59,22 +53,18 @@ void func_8005B79C(GlobalContext* globalCtx, Collider* collision)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/func_8005B7C0.s")
 
-s32 func_8005B7E4(GlobalContext* globalCtx, ColliderTouch* touch)
-{
+s32 func_8005B7E4(GlobalContext* globalCtx, ColliderTouch* touch) {
     return 1;
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/func_8005B7F4.s")
 
-void func_8005B818(GlobalContext* globalCtx, ColliderBody* body)
-{
-
+void func_8005B818(GlobalContext* globalCtx, ColliderBody* body) {
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/func_8005B824.s")
 
-s32 func_8005B850(GlobalContext* globalCtx, ColliderBump* bump)
-{
+s32 func_8005B850(GlobalContext* globalCtx, ColliderBump* bump) {
     return 1;
 }
 
@@ -82,15 +72,13 @@ s32 func_8005B850(GlobalContext* globalCtx, ColliderBump* bump)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/func_8005B884.s")
 
-s32 func_8005B904(GlobalContext* globalCtx, ColliderBody* body)
-{
+s32 func_8005B904(GlobalContext* globalCtx, ColliderBody* body) {
     func_8005B7E4(globalCtx, &body->toucher);
     func_8005B850(globalCtx, &body->bumper);
     return 1;
 }
 
-s32 func_8005B93C(GlobalContext* globalCtx, ColliderBody* body, ColliderBodyInfoInner* bodyInfoInner)
-{
+s32 func_8005B93C(GlobalContext* globalCtx, ColliderBody* body, ColliderBodyInfoInner* bodyInfoInner) {
     body->flags = bodyInfoInner->bodyFlags;
     func_8005B7F4(globalCtx, &body->toucher, &bodyInfoInner->toucherMask);
     func_8005B860(globalCtx, &body->bumper, &bodyInfoInner->bumperMask);
@@ -100,8 +88,7 @@ s32 func_8005B93C(GlobalContext* globalCtx, ColliderBody* body, ColliderBodyInfo
     return 1;
 }
 
-void func_8005B9B0(GlobalContext* globalCtx, ColliderBody* body)
-{
+void func_8005B9B0(GlobalContext* globalCtx, ColliderBody* body) {
     body->unk_18 = 0;
     body->unk_20 = 0;
     body->toucherFlags &= ~0x2;
@@ -109,8 +96,7 @@ void func_8005B9B0(GlobalContext* globalCtx, ColliderBody* body)
     func_8005B818(globalCtx, body);
 }
 
-void func_8005B9E8(GlobalContext* globalCtx, ColliderBody* body)
-{
+void func_8005B9E8(GlobalContext* globalCtx, ColliderBody* body) {
     body->bumper.unk_0A = 0;
     body->bumperFlags &= ~0x2;
     body->bumperFlags &= ~0x80;
@@ -120,15 +106,13 @@ void func_8005B9E8(GlobalContext* globalCtx, ColliderBody* body)
     body->bumper.unk_06 = body->bumper.unk_0A;
 }
 
-void func_8005BA1C(GlobalContext* globalCtx, ColliderBody* body)
-{
+void func_8005BA1C(GlobalContext* globalCtx, ColliderBody* body) {
     body->flags2 &= ~0x2;
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/func_8005BA30.s")
 
-s32 func_8005BA74(UNK_TYPE arg0, UNK_TYPE arg1)
-{
+s32 func_8005BA74(UNK_TYPE arg0, UNK_TYPE arg1) {
     return 1;
 }
 
@@ -158,73 +142,64 @@ s32 func_8005BA74(UNK_TYPE arg0, UNK_TYPE arg1)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/func_8005C2BC.s")
 
-s32 func_8005C318(GlobalContext* globalCtx, ColliderDimensions* dim)
-{
+s32 func_8005C318(GlobalContext* globalCtx, ColliderDimensions* dim) {
     return 1;
 }
 
-s32 func_8005C328(GlobalContext* globalCtx, ColliderDimensions* dest, ColliderDimensions* src)
-{
+s32 func_8005C328(GlobalContext* globalCtx, ColliderDimensions* dest, ColliderDimensions* src) {
     *dest = *src;
     return 1;
 }
 
-s32 ActorCollider_AllocCylinder(GlobalContext* globalCtx, ColliderCylinderMain* collision)
-{
+s32 ActorCollider_AllocCylinder(GlobalContext* globalCtx, ColliderCylinderMain* collision) {
     func_8005B65C(globalCtx, &collision->base);
     func_8005B884(globalCtx, &collision->body);
     func_8005C2BC(globalCtx, &collision->dim);
     return 1;
 }
 
-s32 ActorCollider_FreeCylinder(GlobalContext* globalCtx, ColliderCylinderMain* collision)
-{
+s32 ActorCollider_FreeCylinder(GlobalContext* globalCtx, ColliderCylinderMain* collision) {
     func_8005B6A0(globalCtx, &collision->base);
     func_8005B904(globalCtx, &collision->body);
     func_8005C318(globalCtx, &collision->dim);
     return 1;
 }
 
-s32 func_8005C3F4(GlobalContext* globalCtx, ColliderCylinderMain* collision, ColliderCylinderInit* src)
-{
+s32 func_8005C3F4(GlobalContext* globalCtx, ColliderCylinderMain* collision, ColliderCylinderInit* src) {
     func_8005B6B0(globalCtx, &collision->base, &src->body);
     func_8005B93C(globalCtx, &collision->body, &src->inner);
     func_8005C328(globalCtx, &collision->dim, &src->dim);
     return 1;
 }
 
-s32 func_8005C450(GlobalContext* globalCtx, ColliderCylinderMain* collision, Actor* actor, ColliderCylinderInit* src)
-{
+s32 func_8005C450(GlobalContext* globalCtx, ColliderCylinderMain* collision, Actor* actor, ColliderCylinderInit* src) {
     func_8005B6EC(globalCtx, &collision->base, actor, &src->body);
     func_8005B93C(globalCtx, &collision->body, &src->inner);
     func_8005C328(globalCtx, &collision->dim, &src->dim);
     return 1;
 }
 
-s32 ActorCollider_InitCylinder(GlobalContext* globalCtx, ColliderCylinderMain* collision, Actor* actor, ColliderCylinderInit* src)
-{
+s32 ActorCollider_InitCylinder(GlobalContext* globalCtx, ColliderCylinderMain* collision, Actor* actor,
+                               ColliderCylinderInit* src) {
     func_8005B72C(globalCtx, &collision->base, actor, &src->body);
     func_8005B93C(globalCtx, &collision->body, &src->inner);
     func_8005C328(globalCtx, &collision->dim, &src->dim);
     return 1;
 }
 
-s32 func_8005C508(GlobalContext* globalCtx, ColliderCylinderMain* collision)
-{
+s32 func_8005C508(GlobalContext* globalCtx, ColliderCylinderMain* collision) {
     func_8005B76C(globalCtx, &collision->base);
     func_8005B9B0(globalCtx, &collision->body);
     return 1;
 }
 
-s32 func_8005C540(GlobalContext* globalCtx, ColliderCylinderMain* collision)
-{
+s32 func_8005C540(GlobalContext* globalCtx, ColliderCylinderMain* collision) {
     func_8005B784(globalCtx, &collision->base);
     func_8005B9E8(globalCtx, &collision->body);
     return 1;
 }
 
-s32 func_8005C578(GlobalContext* globalCtx, ColliderCylinderMain* collision)
-{
+s32 func_8005C578(GlobalContext* globalCtx, ColliderCylinderMain* collision) {
     func_8005B79C(globalCtx, &collision->base);
     func_8005BA1C(globalCtx, &collision->body);
     return 1;
@@ -232,8 +207,7 @@ s32 func_8005C578(GlobalContext* globalCtx, ColliderCylinderMain* collision)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/func_8005C5B0.s")
 
-s32 func_8005C5F8(UNK_TYPE arg0, UNK_TYPE arg1)
-{
+s32 func_8005C5F8(UNK_TYPE arg0, UNK_TYPE arg1) {
     return 1;
 }
 
@@ -269,55 +243,48 @@ s32 func_8005CEB4(GlobalContext* globalCtx, ColliderDimensions* dim) {
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/func_8005CF90.s")
 
-s32 func_8005D018(GlobalContext* globalCtx, ColliderCylinderMain* collision)
-{
+s32 func_8005D018(GlobalContext* globalCtx, ColliderCylinderMain* collision) {
     func_8005B65C(globalCtx, &collision->base);
     func_8005B884(globalCtx, &collision->body);
     func_8005CE6C(globalCtx, &collision->dim);
     return 1;
 }
 
-s32 func_8005D060(GlobalContext* globalCtx, ColliderCylinderMain* collision)
-{
+s32 func_8005D060(GlobalContext* globalCtx, ColliderCylinderMain* collision) {
     func_8005B6A0(globalCtx, &collision->base);
     func_8005B904(globalCtx, &collision->body);
     func_8005CEB4(globalCtx, &collision->dim);
     return 1;
 }
 
-s32 func_8005D0A8(GlobalContext* globalCtx, ColliderCylinderMain* collision, Actor* actor, ColliderCylinderInit* src)
-{
+s32 func_8005D0A8(GlobalContext* globalCtx, ColliderCylinderMain* collision, Actor* actor, ColliderCylinderInit* src) {
     func_8005B6EC(globalCtx, &collision->base, actor, &src->body);
     func_8005B93C(globalCtx, &collision->body, &src->inner);
     func_8005CF90(globalCtx, &collision->dim, &src->dim);
     return 1;
 }
 
-s32 func_8005D104(GlobalContext* globalCtx, ColliderCylinderMain* collision, Actor* actor, ColliderCylinderInit* src)
-{
+s32 func_8005D104(GlobalContext* globalCtx, ColliderCylinderMain* collision, Actor* actor, ColliderCylinderInit* src) {
     func_8005B72C(globalCtx, &collision->base, actor, &src->body);
     func_8005B93C(globalCtx, &collision->body, &src->inner);
     func_8005CF90(globalCtx, &collision->dim, &src->dim);
     return 1;
 }
 
-s32 func_8005D160(GlobalContext* globalCtx, ColliderCylinderMain* collision)
-{
+s32 func_8005D160(GlobalContext* globalCtx, ColliderCylinderMain* collision) {
     func_8005B76C(globalCtx, &collision->base);
     func_8005B9B0(globalCtx, &collision->body);
     func_8005CEC4(globalCtx, &collision->dim);
     return 1;
 }
 
-s32 func_8005D1A8(GlobalContext* globalCtx, ColliderCylinderMain* collision)
-{
+s32 func_8005D1A8(GlobalContext* globalCtx, ColliderCylinderMain* collision) {
     func_8005B784(globalCtx, &collision->base);
     func_8005B9E8(globalCtx, &collision->body);
     return 1;
 }
 
-s32 func_8005D1E0(GlobalContext* globalCtx, ColliderCylinderMain* collision)
-{
+s32 func_8005D1E0(GlobalContext* globalCtx, ColliderCylinderMain* collision) {
     func_8005B79C(globalCtx, &collision->base);
     func_8005BA1C(globalCtx, &collision->body);
     return 1;
@@ -331,9 +298,7 @@ s32 func_8005D1E0(GlobalContext* globalCtx, ColliderCylinderMain* collision)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/func_8005D3BC.s")
 
-void func_8005D400(UNK_TYPE arg0, UNK_TYPE arg1)
-{
-
+void func_8005D400(UNK_TYPE arg0, UNK_TYPE arg1) {
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/func_8005D40C.s")
diff --git a/src/code/z_common_data.c b/src/code/z_common_data.c
index 63802a742..cb5739477 100644
--- a/src/code/z_common_data.c
+++ b/src/code/z_common_data.c
@@ -1,8 +1,7 @@
 #include <ultra64.h>
 #include <global.h>
 
-void SaveContext_Init(void)
-{
+void SaveContext_Init(void) {
     bzero(&gSaveContext, sizeof(gSaveContext));
     D_8015FA88 = 0;
     D_8015FA8C = 0;
@@ -14,8 +13,7 @@ void SaveContext_Init(void)
     gSaveContext.chamber_cutscene_num = 0;
     gSaveContext.next_day_time = 0xFFFF;
     gSaveContext.environment_time = 0;
-    gSaveContext.unk_141C = 1;
+    gSaveContext.dogIsLost = 1;
     gSaveContext.transition_type = 0xFF;
     gSaveContext.unk_13EE = 50;
 }
-
diff --git a/src/code/z_construct.c b/src/code/z_construct.c
index 5555ed40f..d14e6ef8c 100644
--- a/src/code/z_construct.c
+++ b/src/code/z_construct.c
@@ -1,15 +1,13 @@
-#include <ultra64.h> 
+#include <ultra64.h>
 #include <global.h>
 
-void func_80110990(GlobalContext* globalCtx)
-{
+void func_80110990(GlobalContext* globalCtx) {
     func_80080F44(globalCtx);
 }
 
 #ifdef NON_MATCHING
 // regalloc, stack usage and minor ordering differences
-void func_801109B0(GlobalContext* globalCtx)
-{
+void func_801109B0(GlobalContext* globalCtx) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
     s32 parameterStart;
     s32 parameterSize;
@@ -32,9 +30,9 @@ void func_801109B0(GlobalContext* globalCtx)
     interfaceCtx->unk_228 = XREG(95);
     interfaceCtx->minimapAlpha = 0;
     interfaceCtx->unk_260 = 0;
-    interfaceCtx->unk_244 = interfaceCtx->aAlpha = interfaceCtx->bAlpha =
-    interfaceCtx->cLeftAlpha = interfaceCtx->cDownAlpha = interfaceCtx->cRightAlpha =
-    interfaceCtx->healthAlpha = interfaceCtx->startAlpha = interfaceCtx->magicAlpha = 0;
+    interfaceCtx->unk_244 = interfaceCtx->aAlpha = interfaceCtx->bAlpha = interfaceCtx->cLeftAlpha =
+        interfaceCtx->cDownAlpha = interfaceCtx->cRightAlpha = interfaceCtx->healthAlpha = interfaceCtx->startAlpha =
+            interfaceCtx->magicAlpha = 0;
 
     parameterStart = _parameter_staticSegmentRomStart;
     parameterSize = _parameter_staticSegmentRomEnd - parameterStart;
@@ -46,9 +44,10 @@ void func_801109B0(GlobalContext* globalCtx)
 
     osSyncPrintf("parameter->parameterSegment=%x", interfaceCtx->parameterSegment);
 
-    if (interfaceCtx->parameterSegment == NULL)
+    if (interfaceCtx->parameterSegment == NULL) {
         __assert("parameter->parameterSegment != NULL", "../z_construct.c", 161);
-    
+    }
+
     DmaMgr_SendRequest1(interfaceCtx->parameterSegment, parameterStart, parameterSize, "../z_construct.c", 162);
 
     interfaceCtx->do_actionSegment = Game_Alloc(&globalCtx->state, 0x480, "../z_construct.c", 166);
@@ -57,28 +56,33 @@ void func_801109B0(GlobalContext* globalCtx)
     osSyncPrintf("ＤＯアクション テクスチャ初期=%x\n", 0x480);
     osSyncPrintf("parameter->do_actionSegment=%x", interfaceCtx->do_actionSegment);
 
-    if (interfaceCtx->do_actionSegment == NULL)
+    if (interfaceCtx->do_actionSegment == NULL) {
         __assert("parameter->do_actionSegment != NULL", "../z_construct.c", 169);
+    }
 
     do_actionStart = _do_action_staticSegmentRomStart;
 
-    if (gSaveContext.language == 0)
+    if (gSaveContext.language == 0) {
         do_actionOffset = 0;
-    else if (gSaveContext.language == 1)
+    } else if (gSaveContext.language == 1) {
         do_actionOffset = 0x2B80;
-    else
+    } else {
         do_actionOffset = 0x5700;
+    }
 
-    DmaMgr_SendRequest1(interfaceCtx->do_actionSegment, do_actionStart + do_actionOffset, 0x300, "../z_construct.c", 174);
+    DmaMgr_SendRequest1(interfaceCtx->do_actionSegment, do_actionStart + do_actionOffset, 0x300, "../z_construct.c",
+                        174);
 
-    if (gSaveContext.language == 0)
+    if (gSaveContext.language == 0) {
         do_actionOffset = 0x480;
-    else if (gSaveContext.language == 1)
+    } else if (gSaveContext.language == 1) {
         do_actionOffset = 0x3000;
-    else
+    } else {
         do_actionOffset = 0x5B80;
+    }
 
-    DmaMgr_SendRequest1((void*)((u32)interfaceCtx->do_actionSegment + 0x300), do_actionStart + do_actionOffset, 0x180, "../z_construct.c", 178);
+    DmaMgr_SendRequest1((void*)((u32)interfaceCtx->do_actionSegment + 0x300), do_actionStart + do_actionOffset, 0x180,
+                        "../z_construct.c", 178);
 
     interfaceCtx->icon_itemSegment = Game_Alloc(&globalCtx->state, 0x4000, "../z_construct.c", 190);
 
@@ -86,69 +90,72 @@ void func_801109B0(GlobalContext* globalCtx)
     osSyncPrintf("アイコンアイテム テクスチャ初期=%x\n", 0x4000);
     osSyncPrintf("parameter->icon_itemSegment=%x\n", interfaceCtx->icon_itemSegment);
 
-    if (interfaceCtx->icon_itemSegment == NULL)
+    if (interfaceCtx->icon_itemSegment == NULL) {
         __assert("parameter->icon_itemSegment != NULL", "../z_construct.c", 193);
+    }
 
-    osSyncPrintf("Register_Item[%x, %x, %x, %x]\n",
-                 gSaveContext.equips.button_items[0], gSaveContext.equips.button_items[1],
-                 gSaveContext.equips.button_items[2], gSaveContext.equips.button_items[3]);
+    osSyncPrintf("Register_Item[%x, %x, %x, %x]\n", gSaveContext.equips.button_items[0],
+                 gSaveContext.equips.button_items[1], gSaveContext.equips.button_items[2],
+                 gSaveContext.equips.button_items[3]);
 
-    if (gSaveContext.equips.button_items[0] < 0xF0)
+    if (gSaveContext.equips.button_items[0] < 0xF0) {
         DmaMgr_SendRequest1(interfaceCtx->icon_itemSegment,
-                            _icon_item_staticSegmentRomStart + gSaveContext.equips.button_items[0] * 0x80,
-                            0x1000, "../z_construct.c", 198);
-    else if (gSaveContext.equips.button_items[0] != 0xFF)
+                            _icon_item_staticSegmentRomStart + gSaveContext.equips.button_items[0] * 0x80, 0x1000,
+                            "../z_construct.c", 198);
+    } else if (gSaveContext.equips.button_items[0] != 0xFF) {
         DmaMgr_SendRequest1(interfaceCtx->icon_itemSegment,
-                            _icon_item_staticSegmentRomStart + gSaveContext.equips.button_items[0] * 0x80,
-                            0x1000, "../z_construct.c", 203);
+                            _icon_item_staticSegmentRomStart + gSaveContext.equips.button_items[0] * 0x80, 0x1000,
+                            "../z_construct.c", 203);
+    }
 
-    if (gSaveContext.equips.button_items[1] < 0xF0)
+    if (gSaveContext.equips.button_items[1] < 0xF0) {
         DmaMgr_SendRequest1((void*)((u32)interfaceCtx->icon_itemSegment + 0x1000),
-                            _icon_item_staticSegmentRomStart + gSaveContext.equips.button_items[1] * 0x80,
-                            0x1000, "../z_construct.c", 209);
+                            _icon_item_staticSegmentRomStart + gSaveContext.equips.button_items[1] * 0x80, 0x1000,
+                            "../z_construct.c", 209);
+    }
 
-    if (gSaveContext.equips.button_items[2] < 0xF0)
+    if (gSaveContext.equips.button_items[2] < 0xF0) {
         DmaMgr_SendRequest1((void*)((u32)interfaceCtx->icon_itemSegment + 0x2000),
-                            _icon_item_staticSegmentRomStart + gSaveContext.equips.button_items[2] * 0x80,
-                            0x1000, "../z_construct.c", 214);
+                            _icon_item_staticSegmentRomStart + gSaveContext.equips.button_items[2] * 0x80, 0x1000,
+                            "../z_construct.c", 214);
+    }
 
-    if (gSaveContext.equips.button_items[3] < 0xF0)
+    if (gSaveContext.equips.button_items[3] < 0xF0) {
         DmaMgr_SendRequest1((void*)((u32)interfaceCtx->icon_itemSegment + 0x3000),
-                            _icon_item_staticSegmentRomStart + gSaveContext.equips.button_items[3] * 0x80,
-                            0x1000, "../z_construct.c", 219);
+                            _icon_item_staticSegmentRomStart + gSaveContext.equips.button_items[3] * 0x80, 0x1000,
+                            "../z_construct.c", 219);
+    }
 
     osSyncPrintf("ＥＶＥＮＴ＝%d\n", gSaveContext.timer_1_state);
 
-    if ((gSaveContext.timer_1_state == 4) || (gSaveContext.timer_1_state == 8) ||
-        (gSaveContext.timer_2_state == 4) || (gSaveContext.timer_2_state == 10))
-    {
+    if ((gSaveContext.timer_1_state == 4) || (gSaveContext.timer_1_state == 8) || (gSaveContext.timer_2_state == 4) ||
+        (gSaveContext.timer_2_state == 10)) {
         osSyncPrintf("restart_flag=%d\n", gSaveContext.respawn_flag);
 
-        if ((gSaveContext.respawn_flag == -1) || (gSaveContext.respawn_flag == 1))
-        {
-            if (gSaveContext.timer_1_state == 4)
-            {
+        if ((gSaveContext.respawn_flag == -1) || (gSaveContext.respawn_flag == 1)) {
+            if (gSaveContext.timer_1_state == 4) {
                 gSaveContext.timer_1_state = 1;
                 gSaveContext.timer_x[0] = 140;
                 gSaveContext.timer_y[0] = 80;
             }
         }
 
-        if ((gSaveContext.timer_1_state == 4) || (gSaveContext.timer_1_state == 8))
+        if ((gSaveContext.timer_1_state == 4) || (gSaveContext.timer_1_state == 8)) {
             temp = 0;
-        else
+        } else {
             temp = 1;
+        }
 
         gSaveContext.timer_x[temp] = 26;
 
-        if (gSaveContext.health_capacity > 0xA0)
+        if (gSaveContext.health_capacity > 0xA0) {
             gSaveContext.timer_y[temp] = 54;
-        else
+        } else {
             gSaveContext.timer_y[temp] = 46;
+        }
     }
 
-    if ((gSaveContext.timer_1_state >= 11) && (gSaveContext.timer_1_state < 16))
-    {
+    if ((gSaveContext.timer_1_state >= 11) && (gSaveContext.timer_1_state < 16)) {
         gSaveContext.timer_1_state = 0;
         // Translates to: "Timer Stop!!!!!!!!!!!!!!!!!!!!!!"
         osSyncPrintf("タイマー停止！！！！！！！！！！！！！！！！！！！！！  = %d\n", gSaveContext.timer_1_state);
@@ -179,8 +186,7 @@ void func_801109B0(GlobalContext* globalCtx)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_construct/func_801109B0.s")
 #endif
 
-void func_80110F68(GlobalContext* globalCtx)
-{
+void func_80110F68(GlobalContext* globalCtx) {
     MessageContext* msgCtx = &globalCtx->msgCtx;
     s32 pad;
 
@@ -202,16 +208,16 @@ void func_80110F68(GlobalContext* globalCtx)
     // Translates to: "Textbox game_alloc=%x"
     osSyncPrintf("吹き出しgame_alloc=%x\n", 0x2200);
 
-    if (msgCtx->textboxSegment == NULL)
+    if (msgCtx->textboxSegment == NULL) {
         __assert("message->fukidashiSegment != NULL", "../z_construct.c", 352);
+    }
 
     func_8006EF10(&globalCtx->msgCtx.unk_128);
 
     YREG(31) = 0;
 }
 
-void func_80111070(void)
-{
+void func_80111070(void) {
     YREG(8) = 0xA;
     YREG(14) = 0;
     YREG(15) = 0;
@@ -526,8 +532,7 @@ void func_80111070(void)
     WREG(94) = 3;
     WREG(95) = 6;
 
-    if (gSaveContext.game_mode == 0)
-    {
+    if (gSaveContext.game_mode == 0) {
         VREG(0) = 0x34;
         VREG(1) = 0x24;
         VREG(2) = 0xD6;
@@ -618,7 +623,6 @@ void func_80111070(void)
     VREG(92) = -0x3F;
 }
 
-void func_80112098(GlobalContext* globalCtx)
-{
+void func_80112098(GlobalContext* globalCtx) {
     func_80111070();
 }
diff --git a/src/code/z_debug.c b/src/code/z_debug.c
index b5d078985..adda7974b 100644
--- a/src/code/z_debug.c
+++ b/src/code/z_debug.c
@@ -1,20 +1,249 @@
 #include <ultra64.h>
 #include <global.h>
+#include <PR/os_cont.h>
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_debug/func_800636C0.s")
+typedef struct {
+    u8 x;
+    u8 y;
+    u8 colorId;
+    char text[0x15];
+} PrintTextBuffer;
 
-void func_8006375C(UNK_TYPE arg0, UNK_TYPE arg1, UNK_TYPE arg2)
-{
+typedef struct {
+    u16 push;
+    u16 held;
+} InputCombo;
 
+GameInfo* gGameInfo;
+int D_8015FA94; // no known symbols
+PrintTextBuffer D_8015FA98[0x16];
+
+s16 D_8011E0B0 = 0; // PrintTextBuffer index
+Color_RGBA8 printTextColors[] = {
+    { 0xFF, 0xFF, 0x20, 0xC0 }, { 0xFF, 0x96, 0x80, 0xC0 }, { 0x80, 0x60, 0x00, 0x40 }, { 0xC0, 0x80, 0x10, 0x80 },
+    { 0xFF, 0xC0, 0x20, 0x80 }, { 0xE6, 0xE6, 0xDC, 0x40 }, { 0x80, 0x96, 0xFF, 0x80 }, { 0x80, 0xFF, 0x20, 0x80 },
+};
+
+InputCombo inputCombos[REG_GROUPS] = {
+    { L_TRIG, U_CBUTTONS },       { L_TRIG, L_CBUTTONS },   { L_TRIG, D_CBUTTONS },     { L_TRIG, A_BUTTON },
+    { R_TRIG, D_CBUTTONS },       { L_TRIG, R_CBUTTONS },   { L_TRIG, R_TRIG },         { L_TRIG, L_JPAD },
+    { L_TRIG, R_JPAD },           { L_TRIG, U_JPAD },       { L_TRIG, B_BUTTON },       { L_TRIG, Z_TRIG },
+    { L_TRIG, D_JPAD },           { R_TRIG, A_BUTTON },     { R_TRIG, B_BUTTON },       { R_TRIG, Z_TRIG },
+    { R_TRIG, L_TRIG },           { R_TRIG, U_CBUTTONS },   { R_TRIG, R_CBUTTONS },     { R_TRIG, L_JPAD },
+    { R_TRIG, L_CBUTTONS },       { R_TRIG, START_BUTTON }, { L_TRIG, START_BUTTON },   { R_TRIG, R_JPAD },
+    { R_TRIG, U_JPAD },           { START_BUTTON, R_TRIG }, { START_BUTTON, A_BUTTON }, { START_BUTTON, B_BUTTON },
+    { START_BUTTON, R_CBUTTONS },
+};
+
+char regChar[] = " SOPQMYDUIZCNKXcsiWAVHGmnBdkb";
+
+// initialize GameInfo
+void func_800636C0() {
+    s32 i;
+
+    gGameInfo = (GameInfo*)SystemArena_MallocDebug(sizeof(GameInfo), "../z_debug.c", 260);
+    gGameInfo->regPage = 0;
+    gGameInfo->regGroup = 0;
+    gGameInfo->regCur = 0;
+    gGameInfo->dpadLast = 0;
+    gGameInfo->repeat = 0;
+    for (i = 0; i < ARRAY_COUNT(gGameInfo->data); i++) {
+        gGameInfo->data[i] = 0;
+    }
+}
+
+// Called when free movement is active.
+// 8011D394 to enable camera debugger
+void func_8006375C(s32 arg0, s32 arg1, float* d_80855320) {
 }
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_debug/func_8006376C.s")
+// Copy Camera Debugger Text
+void func_8006376C(u8 x, u8 y, u8 colorId, const char* text) {
+    PrintTextBuffer* buf;
+    char* bufText;
+    s16 i;
+
+    buf = &D_8015FA98[D_8011E0B0];
+    if (D_8011E0B0 < 0x16) {
+        buf->x = x;
+        buf->y = y;
+        buf->colorId = colorId;
+
+        i = 0;
+        bufText = buf->text;
+        while (*bufText++ = *text++) {
+            if (i++ > 0x14) {
+                break;
+            }
+        }
+
+        *bufText = '\0';
+        D_8011E0B0++;
+    }
+}
+
+// Draw Text
+void func_80063828(GfxPrint* gfxPrint) {
+    s32 i;
+    Color_RGBA8* color;
+    PrintTextBuffer* buffer;
+    char* text;
+
+    i = 0;
+    if (D_8011E0B0 > 0) {
+        do {
+            buffer = &D_8015FA98[i];
+            text = buffer->text;
+
+            color = &printTextColors[buffer->colorId];
+            GfxPrint_SetColor(gfxPrint, color->r, color->g, color->b, color->a);
+            GfxPrint_SetPos(gfxPrint, buffer->x, buffer->y);
+            GfxPrint_Printf(gfxPrint, "%s", text);
+            i += 1;
+        } while (i < D_8011E0B0);
+    }
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_debug/func_80063828.s")
+// Edit REG
+void func_8006390C(Input* input) {
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_debug/func_8006390C.s")
+    s32 dpad;
+    s32 regGroup;
+    s32 increment;
+    InputCombo* input_combo;
+    s32 i;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_debug/func_80063C04.s")
+    regGroup = (gGameInfo->regGroup * REG_PAGES + gGameInfo->regPage) * REG_PER_PAGE - REG_PER_PAGE;
+    dpad = input->raw.pad & 0xF00;
+    if (!~(input->raw.pad | ~L_TRIG) || !~(input->raw.pad | ~R_TRIG) || !~(input->raw.pad | ~START_BUTTON)) {
+        input_combo = inputCombos;
+        for (i = 0; i < REG_GROUPS; i++) {
+            if (~(~input_combo->push | input->raw.pad) || ~(~input_combo->held | input->padPressed)) {
+                input_combo++;
+            } else {
+                break;
+            }
+        }
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_debug/func_80063D7C.s")
+        if (i < REG_GROUPS) {
+            if (i == gGameInfo->regGroup) {
+                gGameInfo->regPage = (gGameInfo->regPage + 1) % (REG_PAGES + 1);
+                return;
+            }
+            gGameInfo->regGroup = i;
+            gGameInfo->regPage = 0;
+        }
+    } else {
+        switch (gGameInfo->regPage - 1) {
+            case 0:
+            case 1:
+            case 2:
+            case 3:
+            case 4:
+            case 5:
 
+                if (dpad == gGameInfo->dpadLast) {
+                    gGameInfo->repeat--;
+                    if (gGameInfo->repeat < 0) {
+                        gGameInfo->repeat = 1;
+                    } else {
+                        dpad ^= gGameInfo->dpadLast;
+                    }
+                } else {
+                    gGameInfo->repeat = 0x10;
+                    gGameInfo->dpadLast = dpad;
+                }
+
+                increment = (dpad & R_JPAD)
+                                ? (!~(input->raw.pad | ~(A_BUTTON | B_BUTTON))
+                                       ? 1000
+                                       : !~(input->raw.pad | ~A_BUTTON) ? 100 : !~(input->raw.pad | ~B_BUTTON) ? 10 : 1)
+                                : (dpad & L_JPAD) ? (!~(input->raw.pad | ~(A_BUTTON | B_BUTTON))
+                                                         ? -1000
+                                                         : !~(input->raw.pad | ~A_BUTTON)
+                                                               ? -100
+                                                               : !~(input->raw.pad | ~B_BUTTON) ? -10 : -1)
+                                                  : 0;
+
+                gGameInfo->data[gGameInfo->regCur + regGroup] += increment;
+                if (dpad & U_JPAD) {
+                    gGameInfo->regCur--;
+                    if (gGameInfo->regCur < 0) {
+                        gGameInfo->regCur = REG_PER_PAGE - 1;
+                    }
+                } else if (dpad & D_JPAD) {
+                    gGameInfo->regCur++;
+                    if (gGameInfo->regCur >= REG_PER_PAGE) {
+                        gGameInfo->regCur = 0;
+                    }
+                }
+                if (iREG(0)) {
+                    iREG(0) = 0;
+                    func_800AA000(0, iREG(1), iREG(2), iREG(3));
+                }
+        }
+    }
+}
+
+// Draw Memory Viewer
+void func_80063C04(GfxPrint* gfxPrint) {
+    s32 i;
+    s32 page;
+    s32 regGroup;
+    s32 test; // removing affects stack
+    char name[3];
+
+    page = (gGameInfo->regPage * REG_PER_PAGE) - REG_PER_PAGE;
+    regGroup = (gGameInfo->regGroup * REG_PAGES + gGameInfo->regPage) * REG_PER_PAGE - REG_PER_PAGE;
+
+    // set up register name string
+    name[0] = 'R';
+    name[1] = regChar[gGameInfo->regGroup]; // r_group type char
+    name[2] = '\0';
+    GfxPrint_SetColor(gfxPrint, 0, 0x80, 0x80, 0x80);
+
+    for (i = 0; i != REG_PER_PAGE; i++) {
+        if (i == gGameInfo->regCur) {
+            GfxPrint_SetColor(gfxPrint, 0, 0xff, 0xff, 0xff);
+        }
+        GfxPrint_SetPos(gfxPrint, 3, i + 5);
+        GfxPrint_Printf(gfxPrint, "%s%02d%6d", &name, page + i, gGameInfo->data[i + regGroup]);
+        if (i == gGameInfo->regCur) {
+            GfxPrint_SetColor(gfxPrint, 0, 0x80, 0x80, 0x80);
+        }
+    }
+}
+
+void func_80063D7C(GraphicsContext* gfxCtx) {
+    Gfx* sp7C;
+    Gfx* sp78;
+    Gfx* tempRet;
+    void* unk2[6];
+    GfxPrint gfxPrint;
+    void* unk[2];
+    Gfx* dispRefs[4]; // stores state of GfxCtx next ptrs
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_debug.c", 628);
+    GfxPrint_Ctor(&gfxPrint);
+    sp78 = gfxCtx->polyOpa.p;
+    tempRet = Graph_GfxPlusOne(gfxCtx->polyOpa.p);
+    gSPDisplayList(gfxCtx->overlay.p++, tempRet);
+    GfxPrint_Open(&gfxPrint, tempRet);
+
+    if ((OREG(0) == 1) || (OREG(0) == 8)) {
+        func_80063828(&gfxPrint);
+    }
+
+    if (gGameInfo->regPage != 0) {
+        func_80063C04(&gfxPrint);
+    }
+
+    D_8011E0B0 = 0;
+    sp7C = GfxPrint_Close(&gfxPrint);
+    gSPEndDisplayList(sp7C++);
+    Graph_BranchDlist(sp78, sp7C);
+    gfxCtx->polyOpa.p = sp7C;
+    if (0) {}
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_debug.c", 664);
+    GfxPrint_Dtor(&gfxPrint);
+}
diff --git a/src/code/z_debug_display.c b/src/code/z_debug_display.c
index e961e9c74..914d70c89 100644
--- a/src/code/z_debug_display.c
+++ b/src/code/z_debug_display.c
@@ -1,25 +1,22 @@
 #include <ultra64.h>
 #include <global.h>
 
-typedef struct
-{
+typedef struct {
     /* 0x00 */ s16 drawType; // indicates which draw function to use when displaying the object
-    /* 0x04 */ u32 drawArg; // segment address (display list or texture) passed to the draw funciton when called
-} DebugDispObjectInfo; // size = 0x8
+    /* 0x04 */ u32 drawArg;  // segment address (display list or texture) passed to the draw funciton when called
+} DebugDispObjectInfo;       // size = 0x8
 
 typedef void (*DebugDispObject_DrawFunc)(DebugDispObject*, u32, GlobalContext*);
 
 static void DebugDisplay_DrawSpriteI8(DebugDispObject* dispObj, u32 texture, GlobalContext* globalCtx);
 static void DebugDisplay_DrawPolygon(DebugDispObject* dispObj, u32 dlist, GlobalContext* globalCtx);
 
-static DebugDispObject_DrawFunc sDebugObjectDrawFuncTable[] =
-{
+static DebugDispObject_DrawFunc sDebugObjectDrawFuncTable[] = {
     DebugDisplay_DrawSpriteI8,
     DebugDisplay_DrawPolygon,
 };
 
-static DebugDispObjectInfo sDebugObjectInfoTable[] =
-{
+static DebugDispObjectInfo sDebugObjectInfoTable[] = {
     { 0, 0x040035F0 }, // Circle
     { 0, 0x040038F0 }, // Cross
     { 0, 0x040036F0 }, // Ball
@@ -32,15 +29,13 @@ static Lights1 sDebugObjectLights = gdSPDefLights1(0x80, 0x80, 0x80, 0xFF, 0xFF,
 
 static DebugDispObject* sDebugObjectListHead;
 
-void DebugDisplay_Init(void)
-{
+void DebugDisplay_Init(void) {
     sDebugObjectListHead = NULL;
 }
 
-DebugDispObject* DebugDisplay_AddObject(f32 posX, f32 posY, f32 posZ, s16 rotX, s16 rotY, s16 rotZ,
-                                        f32 scaleX, f32 scaleY, f32 scaleZ, u8 red, u8 green, u8 blue, u8 alpha,
-                                        s16 type, GraphicsContext* gfxCtx)
-{
+DebugDispObject* DebugDisplay_AddObject(f32 posX, f32 posY, f32 posZ, s16 rotX, s16 rotY, s16 rotZ, f32 scaleX,
+                                        f32 scaleY, f32 scaleZ, u8 red, u8 green, u8 blue, u8 alpha, s16 type,
+                                        GraphicsContext* gfxCtx) {
     DebugDispObject* prevHead = sDebugObjectListHead;
 
     sDebugObjectListHead = Graph_Alloc(gfxCtx, sizeof(DebugDispObject));
@@ -64,25 +59,22 @@ DebugDispObject* DebugDisplay_AddObject(f32 posX, f32 posY, f32 posZ, s16 rotX,
     return sDebugObjectListHead;
 }
 
-void DebugDisplay_DrawObjects(GlobalContext* globalCtx)
-{
+void DebugDisplay_DrawObjects(GlobalContext* globalCtx) {
     DebugDispObject* dispObj = sDebugObjectListHead;
     DebugDispObjectInfo* objInfo;
 
-    while (dispObj != NULL)
-    {
+    while (dispObj != NULL) {
         objInfo = &sDebugObjectInfoTable[dispObj->type];
         sDebugObjectDrawFuncTable[objInfo->drawType](dispObj, objInfo->drawArg, globalCtx);
         dispObj = dispObj->next;
     }
 }
 
-static void DebugDisplay_DrawSpriteI8(DebugDispObject* dispObj, u32 texture, GlobalContext* globalCtx)
-{
+static void DebugDisplay_DrawSpriteI8(DebugDispObject* dispObj, u32 texture, GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_debug_display.c", 169);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_debug_display.c", 169);
 
     func_80094678(globalCtx->state.gfxCtx);
 
@@ -91,30 +83,23 @@ static void DebugDisplay_DrawSpriteI8(DebugDispObject* dispObj, u32 texture, Glo
     Matrix_Translate(dispObj->pos.x, dispObj->pos.y, dispObj->pos.z, MTXMODE_NEW);
     Matrix_Scale(dispObj->scale.x, dispObj->scale.y, dispObj->scale.z, MTXMODE_APPLY);
     Matrix_Mult(&globalCtx->mf_11DA0, MTXMODE_APPLY);
-    Matrix_RotateXYZ(dispObj->rot.x, dispObj->rot.y, dispObj->rot.z, MTXMODE_APPLY);
-
-    gDPLoadTextureBlock(gfxCtx->polyXlu.p++,
-                        texture,
-                        G_IM_FMT_I,
-                        G_IM_SIZ_8b,
-                        16, 16,
-                        0,
-                        G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP,
-                        G_TX_NOMASK, G_TX_NOMASK,
-                        G_TX_NOLOD, G_TX_NOLOD);
-
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_debug_display.c", 189), G_MTX_MODELVIEW | G_MTX_LOAD);
+    Matrix_RotateZYX(dispObj->rot.x, dispObj->rot.y, dispObj->rot.z, MTXMODE_APPLY);
+
+    gDPLoadTextureBlock(gfxCtx->polyXlu.p++, texture, G_IM_FMT_I, G_IM_SIZ_8b, 16, 16, 0, G_TX_NOMIRROR | G_TX_WRAP,
+                        G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
+
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_debug_display.c", 189),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, &D_04004298);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_debug_display.c", 192);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_debug_display.c", 192);
 }
 
-static void DebugDisplay_DrawPolygon(DebugDispObject* dispObj, u32 dlist, GlobalContext* globalCtx)
-{
+static void DebugDisplay_DrawPolygon(DebugDispObject* dispObj, u32 dlist, GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_debug_display.c", 211);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_debug_display.c", 211);
     func_8009435C(globalCtx->state.gfxCtx);
 
     gDPSetPrimColor(gfxCtx->polyXlu.p++, 0, 0, dispObj->color.r, dispObj->color.g, dispObj->color.b, dispObj->color.a);
@@ -124,8 +109,9 @@ static void DebugDisplay_DrawPolygon(DebugDispObject* dispObj, u32 dlist, Global
     func_800D1694(dispObj->pos.x, dispObj->pos.y, dispObj->pos.z, &dispObj->rot);
     Matrix_Scale(dispObj->scale.x, dispObj->scale.y, dispObj->scale.z, MTXMODE_APPLY);
 
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_debug_display.c", 228), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_debug_display.c", 228),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, dlist);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_debug_display.c", 231);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_debug_display.c", 231);
 }
diff --git a/src/code/z_demo.c b/src/code/z_demo.c
index c24ab06ad..c2cad2206 100644
--- a/src/code/z_demo.c
+++ b/src/code/z_demo.c
@@ -13,70 +13,34 @@ void func_80068C3C(GlobalContext* globalCtx, CutsceneContext* csCtx);
 void func_80068D84(GlobalContext* globalCtx, CutsceneContext* csCtx);
 void func_80068DC0(GlobalContext* globalCtx, CutsceneContext* csCtx);
 
-CutsceneStateHandler sCsStateHandlers1[] =
-{
-    func_80064720,
-    func_80064760,
-    func_80064720,
-    func_80068D84,
-    func_80064720,
+CutsceneStateHandler sCsStateHandlers1[] = {
+    func_80064720, func_80064760, func_80064720, func_80068D84, func_80064720,
 };
 
-CutsceneStateHandler sCsStateHandlers2[] =
-{
-    func_80064720,
-    func_800647C0,
-    func_80068C3C,
-    func_80068DC0,
-    func_80068C3C,
+CutsceneStateHandler sCsStateHandlers2[] = {
+    func_80064720, func_800647C0, func_80068C3C, func_80068DC0, func_80068C3C,
 };
 
 u8 sTitleCsState = 0;
 
 // TODO: use symbols for these cutscene locations once scenes and rooms are in C
-EntranceCutscene sEntranceCutsceneTable[] =
-{
-    { 0x0185, 2, 0xA0, 0x02013AA0 },
-    { 0x013D, 2, 0xA1, 0x02007EA0 },
-    { 0x00DB, 2, 0xA3, 0x0200A540 },
-    { 0x0108, 2, 0xA4, 0x02003D70 },
-    { 0x0138, 1, 0xA5, 0x02003F40 },
-    { 0x014D, 2, 0xA6, 0x02008400 },
-    { 0x0053, 2, 0xA7, 0x0200CE00 },
-    { 0x0000, 2, 0xA8, 0x0200B650 },
-    { 0x028A, 0, 0x18, 0x0200F9E0 },
-    { 0x0292, 0, 0x18, 0x0200FF00 },
-    { 0x028E, 0, 0x18, 0x02010550 },
-    { 0x0476, 0, 0x18, 0x02010B30 },
-    { 0x050F, 1, 0xA9, 0x0200BB80 },
-    { 0x0102, 2, 0xB1, 0x02007A30 },
-    { 0x0117, 2, 0xB2, 0x020031E0 },
-    { 0x0129, 2, 0xB3, 0x02006490 },
-    { 0x0157, 2, 0xB4, 0x02005BD0 },
-    { 0x0028, 2, 0xB5, 0x02015600 },
-    { 0x00E4, 2, 0xB6, 0x020070C0 },
-    { 0x0225, 2, 0xB7, 0x02004A80 },
-    { 0x0123, 2, 0xB8, 0x02007990 },
-    { 0x0147, 2, 0xB9, 0x020076D0 },
-    { 0x0138, 0, 0xBA, 0x02004280 },
-    { 0x0574, 2, 0x5A, 0x020028E0 },
-    { 0x0538, 2, 0xBB, 0x0201E790 },
-    { 0x053C, 2, 0xBC, 0x0201EF70 },
-    { 0x0540, 2, 0xBD, 0x02021380 },
-    { 0x0544, 2, 0xBE, 0x0201E3E0 },
-    { 0x0548, 2, 0xBF, 0x0201DF90 },
-    { 0x054C, 2, 0xAD, 0x0201EB40 },
-    { 0x008D, 0, 0xC0, 0x02002BB0 },
-    { 0x03B4, 0, 0xC7, 0x020055C0 },
-    { 0x0246, 2, 0xB9, 0x020076D0 },
+EntranceCutscene sEntranceCutsceneTable[] = {
+    { 0x0185, 2, 0xA0, 0x02013AA0 }, { 0x013D, 2, 0xA1, 0x02007EA0 }, { 0x00DB, 2, 0xA3, 0x0200A540 },
+    { 0x0108, 2, 0xA4, 0x02003D70 }, { 0x0138, 1, 0xA5, 0x02003F40 }, { 0x014D, 2, 0xA6, 0x02008400 },
+    { 0x0053, 2, 0xA7, 0x0200CE00 }, { 0x0000, 2, 0xA8, 0x0200B650 }, { 0x028A, 0, 0x18, 0x0200F9E0 },
+    { 0x0292, 0, 0x18, 0x0200FF00 }, { 0x028E, 0, 0x18, 0x02010550 }, { 0x0476, 0, 0x18, 0x02010B30 },
+    { 0x050F, 1, 0xA9, 0x0200BB80 }, { 0x0102, 2, 0xB1, 0x02007A30 }, { 0x0117, 2, 0xB2, 0x020031E0 },
+    { 0x0129, 2, 0xB3, 0x02006490 }, { 0x0157, 2, 0xB4, 0x02005BD0 }, { 0x0028, 2, 0xB5, 0x02015600 },
+    { 0x00E4, 2, 0xB6, 0x020070C0 }, { 0x0225, 2, 0xB7, 0x02004A80 }, { 0x0123, 2, 0xB8, 0x02007990 },
+    { 0x0147, 2, 0xB9, 0x020076D0 }, { 0x0138, 0, 0xBA, 0x02004280 }, { 0x0574, 2, 0x5A, 0x020028E0 },
+    { 0x0538, 2, 0xBB, 0x0201E790 }, { 0x053C, 2, 0xBC, 0x0201EF70 }, { 0x0540, 2, 0xBD, 0x02021380 },
+    { 0x0544, 2, 0xBE, 0x0201E3E0 }, { 0x0548, 2, 0xBF, 0x0201DF90 }, { 0x054C, 2, 0xAD, 0x0201EB40 },
+    { 0x008D, 0, 0xC0, 0x02002BB0 }, { 0x03B4, 0, 0xC7, 0x020055C0 }, { 0x0246, 2, 0xB9, 0x020076D0 },
     { 0x05E8, 2, 0xC6, 0x0200C9D0 },
 };
 
 // Unused, seems to be an early list of dungeon entrance cutscene locations
-u32 D_8011E304[] =
-{
-    0x0200B650, 0x02015600, 0x02014F80, 0x02003F80, 0x02000330, 0x0201DA50
-};
+u32 D_8011E304[] = { 0x0200B650, 0x02015600, 0x02014F80, 0x02003F80, 0x02000330, 0x0201DA50 };
 
 u16 D_8015FCC0;
 u16 D_8015FCC2;
@@ -84,14 +48,13 @@ u16 D_8015FCC4;
 s16 D_8015FCC6;
 u8 D_8015FCC8;
 s16 D_8015FCCA;
-u16 D_8015FCCC; // only written to, never read
+u16 D_8015FCCC;    // only written to, never read
 s8 D_8015FCD0[20]; // unreferenced
-u8 D_8015FCE4; // only written to, never read
+u8 D_8015FCE4;     // only written to, never read
 
 void func_80068ECC(GlobalContext* globalCtx, CutsceneContext* csCtx);
 
-void Cutscene_DrawDebugInfo(GlobalContext* globalCtx, Gfx** dlist, CutsceneContext* csCtx)
-{
+void Cutscene_DrawDebugInfo(GlobalContext* globalCtx, Gfx** dlist, CutsceneContext* csCtx) {
     u8 pad[0x1C];
     GfxPrint printer;
     u8 pad2[8];
@@ -110,65 +73,59 @@ void Cutscene_DrawDebugInfo(GlobalContext* globalCtx, Gfx** dlist, CutsceneConte
     GfxPrint_Dtor(&printer);
 }
 
-void func_8006450C(GlobalContext* globalCtx, CutsceneContext* csCtx)
-{
+void func_8006450C(GlobalContext* globalCtx, CutsceneContext* csCtx) {
     csCtx->state = CS_STATE_IDLE;
     csCtx->unk_0C = 0.0f;
 }
 
-void func_80064520(GlobalContext* globalCtx, CutsceneContext* csCtx)
-{
+void func_80064520(GlobalContext* globalCtx, CutsceneContext* csCtx) {
     csCtx->state = CS_STATE_SKIPPABLE_INIT;
     csCtx->linkAction = NULL;
 }
 
-void func_80064534(GlobalContext* globalCtx, CutsceneContext* csCtx)
-{
-    if (csCtx->state != CS_STATE_UNSKIPPABLE_EXEC)
+void func_80064534(GlobalContext* globalCtx, CutsceneContext* csCtx) {
+    if (csCtx->state != CS_STATE_UNSKIPPABLE_EXEC) {
         csCtx->state = CS_STATE_UNSKIPPABLE_INIT;
+    }
 }
 
-void func_80064558(GlobalContext* globalCtx, CutsceneContext* csCtx)
-{
-    if (gSaveContext.cutscene_index < 0xFFF0)
+void func_80064558(GlobalContext* globalCtx, CutsceneContext* csCtx) {
+    if (gSaveContext.cutscene_index < 0xFFF0) {
         sCsStateHandlers1[csCtx->state](globalCtx, csCtx);
+    }
 }
 
 #ifdef NON_MATCHING
 // minor ordering and regalloc differences
-void func_800645A0(GlobalContext* globalCtx, CutsceneContext* csCtx)
-{
+void func_800645A0(GlobalContext* globalCtx, CutsceneContext* csCtx) {
     CutsceneStateHandler handler;
 
     if (!~(globalCtx->state.input[0].padPressed | -0x201) && (csCtx->state == CS_STATE_IDLE) &&
-        (gSaveContext.scene_setup_index >= 4))
-    {
+        (gSaveContext.scene_setup_index >= 4)) {
         D_8015FCC8 = 0;
         gSaveContext.cutscene_index = 0xFFFD;
         gSaveContext.cutscene_trigger = 1;
     }
 
     if (!~(globalCtx->state.input[0].padPressed | -0x801) && (csCtx->state == CS_STATE_IDLE) &&
-        (gSaveContext.scene_setup_index >= 4) && (D_8011D394 == 0))
-    {
+        (gSaveContext.scene_setup_index >= 4) && (D_8011D394 == 0)) {
         D_8015FCC8 = 1;
         gSaveContext.cutscene_index = 0xFFFD;
         gSaveContext.cutscene_trigger = 1;
     }
 
-    if ((gSaveContext.cutscene_trigger != 0) && (globalCtx->sceneLoadFlag == 0x14))
+    if ((gSaveContext.cutscene_trigger != 0) && (globalCtx->sceneLoadFlag == 0x14)) {
         gSaveContext.cutscene_trigger = 0;
+    }
 
-    if ((gSaveContext.cutscene_trigger != 0) && (csCtx->state == CS_STATE_IDLE))
-    {
+    if ((gSaveContext.cutscene_trigger != 0) && (csCtx->state == CS_STATE_IDLE)) {
         // Translates to: "CUTSCENE START REQUEST ANNOUNCEMENT!"
         osSyncPrintf("\nデモ開始要求 発令！");
         gSaveContext.cutscene_index = 0xFFFD;
         gSaveContext.cutscene_trigger = 1;
     }
 
-    if (gSaveContext.cutscene_index >= 0xFFF0)
-    {
+    if (gSaveContext.cutscene_index >= 0xFFF0) {
         func_80068ECC(globalCtx, csCtx);
         handler = sCsStateHandlers2[csCtx->state];
         handler(globalCtx, csCtx);
@@ -178,36 +135,29 @@ void func_800645A0(GlobalContext* globalCtx, CutsceneContext* csCtx)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_demo/func_800645A0.s")
 #endif
 
-void func_80064720(GlobalContext* globalCtx, CutsceneContext* csCtx)
-{
-
+void func_80064720(GlobalContext* globalCtx, CutsceneContext* csCtx) {
 }
 
-u32 func_8006472C(GlobalContext* globalCtx, CutsceneContext* csCtx, f32 target)
-{
+u32 func_8006472C(GlobalContext* globalCtx, CutsceneContext* csCtx, f32 target) {
     return Math_ApproxF(&csCtx->unk_0C, target, 0.1f);
 }
 
-void func_80064760(GlobalContext* globalCtx, CutsceneContext* csCtx)
-{
+void func_80064760(GlobalContext* globalCtx, CutsceneContext* csCtx) {
     Interface_ChangeAlpha(1);
     func_800B3840(0x20);
 
-    if (func_8006472C(globalCtx, csCtx, 1.0f))
-    {
+    if (func_8006472C(globalCtx, csCtx, 1.0f)) {
         func_800F68BC(1);
         csCtx->state++;
     }
 }
 
-void func_800647C0(GlobalContext* globalCtx, CutsceneContext* csCtx)
-{
+void func_800647C0(GlobalContext* globalCtx, CutsceneContext* csCtx) {
     func_80068C3C(globalCtx, csCtx);
     Interface_ChangeAlpha(1);
     func_800B3840(0x20);
 
-    if (func_8006472C(globalCtx, csCtx, 1.0f))
-    {
+    if (func_8006472C(globalCtx, csCtx, 1.0f)) {
         func_800F68BC(1);
         csCtx->state++;
     }
@@ -216,56 +166,53 @@ void func_800647C0(GlobalContext* globalCtx, CutsceneContext* csCtx)
 // Command 3: Misc. Actions
 #ifdef NON_MATCHING
 // regalloc and minor ordering differences
-void func_80064824(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdBase* cmd)
-{
+void func_80064824(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdBase* cmd) {
     Player* player = PLAYER;
     f32 temp;
     u8 sp3F;
 
     sp3F = 0;
 
-    if ((csCtx->frames < cmd->startFrame) ||
-        (csCtx->frames >= cmd->endFrame) && (cmd->endFrame != cmd->startFrame))
+    if ((csCtx->frames < cmd->startFrame) || (csCtx->frames >= cmd->endFrame) && (cmd->endFrame != cmd->startFrame)) {
         return;
+    }
 
     temp = func_8006F93C(cmd->endFrame - 1, cmd->startFrame, csCtx->frames);
 
-    if (csCtx->frames == cmd->startFrame)
+    if (csCtx->frames == cmd->startFrame) {
         sp3F = 1;
+    }
 
-    switch (cmd->base)
-    {
+    switch (cmd->base) {
         case 1:
-            if (sp3F != 0)
-            {
+            if (sp3F != 0) {
                 func_800F6D58(0xE, 4, 0x3F);
                 func_800F6D58(0xE, 1, 1);
                 globalCtx->unk_10B12[0] = 0x14;
             }
             break;
         case 2:
-            if (sp3F != 0)
-            {
+            if (sp3F != 0) {
                 func_800F6D58(0xF, 0, 0);
                 func_800753C4(globalCtx, 3);
                 D_8015FD70 = 1;
             }
             break;
         case 3:
-            if (sp3F != 0)
-            {
+            if (sp3F != 0) {
                 func_8006C3D0(globalCtx, 0);
-                if (gSaveContext.entrance_index == 0x0053)
+                if (gSaveContext.entrance_index == 0x0053) {
                     func_8006C3D0(globalCtx, 2);
+                }
             }
             break;
         case 6:
-            if (globalCtx->unk_10AC4 < 0x3200)
+            if (globalCtx->unk_10AC4 < 0x3200) {
                 globalCtx->unk_10AC4 += 0x23;
+            }
             break;
         case 7:
-            if (sp3F != 0)
-            {
+            if (sp3F != 0) {
                 globalCtx->unk_10A3D = 1;
                 globalCtx->gloomySky = 1;
                 globalCtx->unk_10A3C = 0;
@@ -277,8 +224,9 @@ void func_80064824(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdBase*
             }
             break;
         case 8:
-            if (globalCtx->unk_11D30[0] < 0x80)
+            if (globalCtx->unk_11D30[0] < 0x80) {
                 globalCtx->unk_11D30[0] += 4;
+            }
             break;
         case 9:
             globalCtx->unk_10B12[3] = 0x10;
@@ -287,55 +235,61 @@ void func_80064824(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdBase*
             func_8006C3D0(globalCtx, 1);
             break;
         case 11:
-            if (globalCtx->unk_11D30[0] < 0x672)
+            if (globalCtx->unk_11D30[0] < 0x672) {
                 globalCtx->unk_11D30[0] += 0x14;
-            if (csCtx->frames == 0x30F)
+            }
+            if (csCtx->frames == 0x30F) {
                 func_80078884(NA_SE_EV_DEKU_DEATH);
-            else if (csCtx->frames == 0x2CD)
+            } else if (csCtx->frames == 0x2CD) {
                 globalCtx->unk_11D30[0] = 0;
+            }
             break;
         case 12:
-            if (sp3F != 0)
-            {
-                if (csCtx->state != CS_STATE_UNSKIPPABLE_EXEC)
+            if (sp3F != 0) {
+                if (csCtx->state != CS_STATE_UNSKIPPABLE_EXEC) {
                     csCtx->state = CS_STATE_UNSKIPPABLE_INIT;
+                }
             }
             break;
         case 13:
-            if (globalCtx->unk_11D30[1] == 0)
+            if (globalCtx->unk_11D30[1] == 0) {
                 func_80078884(NA_SE_EV_TRIFORCE_FLASH);
-            if (globalCtx->unk_11D30[1] < 0xFF)
+            }
+            if (globalCtx->unk_11D30[1] < 0xFF) {
                 globalCtx->unk_11D30[1] += 5;
+            }
             break;
         case 14:
-            if (sp3F != 0)
+            if (sp3F != 0) {
                 func_800BC490(globalCtx, 1);
+            }
             break;
         case 15:
-            if (sp3F != 0)
-                TitleCard_InitPlaceName(globalCtx, &globalCtx->actorCtx.titleCtx, player->unk_1B0,
-                                        0xA0, 0x78, 0x90, 0x18, 0x14);
+            if (sp3F != 0) {
+                TitleCard_InitPlaceName(globalCtx, &globalCtx->actorCtx.titleCtx, player->unk_1B0, 0xA0, 0x78, 0x90,
+                                        0x18, 0x14);
+            }
             break;
         case 16:
-            if (sp3F != 0)
-            {
-                D_8015FCCA = func_80092F88(globalCtx->cameraCtx.activeCameraPtrs[globalCtx->cameraCtx.unk_5C0], 6);
-                func_80092DAC(D_8015FCCA, 0x7FFF);
-                func_80092E70(D_8015FCCA, 4, 0, 1000, 0);
-                func_80092DF0(D_8015FCCA, 800);
+            if (sp3F != 0) {
+                D_8015FCCA = Quake_Add(globalCtx->cameraCtx.activeCameraPtrs[globalCtx->cameraCtx.unk_5C0], 6);
+                Quake_SetSpeed(D_8015FCCA, 0x7FFF);
+                Quake_SetQuakeValues(D_8015FCCA, 4, 0, 1000, 0);
+                Quake_SetCountdown(D_8015FCCA, 800);
             }
             break;
         case 17:
-            if (sp3F != 0)
-                func_80092FAC(D_8015FCCA);
+            if (sp3F != 0) {
+                Quake_RemoveFromIdx(D_8015FCCA);
+            }
             break;
         case 18:
             globalCtx->unk_10B12[0] = 0;
             globalCtx->gloomySkyEvent = 2;
-            if (gSaveContext.day_time < 0x4AAB)
+            if (gSaveContext.day_time < 0x4AAB) {
                 gSaveContext.day_time += 30;
-            if (globalCtx->unk_10B12[1] == 0)
-            {
+            }
+            if (globalCtx->unk_10B12[1] == 0) {
                 D_8011FB30 = 0;
                 func_800F6D58(14, 1, 0);
             }
@@ -366,34 +320,30 @@ void func_80064824(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdBase*
             break;
         case 25:
             gSaveContext.day_time += 30;
-            if ((gSaveContext.day_time & 0xFFFF) > 0xCAAA)
+            if ((gSaveContext.day_time & 0xFFFF) > 0xCAAA) {
                 gSaveContext.day_time = 0xCAAA;
+            }
             break;
         case 26:
-            if ((gSaveContext.day_time < 0x3000) || (gSaveContext.day_time >= 0x4555))
-            {
-                if ((gSaveContext.day_time >= 0x4555) && (gSaveContext.day_time < 0xAAAB))
+            if ((gSaveContext.day_time < 0x3000) || (gSaveContext.day_time >= 0x4555)) {
+                if ((gSaveContext.day_time >= 0x4555) && (gSaveContext.day_time < 0xAAAB)) {
                     globalCtx->unk_10AE3 = 1;
-                else if ((gSaveContext.day_time >= 0xAAAB) && (gSaveContext.day_time < 0xC556))
+                } else if ((gSaveContext.day_time >= 0xAAAB) && (gSaveContext.day_time < 0xC556)) {
                     globalCtx->unk_10AE3 = 2;
-                else
+                } else {
                     globalCtx->unk_10AE3 = 3;
+                }
             }
             break;
         case 27:
-            if (globalCtx->state.frames & 8)
-            {
-                if (globalCtx->unk_10AB0[0] < 40)
-                {
+            if (globalCtx->state.frames & 8) {
+                if (globalCtx->unk_10AB0[0] < 40) {
                     globalCtx->unk_10AB0[0] += 2;
                     globalCtx->unk_10AB0[4] -= 3;
                     globalCtx->unk_10AB0[5] -= 3;
                 }
-            }
-            else
-            {
-                if (globalCtx->unk_10AB0[0] > 2)
-                {
+            } else {
+                if (globalCtx->unk_10AB0[0] > 2) {
                     globalCtx->unk_10AB0[0] -= 2;
                     globalCtx->unk_10AB0[4] += 3;
                     globalCtx->unk_10AB0[5] += 3;
@@ -413,18 +363,20 @@ void func_80064824(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdBase*
             func_8006C3D0(globalCtx, 4);
             break;
         case 32:
-            if (sp3F != 0)
+            if (sp3F != 0) {
                 globalCtx->unk_10B0A = 1;
+            }
             func_800788CC(0x20C0);
             break;
         case 33:
             gSaveContext.unk_1422 = 1;
             break;
         case 34:
-            if (!gSaveContext.night_flag)
+            if (!gSaveContext.night_flag) {
                 gSaveContext.day_time -= D_8011FB40;
-            else
+            } else {
                 gSaveContext.day_time -= D_8011FB40 * 2;
+            }
             break;
         case 35:
             func_800EE824(csCtx);
@@ -437,62 +389,57 @@ void func_80064824(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdBase*
 #endif
 
 // Command 4: Set Environment Lighting
-void Cutscene_Command_SetLighting(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdEnvLighting* cmd)
-{
-    if (csCtx->frames == cmd->startFrame)
-    {
+void Cutscene_Command_SetLighting(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdEnvLighting* cmd) {
+    if (csCtx->frames == cmd->startFrame) {
         globalCtx->unk_10AE3 = cmd->setting - 1;
         globalCtx->unk_10AFC = 1.0f;
     }
 }
 
 // Command 0x56: Play Background Music
-void Cutscene_Command_PlayBGM(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdMusicChange* cmd)
-{
-    if (csCtx->frames == cmd->startFrame)
+void Cutscene_Command_PlayBGM(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdMusicChange* cmd) {
+    if (csCtx->frames == cmd->startFrame) {
         func_800F595C(cmd->sequence - 1);
+    }
 }
 
 // Command 0x57: Stop Background Music
-void Cutscene_Command_StopBGM(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdMusicChange* cmd)
-{
-    if (csCtx->frames == cmd->startFrame)
+void Cutscene_Command_StopBGM(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdMusicChange* cmd) {
+    if (csCtx->frames == cmd->startFrame) {
         func_800F59E8(cmd->sequence - 1);
+    }
 }
 
 // Command 0x7C: Fade Background Music over duration
-void Cutscene_Command_FadeBGM(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdMusicFade* cmd)
-{
+void Cutscene_Command_FadeBGM(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdMusicFade* cmd) {
     u8 var1;
 
-    if ((csCtx->frames == cmd->startFrame) && (csCtx->frames < cmd->endFrame))
-    {
+    if ((csCtx->frames == cmd->startFrame) && (csCtx->frames < cmd->endFrame)) {
         var1 = cmd->endFrame - cmd->startFrame;
 
-        if (cmd->type == 3)
+        if (cmd->type == 3) {
             Audio_SetBGM(var1 << 0x10 | 0x110000FF);
-        else
+        } else {
             Audio_SetBGM(var1 << 0x10 | 0x100000FF);
+        }
     }
 }
 
 // Command 9: ?
-void Cutscene_Command_09(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdUnknown9* cmd)
-{
-    if (csCtx->frames == cmd->startFrame)
+void Cutscene_Command_09(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdUnknown9* cmd) {
+    if (csCtx->frames == cmd->startFrame) {
         func_800AA000(0.0f, cmd->unk_06, cmd->unk_07, cmd->unk_08);
+    }
 }
 
 // Command 0x8C: Set Time of Day & Environment Time
 #ifdef NON_MATCHING
 // regalloc differences
-void func_80065134(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdDayTime* cmd)
-{
+void func_80065134(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdDayTime* cmd) {
     s16 temp1;
     s16 temp2;
 
-    if (csCtx->frames == cmd->startFrame)
-    {
+    if (csCtx->frames == cmd->startFrame) {
         temp1 = (cmd->hour * 60.0f) / 0.021972656f;
         temp2 = (cmd->minute + 1) / 0.021972656f;
         gSaveContext.environment_time = gSaveContext.day_time = temp1 + temp2;
@@ -503,25 +450,22 @@ void func_80065134(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdDayTim
 #endif
 
 // Command 0x3E8: Code Execution (& Terminates Cutscene?)
-void Cutscene_Command_Terminator(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdBase* cmd)
-{
+void Cutscene_Command_Terminator(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdBase* cmd) {
     Player* player = PLAYER;
     s32 temp = 0;
 
-    if ((gSaveContext.game_mode != 0) && (gSaveContext.game_mode != 3) &&
-        (globalCtx->sceneNum != SCENE_SPOT00) && (csCtx->frames > 20) &&
-        (!~(globalCtx->state.input[0].padPressed | 0xFFFF7FFF) ||
-         !~(globalCtx->state.input[0].padPressed | -0x4001) ||
+    if ((gSaveContext.game_mode != 0) && (gSaveContext.game_mode != 3) && (globalCtx->sceneNum != SCENE_SPOT00) &&
+        (csCtx->frames > 20) &&
+        (!~(globalCtx->state.input[0].padPressed | 0xFFFF7FFF) || !~(globalCtx->state.input[0].padPressed | -0x4001) ||
          !~(globalCtx->state.input[0].padPressed | -0x1001)) &&
-        (gSaveContext.file_num != 0xFEDC) && (globalCtx->sceneLoadFlag == 0))
-    {
+        (gSaveContext.file_num != 0xFEDC) && (globalCtx->sceneLoadFlag == 0)) {
         Audio_PlaySoundGeneral(NA_SE_SY_PIECE_OF_HEART, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
         temp = 1;
     }
 
     if ((csCtx->frames == cmd->startFrame) || (temp != 0) ||
-        ((csCtx->frames > 20) && (!~(globalCtx->state.input[0].padPressed | -0x1001)) && (gSaveContext.file_num != 0xFEDC)))
-    {
+        ((csCtx->frames > 20) && (!~(globalCtx->state.input[0].padPressed | -0x1001)) &&
+         (gSaveContext.file_num != 0xFEDC))) {
         csCtx->state = CS_STATE_UNSKIPPABLE_EXEC;
         func_800F68BC(0);
         gSaveContext.unk_1410 = 1;
@@ -529,13 +473,13 @@ void Cutscene_Command_Terminator(GlobalContext* globalCtx, CutsceneContext* csCt
         // Translates to: "FUTURE FORK DESIGNATION=No. [%d]"
         osSyncPrintf("\n分岐先指定！！=[%d]番", cmd->base);
 
-        if ((gSaveContext.game_mode != 0) && (csCtx->frames != cmd->startFrame))
+        if ((gSaveContext.game_mode != 0) && (csCtx->frames != cmd->startFrame)) {
             gSaveContext.unk_13E7 = 1;
+        }
 
         gSaveContext.cutscene_index = 0;
 
-        switch (cmd->base)
-        {
+        switch (cmd->base) {
             case 1:
                 globalCtx->nextEntranceIndex = 0x00A0;
                 gSaveContext.cutscene_index = 0xFFF1;
@@ -581,22 +525,19 @@ void Cutscene_Command_Terminator(GlobalContext* globalCtx, CutsceneContext* csCt
             case 8:
                 gSaveContext.fw.set = 0;
                 gSaveContext.respawn[RESPAWN_MODE_TOP].data = 0;
-                if (!(gSaveContext.event_chk_inf[4] & 0x20))
-                {
+                if (!(gSaveContext.event_chk_inf[4] & 0x20)) {
                     gSaveContext.event_chk_inf[4] |= 0x20;
                     globalCtx->nextEntranceIndex = 0x00A0;
                     globalCtx->sceneLoadFlag = 0x14;
                     gSaveContext.cutscene_index = 0xFFF3;
                     globalCtx->fadeOutTransition = 0xB;
-                }
-                else
-                {
-                    if (gSaveContext.scene_setup_index < 4)
-                    {
-                        if (LINK_IS_CHILD)
+                } else {
+                    if (gSaveContext.scene_setup_index < 4) {
+                        if (LINK_IS_CHILD) {
                             globalCtx->linkAgeOnLoad = 0;
-                        else
+                        } else {
                             globalCtx->linkAgeOnLoad = 1;
+                        }
                     }
                     globalCtx->nextEntranceIndex = 0x02CA;
                     globalCtx->sceneLoadFlag = 0x14;
@@ -1037,19 +978,14 @@ void Cutscene_Command_Terminator(GlobalContext* globalCtx, CutsceneContext* csCt
                 globalCtx->fadeOutTransition = 3;
                 break;
             case 95:
-                if ((gSaveContext.event_chk_inf[4] & 0x100) &&
-                    (gSaveContext.event_chk_inf[4] & 0x200) &&
-                    (gSaveContext.event_chk_inf[4] & 0x400))
-                {
+                if ((gSaveContext.event_chk_inf[4] & 0x100) && (gSaveContext.event_chk_inf[4] & 0x200) &&
+                    (gSaveContext.event_chk_inf[4] & 0x400)) {
                     globalCtx->nextEntranceIndex = 0x0053;
                     globalCtx->sceneLoadFlag = 0x14;
                     gSaveContext.cutscene_index = 0xFFF3;
                     globalCtx->fadeOutTransition = 2;
-                }
-                else
-                {
-                    switch (gSaveContext.scene_setup_index)
-                    {
+                } else {
+                    switch (gSaveContext.scene_setup_index) {
                         case 8:
                             globalCtx->nextEntranceIndex = 0x00FC;
                             globalCtx->sceneLoadFlag = 0x14;
@@ -1070,15 +1006,12 @@ void Cutscene_Command_Terminator(GlobalContext* globalCtx, CutsceneContext* csCt
                 }
                 break;
             case 96:
-                if (gBitFlags[4] & gSaveContext.quest_items)
-                {
+                if (gBitFlags[4] & gSaveContext.quest_items) {
                     globalCtx->nextEntranceIndex = 0x006B;
                     globalCtx->sceneLoadFlag = 0x14;
                     gSaveContext.cutscene_index = 0xFFF1;
                     globalCtx->fadeOutTransition = 5;
-                }
-                else
-                {
+                } else {
                     gSaveContext.event_chk_inf[12] |= 0x100;
                     globalCtx->nextEntranceIndex = 0x0610;
                     globalCtx->sceneLoadFlag = 0x14;
@@ -1087,15 +1020,12 @@ void Cutscene_Command_Terminator(GlobalContext* globalCtx, CutsceneContext* csCt
                 }
                 break;
             case 97:
-                if (gBitFlags[3] & gSaveContext.quest_items)
-                {
+                if (gBitFlags[3] & gSaveContext.quest_items) {
                     globalCtx->nextEntranceIndex = 0x006B;
                     globalCtx->sceneLoadFlag = 0x14;
                     gSaveContext.cutscene_index = 0xFFF1;
                     globalCtx->fadeOutTransition = 5;
-                }
-                else
-                {
+                } else {
                     globalCtx->nextEntranceIndex = 0x0580;
                     globalCtx->sceneLoadFlag = 0x14;
                     globalCtx->fadeOutTransition = 3;
@@ -1138,8 +1068,7 @@ void Cutscene_Command_Terminator(GlobalContext* globalCtx, CutsceneContext* csCt
                 globalCtx->fadeOutTransition = 2;
                 break;
             case 104:
-                switch (sTitleCsState)
-                {
+                switch (sTitleCsState) {
                     case 0:
                         globalCtx->nextEntranceIndex = 0x008D;
                         globalCtx->sceneLoadFlag = 0x14;
@@ -1206,16 +1135,13 @@ void Cutscene_Command_Terminator(GlobalContext* globalCtx, CutsceneContext* csCt
                 break;
             case 113:
                 if (Flags_GetEventChkInf(0xBB) && Flags_GetEventChkInf(0xBC) && Flags_GetEventChkInf(0xBD) &&
-                    Flags_GetEventChkInf(0xBE) && Flags_GetEventChkInf(0xBF) && Flags_GetEventChkInf(0xAD))
-                {
+                    Flags_GetEventChkInf(0xBE) && Flags_GetEventChkInf(0xBF) && Flags_GetEventChkInf(0xAD)) {
                     globalCtx->csCtx.segment = SEGMENTED_TO_VIRTUAL(&D_0201DA50);
                     globalCtx->csCtx.frames = 0;
                     gSaveContext.cutscene_trigger = 1;
                     gSaveContext.cutscene_index = 0xFFFF;
                     csCtx->state = CS_STATE_UNSKIPPABLE_INIT;
-                }
-                else
-                {
+                } else {
                     gSaveContext.cutscene_index = 0xFFFF;
                     csCtx->state = CS_STATE_UNSKIPPABLE_INIT;
                 }
@@ -1232,14 +1158,11 @@ void Cutscene_Command_Terminator(GlobalContext* globalCtx, CutsceneContext* csCt
                 gSaveContext.transition_type = 2;
                 break;
             case 116:
-                if (gSaveContext.event_chk_inf[12] & 0x100)
-                {
+                if (gSaveContext.event_chk_inf[12] & 0x100) {
                     globalCtx->nextEntranceIndex = 0x0580;
                     globalCtx->sceneLoadFlag = 0x14;
                     globalCtx->fadeOutTransition = 3;
-                }
-                else
-                {
+                } else {
                     globalCtx->nextEntranceIndex = 0x0610;
                     globalCtx->sceneLoadFlag = 0x14;
                     globalCtx->fadeOutTransition = 3;
@@ -1273,67 +1196,68 @@ void Cutscene_Command_Terminator(GlobalContext* globalCtx, CutsceneContext* csCt
 }
 
 // Command 0x2D: Transition Effects
-void Cutscene_Command_TransitionFX(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdBase* cmd)
-{
+void Cutscene_Command_TransitionFX(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdBase* cmd) {
     f32 temp;
 
-    if ((csCtx->frames >= cmd->startFrame) && (csCtx->frames <= cmd->endFrame))
-    {
+    if ((csCtx->frames >= cmd->startFrame) && (csCtx->frames <= cmd->endFrame)) {
         globalCtx->unk_10B05 = 1;
         temp = func_8006F93C(cmd->endFrame, cmd->startFrame, csCtx->frames);
 
-        switch (cmd->base)
-        {
+        switch (cmd->base) {
             case 1:
             case 5:
                 globalCtx->unk_10B06[0] = 0xA0;
                 globalCtx->unk_10B06[1] = 0xA0;
                 globalCtx->unk_10B06[2] = 0xA0;
-                if (cmd->base == 1)
-                {
+                if (cmd->base == 1) {
                     globalCtx->unk_10B06[3] = 255.0f * temp;
-                    if ((temp == 0.0f) && (gSaveContext.entrance_index == 0x006B))
-                        Audio_PlaySoundGeneral(NA_SE_SY_WHITE_OUT_S, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
-                    else if ((temp == 0.0f) &&
-                             ((gSaveContext.entrance_index == 0x0053) ||
-                              (gSaveContext.entrance_index == 0x0138) ||
-                              (gSaveContext.entrance_index == 0x0371)))
-                        Audio_PlaySoundGeneral(NA_SE_EV_WHITE_OUT, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
-                    else if ((temp == 0.0f) && (globalCtx->sceneNum == SCENE_GANONTIKA))
+                    if ((temp == 0.0f) && (gSaveContext.entrance_index == 0x006B)) {
+                        Audio_PlaySoundGeneral(NA_SE_SY_WHITE_OUT_S, &D_801333D4, 4, &D_801333E0, &D_801333E0,
+                                               &D_801333E8);
+                    } else if ((temp == 0.0f) &&
+                               ((gSaveContext.entrance_index == 0x0053) || (gSaveContext.entrance_index == 0x0138) ||
+                                (gSaveContext.entrance_index == 0x0371))) {
+                        Audio_PlaySoundGeneral(NA_SE_EV_WHITE_OUT, &D_801333D4, 4, &D_801333E0, &D_801333E0,
+                                               &D_801333E8);
+                    } else if ((temp == 0.0f) && (globalCtx->sceneNum == SCENE_GANONTIKA)) {
                         func_800788CC(NA_SE_EV_WHITE_OUT);
-                }
-                else
+                    }
+                } else {
                     globalCtx->unk_10B06[3] = (1.0f - temp) * 255.0f;
+                }
                 break;
             case 2:
             case 6:
                 globalCtx->unk_10B06[0] = 0;
                 globalCtx->unk_10B06[1] = 0;
                 globalCtx->unk_10B06[2] = 0xFF;
-                if (cmd->base == 2)
+                if (cmd->base == 2) {
                     globalCtx->unk_10B06[3] = 255.0f * temp;
-                else
+                } else {
                     globalCtx->unk_10B06[3] = (1.0f - temp) * 255.0f;
+                }
                 break;
             case 3:
             case 7:
                 globalCtx->unk_10B06[0] = 0xFF;
                 globalCtx->unk_10B06[1] = 0;
                 globalCtx->unk_10B06[2] = 0;
-                if (cmd->base == 3)
+                if (cmd->base == 3) {
                     globalCtx->unk_10B06[3] = (1.0f - temp) * 255.0f;
-                else
+                } else {
                     globalCtx->unk_10B06[3] = 255.0f * temp;
+                }
                 break;
             case 4:
             case 8:
                 globalCtx->unk_10B06[0] = 0;
                 globalCtx->unk_10B06[1] = 0xFF;
                 globalCtx->unk_10B06[2] = 0;
-                if (cmd->base == 4)
+                if (cmd->base == 4) {
                     globalCtx->unk_10B06[3] = (1.0f - temp) * 255.0f;
-                else
+                } else {
                     globalCtx->unk_10B06[3] = 255.0f * temp;
+                }
                 break;
             case 9:
                 gSaveContext.unk_1410 = 1;
@@ -1343,10 +1267,11 @@ void Cutscene_Command_TransitionFX(GlobalContext* globalCtx, CutsceneContext* cs
                 globalCtx->unk_10B06[0] = 0;
                 globalCtx->unk_10B06[1] = 0;
                 globalCtx->unk_10B06[2] = 0;
-                if (cmd->base == 10)
+                if (cmd->base == 10) {
                     globalCtx->unk_10B06[3] = (1.0f - temp) * 255.0f;
-                else
+                } else {
                     globalCtx->unk_10B06[3] = 255.0f * temp;
+                }
                 break;
             case 12:
                 gSaveContext.unk_1410 = 255.0f - (155.0f * temp);
@@ -1362,8 +1287,7 @@ void Cutscene_Command_TransitionFX(GlobalContext* globalCtx, CutsceneContext* cs
 }
 
 // Command 0x1 & 0x5: Camera Positions
-s32 Cutscene_Command_CameraPositions(GlobalContext* globalCtx, CutsceneContext* csCtx, u8* cmd, u8 relativeToLink)
-{
+s32 Cutscene_Command_CameraPositions(GlobalContext* globalCtx, CutsceneContext* csCtx, u8* cmd, u8 relativeToLink) {
     s32 shouldContinue = 1;
     CsCmdBase* cmdBase = (CsCmdBase*)cmd;
     s32 size;
@@ -1372,15 +1296,12 @@ s32 Cutscene_Command_CameraPositions(GlobalContext* globalCtx, CutsceneContext*
     size = 8;
 
     if ((cmdBase->startFrame < csCtx->frames) && (csCtx->frames < cmdBase->endFrame) &&
-        ((csCtx->unk_18 < cmdBase->startFrame) || (csCtx->unk_18 >= 0xF000)))
-    {
+        ((csCtx->unk_18 < cmdBase->startFrame) || (csCtx->unk_18 >= 0xF000))) {
         csCtx->unk_1B = 1;
         csCtx->cameraPosition = (CutsceneCameraPoint*)cmd;
-        if (csCtx->unk_1A != 0)
-        {
+        if (csCtx->unk_1A != 0) {
             csCtx->unk_18 = cmdBase->startFrame;
-            if (D_8015FCC8 != 0)
-            {
+            if (D_8015FCC8 != 0) {
                 func_800C0874(globalCtx, csCtx->unk_16, 0x25);
                 func_800C0314(globalCtx, D_8015FCC6, 1);
                 func_800C0314(globalCtx, csCtx->unk_16, 7);
@@ -1391,10 +1312,10 @@ s32 Cutscene_Command_CameraPositions(GlobalContext* globalCtx, CutsceneContext*
         }
     }
 
-    while (shouldContinue)
-    {
-        if (((CutsceneCameraPoint*)cmd)->continueFlag == -1)
-             shouldContinue = 0;
+    while (shouldContinue) {
+        if (((CutsceneCameraPoint*)cmd)->continueFlag == -1) {
+            shouldContinue = 0;
+        }
         cmd += 0x10;
         size += 0x10;
     }
@@ -1403,8 +1324,7 @@ s32 Cutscene_Command_CameraPositions(GlobalContext* globalCtx, CutsceneContext*
 }
 
 // Command 0x2 & 0x6: Camera Focus Points
-s32 Cutscene_Command_CameraFocus(GlobalContext* globalCtx, CutsceneContext* csCtx, u8* cmd, u8 relativeToLink)
-{
+s32 Cutscene_Command_CameraFocus(GlobalContext* globalCtx, CutsceneContext* csCtx, u8* cmd, u8 relativeToLink) {
     s32 shouldContinue = 1;
     CsCmdBase* cmdBase = (CsCmdBase*)cmd;
     s32 size;
@@ -1413,15 +1333,12 @@ s32 Cutscene_Command_CameraFocus(GlobalContext* globalCtx, CutsceneContext* csCt
     size = 8;
 
     if ((cmdBase->startFrame < csCtx->frames) && (csCtx->frames < cmdBase->endFrame) &&
-        ((D_8015FCC0 < cmdBase->startFrame) || (D_8015FCC0 >= 0xF000)))
-    {
+        ((D_8015FCC0 < cmdBase->startFrame) || (D_8015FCC0 >= 0xF000))) {
         csCtx->unk_1A = 1;
         csCtx->cameraFocus = (CutsceneCameraPoint*)cmd;
-        if (csCtx->unk_1B != 0)
-        {
+        if (csCtx->unk_1B != 0) {
             D_8015FCC0 = cmdBase->startFrame;
-            if (D_8015FCC8 != 0)
-            {
+            if (D_8015FCC8 != 0) {
                 func_800C0874(globalCtx, csCtx->unk_16, 0x25);
                 func_800C0314(globalCtx, D_8015FCC6, 1);
                 func_800C0314(globalCtx, csCtx->unk_16, 7);
@@ -1432,10 +1349,10 @@ s32 Cutscene_Command_CameraFocus(GlobalContext* globalCtx, CutsceneContext* csCt
         }
     }
 
-    while (shouldContinue)
-    {
-        if (((CutsceneCameraPoint*)cmd)->continueFlag == -1)
-             shouldContinue = 0;
+    while (shouldContinue) {
+        if (((CutsceneCameraPoint*)cmd)->continueFlag == -1) {
+            shouldContinue = 0;
+        }
         cmd += 0x10;
         size += 0x10;
     }
@@ -1444,8 +1361,7 @@ s32 Cutscene_Command_CameraFocus(GlobalContext* globalCtx, CutsceneContext* csCt
 }
 
 // Command 0x7: ? (Related to camera positons)
-s32 Cutscene_Command_07(GlobalContext* globalCtx, CutsceneContext* csCtx, u8* cmd, u8 unused)
-{
+s32 Cutscene_Command_07(GlobalContext* globalCtx, CutsceneContext* csCtx, u8* cmd, u8 unused) {
     CsCmdBase* cmdBase = (CsCmdBase*)cmd;
     s32 size;
     Vec3f sp3C;
@@ -1457,15 +1373,12 @@ s32 Cutscene_Command_07(GlobalContext* globalCtx, CutsceneContext* csCtx, u8* cm
     size = 8;
 
     if ((cmdBase->startFrame < csCtx->frames) && (csCtx->frames < cmdBase->endFrame) &&
-        ((D_8015FCC2 < cmdBase->startFrame) || (D_8015FCC2 >= 0xF000)))
-    {
+        ((D_8015FCC2 < cmdBase->startFrame) || (D_8015FCC2 >= 0xF000))) {
         csCtx->unk_1B = 1;
         csCtx->cameraPosition = (CutsceneCameraPoint*)cmd;
-        if (csCtx->unk_1A != 0)
-        {
+        if (csCtx->unk_1A != 0) {
             D_8015FCC2 = cmdBase->startFrame;
-            if (D_8015FCC8 != 0)
-            {
+            if (D_8015FCC8 != 0) {
                 sp2C = func_800C04A4(globalCtx, csCtx->unk_16);
                 sp2C->player = NULL;
                 func_800C0314(globalCtx, 0, 1);
@@ -1491,8 +1404,7 @@ s32 Cutscene_Command_07(GlobalContext* globalCtx, CutsceneContext* csCtx, u8* cm
 }
 
 // Command 0x8: ? (Related to camera focus points)
-s32 Cutscene_Command_08(GlobalContext* globalCtx, CutsceneContext* csCtx, u8* cmd, u8 unused)
-{
+s32 Cutscene_Command_08(GlobalContext* globalCtx, CutsceneContext* csCtx, u8* cmd, u8 unused) {
     CsCmdBase* cmdBase = (CsCmdBase*)cmd;
     s32 size;
     Vec3f sp3C;
@@ -1504,15 +1416,12 @@ s32 Cutscene_Command_08(GlobalContext* globalCtx, CutsceneContext* csCtx, u8* cm
     size = 8;
 
     if ((cmdBase->startFrame < csCtx->frames) && (csCtx->frames < cmdBase->endFrame) &&
-        ((D_8015FCC4 < cmdBase->startFrame) || (D_8015FCC4 >= 0xF000)))
-    {
+        ((D_8015FCC4 < cmdBase->startFrame) || (D_8015FCC4 >= 0xF000))) {
         csCtx->unk_1A = 1;
         csCtx->cameraFocus = (CutsceneCameraPoint*)cmd;
-        if (csCtx->unk_1B != 0)
-        {
+        if (csCtx->unk_1B != 0) {
             D_8015FCC4 = cmdBase->startFrame;
-            if (D_8015FCC8 != 0)
-            {
+            if (D_8015FCC8 != 0) {
                 sp2C = func_800C04A4(globalCtx, csCtx->unk_16);
                 sp2C->player = NULL;
                 func_800C0314(globalCtx, 0, 1);
@@ -1536,81 +1445,70 @@ s32 Cutscene_Command_08(GlobalContext* globalCtx, CutsceneContext* csCtx, u8* cm
 }
 
 // Command 0x13: Textbox
-void Cutscene_Command_Textbox(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdTextbox* cmd)
-{
+void Cutscene_Command_Textbox(GlobalContext* globalCtx, CutsceneContext* csCtx, CsCmdTextbox* cmd) {
     u8 dialogState;
     s16 originalCsFrames;
 
-    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame))
-    {
-        if (cmd->type != 2)
-        {
-            if (D_8011E1C0 != cmd->base)
-            {
+    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame)) {
+        if (cmd->type != 2) {
+            if (D_8011E1C0 != cmd->base) {
                 D_8011E1C0 = cmd->base;
-                if ((cmd->type == 3) && (gBitFlags[20] & gSaveContext.quest_items))
+                if ((cmd->type == 3) && (gBitFlags[20] & gSaveContext.quest_items)) {
                     func_8010B680(globalCtx, cmd->textId1, 0);
-                else if ((cmd->type == 4) && (gBitFlags[19] & gSaveContext.quest_items))
+                } else if ((cmd->type == 4) && (gBitFlags[19] & gSaveContext.quest_items)) {
                     func_8010B680(globalCtx, cmd->textId1, 0);
-                else
+                } else {
                     func_8010B680(globalCtx, cmd->base, 0);
+                }
                 return;
             }
-        }
-        else
-        {
-            if (D_8011E1C4 != cmd->base)
-            {
+        } else {
+            if (D_8011E1C4 != cmd->base) {
                 D_8011E1C4 = cmd->base;
                 func_8010BD58(globalCtx, cmd->base);
                 return;
             }
         }
 
-        if (csCtx->frames >= cmd->endFrame)
-        {
+        if (csCtx->frames >= cmd->endFrame) {
             originalCsFrames = csCtx->frames;
             dialogState = func_8010BDBC(&globalCtx->msgCtx);
 
-            if ((dialogState != 2) && (dialogState != 0) && (dialogState != 7) && (dialogState != 8))
-            {
+            if ((dialogState != 2) && (dialogState != 0) && (dialogState != 7) && (dialogState != 8)) {
                 csCtx->frames--;
 
-                if ((dialogState == 4) && (func_80106BC8(globalCtx) != 0))
-                {
-                    if (globalCtx->msgCtx.choiceIndex == 0)
-                    {
-                        if (cmd->textId1 != 0xFFFF)
+                if ((dialogState == 4) && (func_80106BC8(globalCtx) != 0)) {
+                    if (globalCtx->msgCtx.choiceIndex == 0) {
+                        if (cmd->textId1 != 0xFFFF) {
                             func_8010B720(globalCtx, cmd->textId1);
-                        else
+                        } else {
                             csCtx->frames++;
-                    }
-                    else
-                    {
-                        if (cmd->textId2 != 0xFFFF)
+                        }
+                    } else {
+                        if (cmd->textId2 != 0xFFFF) {
                             func_8010B720(globalCtx, cmd->textId2);
-                        else
+                        } else {
                             csCtx->frames++;
+                        }
                     }
                 }
 
-                if (dialogState == 9)
-                {
-                    if (cmd->textId1 != 0xFFFF)
+                if (dialogState == 9) {
+                    if (cmd->textId1 != 0xFFFF) {
                         func_8010B720(globalCtx, cmd->textId1);
-                    else
+                    } else {
                         csCtx->frames++;
+                    }
                 }
 
-                if (dialogState == 5)
-                {
-                    if (func_80106BC8(globalCtx) != 0)
+                if (dialogState == 5) {
+                    if (func_80106BC8(globalCtx) != 0) {
                         func_8010BD58(globalCtx, cmd->base);
+                    }
                 }
             }
 
-            if (csCtx->frames == originalCsFrames)
-            {
+            if (csCtx->frames == originalCsFrames) {
                 Interface_ChangeAlpha(1);
                 D_8011E1C0 = 0;
                 D_8011E1C4 = 0;
@@ -1619,8 +1517,7 @@ void Cutscene_Command_Textbox(GlobalContext* globalCtx, CutsceneContext* csCtx,
     }
 }
 
-void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx, u8* cutscenePtr)
-{
+void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx, u8* cutscenePtr) {
     s16 i;
     s32 totalEntries;
     s32 cmdType;
@@ -1634,33 +1531,29 @@ void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx,
     MemCopy(&cutsceneEndFrame, cutscenePtr, 4);
     cutscenePtr += 4;
 
-    if ((cutsceneEndFrame < csCtx->frames) && (csCtx->state != CS_STATE_UNSKIPPABLE_EXEC))
-    {
+    if ((cutsceneEndFrame < csCtx->frames) && (csCtx->state != CS_STATE_UNSKIPPABLE_EXEC)) {
         csCtx->state = CS_STATE_UNSKIPPABLE_INIT;
         return;
     }
 
-    if (!~(globalCtx->state.input[0].padPressed | -0x101))
-    {
+    if (!~(globalCtx->state.input[0].padPressed | -0x101)) {
         csCtx->state = CS_STATE_UNSKIPPABLE_INIT;
         return;
     }
 
-    for (i = 0; i < totalEntries; i++)
-    {
+    for (i = 0; i < totalEntries; i++) {
         MemCopy(&cmdType, cutscenePtr, 4);
         cutscenePtr += 4;
 
-        if (cmdType == -1)
+        if (cmdType == -1) {
             return;
+        }
 
-        switch (cmdType)
-        {
+        switch (cmdType) {
             case CS_CMD_MISC:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     func_80064824(globalCtx, csCtx, (void*)cutscenePtr);
                     cutscenePtr += 0x30;
                 }
@@ -1668,8 +1561,7 @@ void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx,
             case CS_CMD_SET_LIGHTING:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     Cutscene_Command_SetLighting(globalCtx, csCtx, (void*)cutscenePtr);
                     cutscenePtr += 0x30;
                 }
@@ -1677,8 +1569,7 @@ void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx,
             case CS_CMD_PLAYBGM:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     Cutscene_Command_PlayBGM(globalCtx, csCtx, (void*)cutscenePtr);
                     cutscenePtr += 0x30;
                 }
@@ -1686,8 +1577,7 @@ void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx,
             case CS_CMD_STOPBGM:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     Cutscene_Command_StopBGM(globalCtx, csCtx, (void*)cutscenePtr);
                     cutscenePtr += 0x30;
                 }
@@ -1695,8 +1585,7 @@ void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx,
             case CS_CMD_FADEBGM:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     Cutscene_Command_FadeBGM(globalCtx, csCtx, (void*)cutscenePtr);
                     cutscenePtr += 0x30;
                 }
@@ -1704,8 +1593,7 @@ void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx,
             case CS_CMD_09:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     Cutscene_Command_09(globalCtx, csCtx, (void*)cutscenePtr);
                     cutscenePtr += 0xC;
                 }
@@ -1713,8 +1601,7 @@ void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx,
             case CS_CMD_SETTIME:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     func_80065134(globalCtx, csCtx, (void*)cutscenePtr);
                     cutscenePtr += 0xC;
                 }
@@ -1722,11 +1609,11 @@ void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx,
             case CS_CMD_SET_ACTOR_ACTION_0:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     cmd = (CsCmdBase*)cutscenePtr;
-                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame))
+                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame)) {
                         csCtx->linkAction = (void*)cutscenePtr;
+                    }
                     cutscenePtr += 0x30;
                 }
                 break;
@@ -1750,11 +1637,11 @@ void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx,
             case 144:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     cmd = (CsCmdBase*)cutscenePtr;
-                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame))
+                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame)) {
                         csCtx->actorActions[0] = (void*)cutscenePtr;
+                    }
                     cutscenePtr += 0x30;
                 }
                 break;
@@ -1778,11 +1665,11 @@ void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx,
             case 141:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     cmd = (CsCmdBase*)cutscenePtr;
-                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame))
+                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame)) {
                         csCtx->actorActions[1] = (void*)cutscenePtr;
+                    }
                     cutscenePtr += 0x30;
                 }
                 break;
@@ -1802,11 +1689,11 @@ void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx,
             case 132:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     cmd = (CsCmdBase*)cutscenePtr;
-                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame))
+                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame)) {
                         csCtx->actorActions[2] = (void*)cutscenePtr;
+                    }
                     cutscenePtr += 0x30;
                 }
                 break;
@@ -1825,11 +1712,11 @@ void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx,
             case 133:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     cmd = (CsCmdBase*)cutscenePtr;
-                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame))
+                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame)) {
                         csCtx->actorActions[3] = (void*)cutscenePtr;
+                    }
                     cutscenePtr += 0x30;
                 }
                 break;
@@ -1844,11 +1731,11 @@ void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx,
             case 135:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     cmd = (CsCmdBase*)cutscenePtr;
-                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame))
+                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame)) {
                         csCtx->actorActions[4] = (void*)cutscenePtr;
+                    }
                     cutscenePtr += 0x30;
                 }
                 break;
@@ -1861,11 +1748,11 @@ void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx,
             case 136:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     cmd = (CsCmdBase*)cutscenePtr;
-                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame))
+                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame)) {
                         csCtx->actorActions[5] = (void*)cutscenePtr;
+                    }
                     cutscenePtr += 0x30;
                 }
                 break;
@@ -1879,11 +1766,11 @@ void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx,
             case 137:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     cmd = (CsCmdBase*)cutscenePtr;
-                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame))
+                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame)) {
                         csCtx->actorActions[6] = (void*)cutscenePtr;
+                    }
                     cutscenePtr += 0x30;
                 }
                 break;
@@ -1896,33 +1783,33 @@ void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx,
             case 142:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     cmd = (CsCmdBase*)cutscenePtr;
-                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame))
+                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame)) {
                         csCtx->actorActions[7] = (void*)cutscenePtr;
+                    }
                     cutscenePtr += 0x30;
                 }
                 break;
             case 62:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     cmd = (CsCmdBase*)cutscenePtr;
-                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame))
+                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame)) {
                         csCtx->actorActions[8] = (void*)cutscenePtr;
+                    }
                     cutscenePtr += 0x30;
                 }
                 break;
             case CS_CMD_SET_ACTOR_ACTION_10:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     cmd = (CsCmdBase*)cutscenePtr;
-                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame))
+                    if ((cmd->startFrame < csCtx->frames) && (csCtx->frames <= cmd->endFrame)) {
                         csCtx->actorActions[9] = (void*)cutscenePtr;
+                    }
                     cutscenePtr += 0x30;
                 }
                 break;
@@ -1952,11 +1839,11 @@ void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx,
             case CS_CMD_TEXTBOX:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
-                {
+                for (j = 0; j < cmdEntries; j++) {
                     cmd = (CsCmdBase*)cutscenePtr;
-                    if (cmd->base != 0xFFFF)
+                    if (cmd->base != 0xFFFF) {
                         Cutscene_Command_Textbox(globalCtx, csCtx, (void*)cutscenePtr);
+                    }
                     cutscenePtr += 0xC;
                 }
                 break;
@@ -1968,79 +1855,73 @@ void Cutscene_ProcessCommands(GlobalContext* globalCtx, CutsceneContext* csCtx,
             default:
                 MemCopy(&cmdEntries, cutscenePtr, 4);
                 cutscenePtr += 4;
-                for (j = 0; j < cmdEntries; j++)
+                for (j = 0; j < cmdEntries; j++) {
                     cutscenePtr += 0x30;
+                }
                 break;
         }
     }
 }
 
-void func_80068C3C(GlobalContext* globalCtx, CutsceneContext* csCtx)
-{
+void func_80068C3C(GlobalContext* globalCtx, CutsceneContext* csCtx) {
     Gfx* displayList;
     Gfx* prevDisplayList;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    if (0) ; // Necessary to match
+    if (0) {} // Necessary to match
 
-    if (gSaveContext.cutscene_index >= 0xFFF0)
-    {
-        if (0) ; // Also necessary to match
+    if (gSaveContext.cutscene_index >= 0xFFF0) {
+        if (0) {} // Also necessary to match
 
-        if (BREG(0) != 0)
-        {
+        if (BREG(0) != 0) {
             gfxCtx = globalCtx->state.gfxCtx;
-            func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_demo.c", 4101);
+            Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_demo.c", 4101);
 
             prevDisplayList = gfxCtx->polyOpa.p;
-            displayList = func_800C6C20(gfxCtx->polyOpa.p);
+            displayList = Graph_GfxPlusOne(gfxCtx->polyOpa.p);
             gSPDisplayList(gfxCtx->overlay.p++, displayList);
             Cutscene_DrawDebugInfo(globalCtx, &displayList, csCtx);
             gSPEndDisplayList(displayList++);
-            func_800C6C28(prevDisplayList, displayList);
+            Graph_BranchDlist(prevDisplayList, displayList);
             gfxCtx->polyOpa.p = displayList;
 
-            func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_demo.c", 4108);
+            Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_demo.c", 4108);
         }
 
         csCtx->frames++;
-        if (dREG(95) != 0)
+        if (dREG(95) != 0) {
             Cutscene_ProcessCommands(globalCtx, csCtx, D_8012D1F0);
-        else
+        } else {
             Cutscene_ProcessCommands(globalCtx, csCtx, globalCtx->csCtx.segment);
+        }
     }
 }
 
-void func_80068D84(GlobalContext* globalCtx, CutsceneContext* csCtx)
-{
-    if (func_8006472C(globalCtx, csCtx, 0.0f))
-    {
+void func_80068D84(GlobalContext* globalCtx, CutsceneContext* csCtx) {
+    if (func_8006472C(globalCtx, csCtx, 0.0f)) {
         func_800F68BC(0);
         csCtx->state = CS_STATE_IDLE;
     }
 }
 
-void func_80068DC0(GlobalContext* globalCtx, CutsceneContext* csCtx)
-{
+void func_80068DC0(GlobalContext* globalCtx, CutsceneContext* csCtx) {
     s16 i;
 
-    if (func_8006472C(globalCtx, csCtx, 0.0f))
-    {
+    if (func_8006472C(globalCtx, csCtx, 0.0f)) {
         csCtx->linkAction = NULL;
 
-        for (i = 0; i < 10; i++)
+        for (i = 0; i < 10; i++) {
             csCtx->actorActions[i] = NULL;
+        }
 
         // Translates to: "RIGHT HERE, HUH"
         osSyncPrintf("\n\n\n\n\nやっぱりここかいな");
         gSaveContext.cutscene_index = 0;
         gSaveContext.game_mode = 0;
 
-        if (D_8015FCC8 != 0)
-        {
-            switch (gSaveContext.entrance_index)
-            {
+        if (D_8015FCC8 != 0) {
+            switch (gSaveContext.entrance_index) {
                 case 0x028A:
                 case 0x028E:
                 case 0x0292:
@@ -2058,15 +1939,14 @@ void func_80068DC0(GlobalContext* globalCtx, CutsceneContext* csCtx)
     }
 }
 
-void func_80068ECC(GlobalContext* globalCtx, CutsceneContext* csCtx)
-{
+void func_80068ECC(GlobalContext* globalCtx, CutsceneContext* csCtx) {
     u8 i;
 
-    if ((gSaveContext.cutscene_trigger != 0) && (csCtx->state == CS_STATE_IDLE) && !func_8008E988(globalCtx))
+    if ((gSaveContext.cutscene_trigger != 0) && (csCtx->state == CS_STATE_IDLE) && !func_8008E988(globalCtx)) {
         gSaveContext.cutscene_index = 0xFFFD;
+    }
 
-    if ((gSaveContext.cutscene_index >= 0xFFF0) && (csCtx->state == CS_STATE_IDLE))
-    {
+    if ((gSaveContext.cutscene_index >= 0xFFF0) && (csCtx->state == CS_STATE_IDLE)) {
         func_8006C438(globalCtx, 0);
 
         D_8011E1C0 = 0;
@@ -2074,13 +1954,13 @@ void func_80068ECC(GlobalContext* globalCtx, CutsceneContext* csCtx)
         csCtx->unk_12 = 0;
         csCtx->linkAction = NULL;
 
-        for (i = 0; i < 10; i++)
+        for (i = 0; i < 10; i++) {
             csCtx->actorActions[i] = NULL;
+        }
 
         csCtx->state++;
 
-        if (csCtx->state == CS_STATE_SKIPPABLE_INIT)
-        {
+        if (csCtx->state == CS_STATE_SKIPPABLE_INIT) {
             func_800F68BC(1);
 
             csCtx->frames = 0xFFFF;
@@ -2092,11 +1972,11 @@ void func_80068ECC(GlobalContext* globalCtx, CutsceneContext* csCtx)
             csCtx->unk_1B = 0;
             D_8015FCC6 = globalCtx->cameraCtx.unk_5C0;
 
-            if (D_8015FCC8 != 0)
+            if (D_8015FCC8 != 0) {
                 csCtx->unk_14_all = func_800C0230(globalCtx);
+            }
 
-            if (gSaveContext.cutscene_trigger == 0)
-            {
+            if (gSaveContext.cutscene_trigger == 0) {
                 Interface_ChangeAlpha(1);
                 func_800B3840(0x20);
                 func_800B38A4(0x20);
@@ -2110,41 +1990,39 @@ void func_80068ECC(GlobalContext* globalCtx, CutsceneContext* csCtx)
     }
 }
 
-void func_80069048(GlobalContext* globalCtx)
-{
+void func_80069048(GlobalContext* globalCtx) {
     s16 i;
 
     D_8015FCCC = 0;
-    for (i = 0; i < 20; i++) ; // Empty Loop
+    for (i = 0; i < 20; i++) {
+        ; // Empty Loop
+    }
     D_8015FCE4 = 0;
 }
 
-void func_8006907C(GlobalContext* globalCtx)
-{
-    if (D_8015FCCC != 0)
+void func_8006907C(GlobalContext* globalCtx) {
+    if (D_8015FCCC != 0) {
         D_8015FCCC = 0;
+    }
 }
 
-void Cutscene_HandleEntranceTriggers(GlobalContext* globalCtx)
-{
+void Cutscene_HandleEntranceTriggers(GlobalContext* globalCtx) {
     EntranceCutscene* entranceCutscene;
     u8 requiredAge;
     s16 i;
 
-    for (i = 0; i < ARRAY_COUNT(sEntranceCutsceneTable); i++)
-    {
+    for (i = 0; i < ARRAY_COUNT(sEntranceCutsceneTable); i++) {
         entranceCutscene = &sEntranceCutsceneTable[i];
 
         requiredAge = entranceCutscene->ageRestriction;
-        if (requiredAge == 2)
+        if (requiredAge == 2) {
             requiredAge = gSaveContext.link_age;
+        }
 
         if ((gSaveContext.entrance_index == entranceCutscene->entrance) &&
             (!Flags_GetEventChkInf(entranceCutscene->flag) || (entranceCutscene->flag == 0x18)) &&
-            (gSaveContext.cutscene_index < 0xFFF0) &&
-            ((u8)gSaveContext.link_age == requiredAge) &&
-            (gSaveContext.respawn_flag <= 0))
-        {
+            (gSaveContext.cutscene_index < 0xFFF0) && ((u8)gSaveContext.link_age == requiredAge) &&
+            (gSaveContext.respawn_flag <= 0)) {
             Flags_SetEventChkInf(entranceCutscene->flag);
             Cutscene_SetSegment(globalCtx, entranceCutscene->segAddr);
             gSaveContext.cutscene_trigger = 2;
@@ -2156,42 +2034,31 @@ void Cutscene_HandleEntranceTriggers(GlobalContext* globalCtx)
 
 #ifdef NON_MATCHING
 // regalloc differences
-void Cutscene_HandleConditionalTriggers(GlobalContext* globalCtx)
-{
+void Cutscene_HandleConditionalTriggers(GlobalContext* globalCtx) {
     osSyncPrintf("\ngame_info.mode=[%d] restart_flag", gSaveContext.respawn_flag);
 
-    if ((gSaveContext.game_mode == 0) && (gSaveContext.respawn_flag <= 0) && (gSaveContext.cutscene_index < 0xFFF0))
-    {
-        if ((gSaveContext.entrance_index == 0x01E1) && !Flags_GetEventChkInf(0xAC))
-        {
+    if ((gSaveContext.game_mode == 0) && (gSaveContext.respawn_flag <= 0) && (gSaveContext.cutscene_index < 0xFFF0)) {
+        if ((gSaveContext.entrance_index == 0x01E1) && !Flags_GetEventChkInf(0xAC)) {
             Flags_SetEventChkInf(0xAC);
             gSaveContext.entrance_index = 0x0123;
             gSaveContext.cutscene_index = 0xFFF0;
-        }
-        else if ((gSaveContext.entrance_index == 0x00DB) && LINK_IS_ADULT &&
-                 (gSaveContext.event_chk_inf[4] & 0x0100) && (gSaveContext.event_chk_inf[4] & 0x0200) &&
-                 (gSaveContext.event_chk_inf[4] & 0x0400) && !Flags_GetEventChkInf(0xAA))
-        {
+        } else if ((gSaveContext.entrance_index == 0x00DB) && LINK_IS_ADULT &&
+                   (gSaveContext.event_chk_inf[4] & 0x0100) && (gSaveContext.event_chk_inf[4] & 0x0200) &&
+                   (gSaveContext.event_chk_inf[4] & 0x0400) && !Flags_GetEventChkInf(0xAA)) {
             Flags_SetEventChkInf(0xAA);
             gSaveContext.cutscene_index = 0xFFF0;
-        }
-        else if ((gSaveContext.entrance_index == 0x05E0) && !Flags_GetEventChkInf(0xC1))
-        {
+        } else if ((gSaveContext.entrance_index == 0x05E0) && !Flags_GetEventChkInf(0xC1)) {
             Flags_SetEventChkInf(0xC1);
             Item_Give(globalCtx, ITEM_OCARINA_FAIRY);
             gSaveContext.entrance_index = 0x011E;
             gSaveContext.cutscene_index = 0xFFF0;
-        }
-        else if ((gBitFlags[3] & gSaveContext.quest_items) && (gBitFlags[4] & gSaveContext.quest_items) &&
-                 LINK_IS_ADULT && !Flags_GetEventChkInf(0xC4) &&
-                 (gEntranceTable[gSaveContext.entrance_index].scene == 67))
-        {
+        } else if ((gBitFlags[3] & gSaveContext.quest_items) && (gBitFlags[4] & gSaveContext.quest_items) &&
+                   LINK_IS_ADULT && !Flags_GetEventChkInf(0xC4) &&
+                   (gEntranceTable[gSaveContext.entrance_index].scene == 67)) {
             Flags_SetEventChkInf(0xC4);
             gSaveContext.entrance_index = 0x0053;
             gSaveContext.cutscene_index = 0xFFF8;
-        }
-        else if (!Flags_GetEventChkInf(0xC7) && (gEntranceTable[gSaveContext.entrance_index].scene == 79))
-        {
+        } else if (!Flags_GetEventChkInf(0xC7) && (gEntranceTable[gSaveContext.entrance_index].scene == 79)) {
             Flags_SetEventChkInf(0xC7);
             gSaveContext.entrance_index = 0x0517;
             gSaveContext.cutscene_index = 0xFFF0;
@@ -2202,10 +2069,10 @@ void Cutscene_HandleConditionalTriggers(GlobalContext* globalCtx)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_demo/Cutscene_HandleConditionalTriggers.s")
 #endif
 
-void Cutscene_SetSegment(GlobalContext* globalCtx, u32 segment)
-{
-    if (SEGMENT_NUMBER(segment) != 0)
+void Cutscene_SetSegment(GlobalContext* globalCtx, u32 segment) {
+    if (SEGMENT_NUMBER(segment) != 0) {
         globalCtx->csCtx.segment = SEGMENTED_TO_VIRTUAL(segment);
-    else
+    } else {
         globalCtx->csCtx.segment = (void*)segment;
+    }
 }
diff --git a/src/code/z_draw.c b/src/code/z_draw.c
index 9bc4bbd7a..ce07d2b36 100644
--- a/src/code/z_draw.c
+++ b/src/code/z_draw.c
@@ -29,15 +29,13 @@ static void func_8006B54C(GlobalContext* globalCtx, s16 drawId);
 static void func_8006B6E4(GlobalContext* globalCtx, s16 drawId);
 static void func_8006B870(GlobalContext* globalCtx, s16 drawId);
 
-typedef struct
-{
-    /* 0x00 */ void    (*drawFunc)(GlobalContext*, s16);
-    /* 0x04 */ u32     dlists[8];
+typedef struct {
+    /* 0x00 */ void (*drawFunc)(GlobalContext*, s16);
+    /* 0x04 */ u32 dlists[8];
 } DrawItemTableEntry; // size = 0x24
 
 // TODO: use symbols for these dlists once objects are in C
-static DrawItemTableEntry sDrawItemTable[] =
-{
+static DrawItemTableEntry sDrawItemTable[] = {
     { func_8006AAA8, { 0x06000670, 0x06000750 } },
     { func_8006A9CC, { 0x06000800 } },
     { func_8006ABEC, { 0x06000A80, 0x06000AE0 } },
@@ -71,8 +69,10 @@ static DrawItemTableEntry sDrawItemTable[] =
     { func_8006A9CC, { 0x06000EE0 } },
     { func_8006A9CC, { 0x060009A0 } },
     { func_8006A9CC, { 0x06000B70 } },
-    { func_8006B870, { 0x06001850, 0x06001750, 0x06001790, 0x060019A0, 0x060017B0, 0x06001A28, 0x060017D0, 0x06001AD8 } },
-    { func_8006B870, { 0x06001850, 0x06001770, 0x060017F0, 0x060019A0, 0x06001810, 0x06001A28, 0x06001830, 0x06001AD8 } },
+    { func_8006B870,
+      { 0x06001850, 0x06001750, 0x06001790, 0x060019A0, 0x060017B0, 0x06001A28, 0x060017D0, 0x06001AD8 } },
+    { func_8006B870,
+      { 0x06001850, 0x06001770, 0x060017F0, 0x060019A0, 0x06001810, 0x06001A28, 0x06001830, 0x06001AD8 } },
     { func_8006A9CC, { 0x06000F60 } },
     { func_8006A9CC, { 0x06000340 } },
     { func_8006A9CC, { 0x06000B90 } },
@@ -161,512 +161,526 @@ static DrawItemTableEntry sDrawItemTable[] =
  * Draw "Get Item" Model
  * Calls the corresponding draw function for the given draw ID
  */
-void func_800694A0(GlobalContext* globalCtx, s16 drawId)
-{
+void func_800694A0(GlobalContext* globalCtx, s16 drawId) {
     sDrawItemTable[drawId].drawFunc(globalCtx, drawId);
 }
 
 // All remaining functions in this file are draw functions referenced in the table and called by the function above
 
-static void func_800694E4(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_800694E4(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 556);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 556);
 
     func_80093BA8(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 560), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 560),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 565);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 565);
 }
 
-static void func_800695C0(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_800695C0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 572);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 572);
 
-    gfxCtx->polyXlu.p = func_80093774(gfxCtx->polyXlu.p, 5);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 576), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gfxCtx->polyXlu.p = Gfx_CallSetupDL(gfxCtx->polyXlu.p, 5);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 576),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[0]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 581);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 581);
 }
 
-static void func_8006969C(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006969C(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 588);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 588);
 
     func_80093D18(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 592), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 592),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
     func_80093D84(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0 * (globalCtx->state.frames * 0), 0 * (globalCtx->state.frames * 0), 16, 32,
-                                 1, 1 * (globalCtx->state.frames * 1), 1 * -(globalCtx->state.frames * 8), 16, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0 * (globalCtx->state.frames * 0),
+                                0 * (globalCtx->state.frames * 0), 16, 32, 1, 1 * (globalCtx->state.frames * 1),
+                                1 * -(globalCtx->state.frames * 8), 16, 32));
     Matrix_Push();
     Matrix_Translate(-8.0f, -2.0f, 0.0f, MTXMODE_APPLY);
     func_800D1FD4(&globalCtx->mf_11DA0);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 615), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 615),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
     Matrix_Pull();
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 621);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 621);
 }
 
-static void func_80069880(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_80069880(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 628);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 628);
 
     func_80093D18(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 632), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 632),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
     func_80093D84(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 641), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 641),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0 * (globalCtx->state.frames * 0), 0 * (globalCtx->state.frames * 0), 16, 32,
-                                 1, 1 * (globalCtx->state.frames * 1), 1 * -(globalCtx->state.frames * 6), 16, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0 * (globalCtx->state.frames * 0),
+                                0 * (globalCtx->state.frames * 0), 16, 32, 1, 1 * (globalCtx->state.frames * 1),
+                                1 * -(globalCtx->state.frames * 6), 16, 32));
     Matrix_Push();
     func_800D1FD4(&globalCtx->mf_11DA0);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 656), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 656),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[3]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
     Matrix_Pull();
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 663);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 663);
 }
 
-static void func_80069AC8(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_80069AC8(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 670);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 670);
 
     func_80093D18(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 674), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 674),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
     func_80093D84(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 683), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 683),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0 * (globalCtx->state.frames * 0), 0 * (globalCtx->state.frames * 0), 32, 32,
-                                 1, 1 * (globalCtx->state.frames * 1), 1 * -(globalCtx->state.frames * 6), 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0 * (globalCtx->state.frames * 0),
+                                0 * (globalCtx->state.frames * 0), 32, 32, 1, 1 * (globalCtx->state.frames * 1),
+                                1 * -(globalCtx->state.frames * 6), 32, 32));
     Matrix_Push();
     func_800D1FD4(&globalCtx->mf_11DA0);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 698), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 698),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
     Matrix_Pull();
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 704);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 704);
 }
 
-static void func_80069CF0(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_80069CF0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 712);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 712);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0 * (globalCtx->state.frames * 0) % 256, 1 * (globalCtx->state.frames * 2) % 256, 64, 64,
-                                 1, 0 * (globalCtx->state.frames * 0) % 128, 1 * (globalCtx->state.frames * 1) % 128, 32, 32));
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 723), G_MTX_MODELVIEW | G_MTX_LOAD);
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0 * (globalCtx->state.frames * 0) % 256,
+                                1 * (globalCtx->state.frames * 2) % 256, 64, 64, 1,
+                                0 * (globalCtx->state.frames * 0) % 128, 1 * (globalCtx->state.frames * 1) % 128, 32,
+                                32));
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 723),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
     func_80093D84(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 730), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 730),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
 
-
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 735);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 735);
 }
 
-static void func_80069EB0(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_80069EB0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 742);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 742);
 
     func_80093D18(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 746), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 746),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
     func_80093D84(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0 * (globalCtx->state.frames * 0), 1 * -(globalCtx->state.frames * 5), 32, 32,
-                                 1, 0 * (globalCtx->state.frames * 0), 0 * (globalCtx->state.frames * 0), 32, 64));
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 760), G_MTX_MODELVIEW | G_MTX_LOAD);
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0 * (globalCtx->state.frames * 0),
+                                1 * -(globalCtx->state.frames * 5), 32, 32, 1, 0 * (globalCtx->state.frames * 0),
+                                0 * (globalCtx->state.frames * 0), 32, 64));
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 760),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 765);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 765);
 }
 
-static void func_8006A060(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006A060(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 772);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 772);
 
     func_80093BA8(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 776), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 776),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[1]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 783);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 783);
 }
 
-static void func_8006A158(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006A158(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 811);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 811);
 
     func_80093D18(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 815), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 815),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
-    gfxCtx->polyXlu.p = func_80093774(gfxCtx->polyXlu.p, 5);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 822), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gfxCtx->polyXlu.p = Gfx_CallSetupDL(gfxCtx->polyXlu.p, 5);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 822),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 827);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 827);
 }
 
-static void func_8006A2A0(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006A2A0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 834);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 834);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, -1 * (globalCtx->state.frames * 1), 1 * (globalCtx->state.frames * 1), 32, 32,
-                                 1, -1 * (globalCtx->state.frames * 1), 1 * (globalCtx->state.frames * 1), 32, 32));
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 845), G_MTX_MODELVIEW | G_MTX_LOAD);
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, -1 * (globalCtx->state.frames * 1),
+                                1 * (globalCtx->state.frames * 1), 32, 32, 1, -1 * (globalCtx->state.frames * 1),
+                                1 * (globalCtx->state.frames * 1), 32, 32));
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 845),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[1]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[2]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[3]);
 
     func_80093D84(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 855), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 855),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[4]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[5]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 861);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 861);
 }
 
-static void func_8006A4B0(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006A4B0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 868);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 868);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 1 * (globalCtx->state.frames * 1), 0 * (globalCtx->state.frames * 1), 32, 32,
-                                 1, 0 * (globalCtx->state.frames * 1), 0 * (globalCtx->state.frames * 1), 32, 32));
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 878), G_MTX_MODELVIEW | G_MTX_LOAD);
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 1 * (globalCtx->state.frames * 1),
+                                0 * (globalCtx->state.frames * 1), 32, 32, 1, 0 * (globalCtx->state.frames * 1),
+                                0 * (globalCtx->state.frames * 1), 32, 32));
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 878),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 883);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 883);
 }
 
-static void func_8006A5F0(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006A5F0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 890);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 890);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 1 * (globalCtx->state.frames * 6), 1 * (globalCtx->state.frames * 6), 32, 32,
-                                 1, 1 * (globalCtx->state.frames * 6), 1 * (globalCtx->state.frames * 6), 32, 32));
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 901), G_MTX_MODELVIEW | G_MTX_LOAD);
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 1 * (globalCtx->state.frames * 6),
+                                1 * (globalCtx->state.frames * 6), 32, 32, 1, 1 * (globalCtx->state.frames * 6),
+                                1 * (globalCtx->state.frames * 6), 32, 32));
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 901),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 906);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 906);
 }
 
-static void func_8006A73C(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006A73C(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 913);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 913);
 
     func_80093D84(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0 * (globalCtx->state.frames * 1), 1 * -(globalCtx->state.frames * 3), 32, 32,
-                                 1, 0 * (globalCtx->state.frames * 1), 1 * -(globalCtx->state.frames * 2), 32, 32));
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 924), G_MTX_MODELVIEW | G_MTX_LOAD);
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0 * (globalCtx->state.frames * 1),
+                                1 * -(globalCtx->state.frames * 3), 32, 32, 1, 0 * (globalCtx->state.frames * 1),
+                                1 * -(globalCtx->state.frames * 2), 32, 32));
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 924),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[0]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 929);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 929);
 }
 
-static void func_8006A88C(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006A88C(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 936);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 936);
 
     func_80093D84(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0 * (globalCtx->state.frames * 0), 1 * (globalCtx->state.frames * 1), 32, 32,
-                                 1, 0 * (globalCtx->state.frames * 0), 1 * (globalCtx->state.frames * 1), 32, 32));
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 947), G_MTX_MODELVIEW | G_MTX_LOAD);
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0 * (globalCtx->state.frames * 0),
+                                1 * (globalCtx->state.frames * 1), 32, 32, 1, 0 * (globalCtx->state.frames * 0),
+                                1 * (globalCtx->state.frames * 1), 32, 32));
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 947),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[0]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 952);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 952);
 }
 
-static void func_8006A9CC(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006A9CC(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 959);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 959);
 
     func_80093D18(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 963), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 963),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 968);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 968);
 }
 
-static void func_8006AAA8(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006AAA8(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 975);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 975);
 
     func_80093D18(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 979), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 979),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
     func_80093D84(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 986), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 986),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 991);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 991);
 }
 
-static void func_8006ABEC(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006ABEC(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 998);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 998);
     func_80093D84(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1002), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1002),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[0]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1008);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1008);
 }
 
-static void func_8006ACE4(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006ACE4(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1015);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1015);
 
     func_80093D18(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1019), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1019),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[1]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
     func_80093D84(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1027), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1027),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1032);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1032);
 }
 
-static void func_8006AE40(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006AE40(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1039);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1039);
 
     func_80093D18(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1043), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1043),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
     func_80093D84(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1050), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1050),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1056);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1056);
 }
 
-static void func_8006AF9C(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006AF9C(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1063);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1063);
 
     func_80093D84(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 1 * (globalCtx->state.frames * 2), 1 * -(globalCtx->state.frames * 6), 32, 32,
-                                 1, 1 * (globalCtx->state.frames * 1), -1 * (globalCtx->state.frames * 2), 32, 32));
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1074), G_MTX_MODELVIEW | G_MTX_LOAD);
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 1 * (globalCtx->state.frames * 2),
+                                1 * -(globalCtx->state.frames * 6), 32, 32, 1, 1 * (globalCtx->state.frames * 1),
+                                -1 * (globalCtx->state.frames * 2), 32, 32));
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1074),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[0]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1081);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1081);
 }
 
-static void func_8006B124(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006B124(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1088);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1088);
 
     func_80093D18(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1092), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1092),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[1]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[2]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[3]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1100);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1100);
 }
 
-static void func_8006B24C(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006B24C(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1108);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1108);
 
     func_80093D18(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1112), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1112),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[1]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
     func_80093D84(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1120), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1120),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[3]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1126);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1126);
 }
 
-static void func_8006B3C0(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006B3C0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1133);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1133);
 
     Matrix_Scale(0.7f, 0.7f, 0.7f, MTXMODE_APPLY);
 
     func_80093D18(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1140), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1140),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[1]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
     func_80093D84(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1148), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1148),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[3]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1154);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1154);
 }
 
-static void func_8006B54C(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006B54C(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1162);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1162);
 
     func_80093D84(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 1 * (globalCtx->state.frames * 2), -1 * (globalCtx->state.frames * 2), 64, 64,
-                                 1, 1 * (globalCtx->state.frames * 4), 1 * -(globalCtx->state.frames * 4), 32, 32));
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1173), G_MTX_MODELVIEW | G_MTX_LOAD);
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 1 * (globalCtx->state.frames * 2),
+                                -1 * (globalCtx->state.frames * 2), 64, 64, 1, 1 * (globalCtx->state.frames * 4),
+                                1 * -(globalCtx->state.frames * 4), 32, 32));
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1173),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[3]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[0]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1181);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1181);
 }
 
-static void func_8006B6E4(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006B6E4(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1188);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1188);
 
     func_80093D18(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1192), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1192),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[1]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
     func_80093D84(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1200), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1200),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[3]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[4]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1207);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1207);
 }
 
-static void func_8006B870(GlobalContext* globalCtx, s16 drawId)
-{
+static void func_8006B870(GlobalContext* globalCtx, s16 drawId) {
     u32 pad;
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1214);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1214);
 
     func_80093D18(globalCtx->state.gfxCtx);
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1218), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1218),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[1]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[2]);
@@ -676,5 +690,5 @@ static void func_8006B870(GlobalContext* globalCtx, s16 drawId)
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[6]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[7]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1230);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1230);
 }
diff --git a/src/code/z_eff_blure.c b/src/code/z_eff_blure.c
index eb7b016dc..21f2bc75a 100644
--- a/src/code/z_eff_blure.c
+++ b/src/code/z_eff_blure.c
@@ -9,15 +9,14 @@
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_80020A50.s")
 
-void func_80020F60(u32 unused, GraphicsContext* gfxCtx)
-{
-    Gfx* gfxArr[5];
+void func_80020F60(u32 unused, GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, D_80135180, 809);
+    Graph_OpenDisps(dispRefs, gfxCtx, D_80135180, 809);
 
-    gfxCtx->polyXlu.p = func_80093774(gfxCtx->polyXlu.p, 0x26);
+    gfxCtx->polyXlu.p = Gfx_CallSetupDL(gfxCtx->polyXlu.p, 0x26);
 
-    func_800C6B54(gfxArr, gfxCtx, D_80135194, 813);
+    Graph_CloseDisps(dispRefs, gfxCtx, D_80135194, 813);
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_80020FC0.s")
@@ -29,4 +28,3 @@ void func_80020F60(u32 unused, GraphicsContext* gfxCtx)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_800224F4.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_80022A10.s")
-
diff --git a/src/code/z_eff_shield_particle.c b/src/code/z_eff_shield_particle.c
index fd85f4abb..d3f2591f8 100644
--- a/src/code/z_eff_shield_particle.c
+++ b/src/code/z_eff_shield_particle.c
@@ -8,4 +8,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_shield_particle/func_8002389C.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_shield_particle/func_800245BC.s")
-
diff --git a/src/code/z_eff_spark.c b/src/code/z_eff_spark.c
index f24a7f3ab..5f7c2a65f 100644
--- a/src/code/z_eff_spark.c
+++ b/src/code/z_eff_spark.c
@@ -3,12 +3,9 @@
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_spark/func_80024B00.s")
 
-void func_80024F0C(UNK_TYPE arg0)
-{
-
+void func_80024F0C(UNK_TYPE arg0) {
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_spark/func_80024F14.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_spark/func_80025000.s")
-
diff --git a/src/code/z_eff_ss_dead.c b/src/code/z_eff_ss_dead.c
index c3228d70b..f203e81e4 100644
--- a/src/code/z_eff_ss_dead.c
+++ b/src/code/z_eff_ss_dead.c
@@ -12,4 +12,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_ss_dead/func_80026860.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_ss_dead/func_80026A6C.s")
-
diff --git a/src/code/z_effect.c b/src/code/z_effect.c
new file mode 100644
index 000000000..dfe367d13
--- /dev/null
+++ b/src/code/z_effect.c
@@ -0,0 +1,26 @@
+#include <ultra64.h>
+#include <global.h>
+
+GlobalContext* func_80026B00(void) {
+    return D_80157DA0;
+}
+
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_effect/func_80026B0C.s")
+
+void func_80026C1C(u8* arg0) {
+    arg0[0] = 0;
+    arg0[1] = 0;
+    arg0[2] = 0;
+}
+
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_effect/func_80026C2C.s")
+
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_effect/Effect_Add.s")
+
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_effect/func_80026E74.s")
+
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_effect/func_80026F70.s")
+
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_effect/func_8002709C.s")
+
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_effect/func_800271A8.s")
diff --git a/src/code/z_effect_soft_sprite.c b/src/code/z_effect_soft_sprite.c
index 833994f81..34b264bf4 100644
--- a/src/code/z_effect_soft_sprite.c
+++ b/src/code/z_effect_soft_sprite.c
@@ -7,8 +7,7 @@ void Effect_SS_Delete(LoadedParticleEntry* particle);
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_effect_soft_sprite/func_800272B0.s")
 
-void Effect_SS_Clear(GlobalContext* globalCtx)
-{
+void Effect_SS_Clear(GlobalContext* globalCtx) {
     u32 i;
     LoadedParticleEntry* iter;
     ParticleOverlay* iter2;
@@ -18,35 +17,36 @@ void Effect_SS_Clear(GlobalContext* globalCtx)
     EffectSS2Info.searchIndex = 0;
     EffectSS2Info.size = 0;
 
-    for (iter = EffectSS2Info.data_table; iter < EffectSS2Info.data_table + EffectSS2Info.size; iter++)
+    for (iter = EffectSS2Info.data_table; iter < EffectSS2Info.data_table + EffectSS2Info.size; iter++) {
         Effect_SS_Delete(iter);
+    }
 
     // Free memory from loaded particle overlays
     iter2 = &sParticleOverlayTable[0];
-    for (i = 0; i < ARRAY_COUNT(sParticleOverlayTable); i++)
-    {
+    for (i = 0; i < ARRAY_COUNT(sParticleOverlayTable); i++) {
         addr = iter2->loadedRamAddr;
 
-        if (addr != NULL)
+        if (addr != NULL) {
             ZeldaArena_FreeDebug(addr, D_801357DC, 337);
+        }
 
         (iter2++)->loadedRamAddr = NULL;
     }
 }
 
-void Effect_SS_Delete(LoadedParticleEntry* particle)
-{
-    if (particle->flags & 2)
+void Effect_SS_Delete(LoadedParticleEntry* particle) {
+    if (particle->flags & 2) {
         func_800F89E8(particle);
+    }
 
-    if (particle->flags & 4)
+    if (particle->flags & 4) {
         func_800F89E8(&particle->unk_2C);
+    }
 
     Effect_SS_ResetEntry(particle);
 }
 
-void Effect_SS_ResetEntry(LoadedParticleEntry* particle)
-{
+void Effect_SS_ResetEntry(LoadedParticleEntry* particle) {
     u32 i;
 
     particle->type = 0x25;
@@ -70,8 +70,9 @@ void Effect_SS_ResetEntry(LoadedParticleEntry* particle)
     particle->unk_38 = 0;
     particle->unk_3C = 0;
 
-    for (i = 0; i != 13; i++)
+    for (i = 0; i != 13; i++) {
         particle->unk_40[i] = 0;
+    }
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_effect_soft_sprite/func_800275D0.s")
@@ -80,12 +81,10 @@ void Effect_SS_ResetEntry(LoadedParticleEntry* particle)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_effect_soft_sprite/func_80027798.s")
 
-void Effect_SS_UpdateParticle(GlobalContext* globalCtx, s32 index)
-{
+void Effect_SS_UpdateParticle(GlobalContext* globalCtx, s32 index) {
     LoadedParticleEntry* particle = &EffectSS2Info.data_table[index];
 
-    if (particle->update != NULL)
-    {
+    if (particle->update != NULL) {
         particle->velocity.x += particle->acceleration.x;
         particle->velocity.y += particle->acceleration.y;
         particle->velocity.z += particle->acceleration.z;
@@ -98,47 +97,43 @@ void Effect_SS_UpdateParticle(GlobalContext* globalCtx, s32 index)
     }
 }
 
-void Effect_SS_UpdateAllParticles(GlobalContext* globalCtx)
-{
+void Effect_SS_UpdateAllParticles(GlobalContext* globalCtx) {
     s32 i;
 
-    for (i = 0; i < EffectSS2Info.size; i++)
-    {
-        if (EffectSS2Info.data_table[i].life > -1)
-        {
+    for (i = 0; i < EffectSS2Info.size; i++) {
+        if (EffectSS2Info.data_table[i].life > -1) {
             EffectSS2Info.data_table[i].life--;
 
-            if (EffectSS2Info.data_table[i].life < 0)
+            if (EffectSS2Info.data_table[i].life < 0) {
                 Effect_SS_Delete(&EffectSS2Info.data_table[i]);
+            }
         }
 
-        if (EffectSS2Info.data_table[i].life > -1)
+        if (EffectSS2Info.data_table[i].life > -1) {
             Effect_SS_UpdateParticle(globalCtx, i);
+        }
     }
 }
 
-void Effect_SS_DrawParticle(GlobalContext* globalCtx, s32 index)
-{
+void Effect_SS_DrawParticle(GlobalContext* globalCtx, s32 index) {
     LoadedParticleEntry* particle = &EffectSS2Info.data_table[index];
 
-    if (particle->draw != NULL)
+    if (particle->draw != NULL) {
         particle->draw(globalCtx, index, particle);
+    }
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_effect_soft_sprite/func_80027BDC.s")
 
-s16 func_80027DD4(s16 arg0, s16 arg1, s32 arg2)
-{
-    s16 ret = !arg2 ? arg1 : (arg0 + (s32) ((f32) (arg1 - arg0) / arg2));
+s16 func_80027DD4(s16 arg0, s16 arg1, s32 arg2) {
+    s16 ret = !arg2 ? arg1 : (arg0 + (s32)((f32)(arg1 - arg0) / arg2));
     return ret;
 }
 
-s16 func_80027E34(s16 a0, s16 a1, f32 a2)
-{
+s16 func_80027E34(s16 a0, s16 a1, f32 a2) {
     return (a1 - a0) * a2 + a0;
 }
 
-u8 func_80027E84(u8 a0, u8 a1, f32 a2)
-{
+u8 func_80027E84(u8 a0, u8 a1, f32 a2) {
     return a2 * ((f32)a1 - (f32)a0) + a0;
 }
diff --git a/src/code/z_effect_soft_sprite_old_init.c b/src/code/z_effect_soft_sprite_old_init.c
index a385667ee..847e25e2f 100644
--- a/src/code/z_effect_soft_sprite_old_init.c
+++ b/src/code/z_effect_soft_sprite_old_init.c
@@ -164,4 +164,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_effect_soft_sprite_old_init/func_8002A9F4.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_effect_soft_sprite_old_init/func_8002AA44.s")
-
diff --git a/src/code/z_elf_message.c b/src/code/z_elf_message.c
index dabceae8c..ad7ae66c6 100644
--- a/src/code/z_elf_message.c
+++ b/src/code/z_elf_message.c
@@ -1,14 +1,172 @@
 #include <ultra64.h>
 #include <global.h>
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_elf_message/func_8006BBC0.s")
+// TODO: use macros to define elf messages once the format is fully documented
+ElfMessage sChildSariaMsgs[] = {
+    { 0x66, 0x00, 0x03, 0x00 }, { 0x00, 0x37, 0x61, 0x00 }, { 0xE0, 0x00, 0x64, 0x00 }, { 0x00, 0x25, 0x62, 0x00 },
+    { 0x00, 0x37, 0x63, 0x00 }, { 0x00, 0x43, 0x65, 0x00 }, { 0x06, 0x30, 0x66, 0x66 }, { 0x06, 0x30, 0x66, 0x67 },
+    { 0x06, 0x30, 0x66, 0x68 }, { 0x06, 0x20, 0x67, 0x65 }, { 0x06, 0x30, 0x68, 0x69 }, { 0x06, 0x30, 0x68, 0x6A },
+    { 0xE0, 0x00, 0x69, 0x00 },
+};
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_elf_message/func_8006BE88.s")
+ElfMessage sAdultSariaMsgs[] = {
+    { 0x06, 0x30, 0x6A, 0x66 }, { 0x06, 0x30, 0x6B, 0x67 }, { 0x06, 0x30, 0x6B, 0x68 },
+    { 0x06, 0x30, 0x6C, 0x69 }, { 0x06, 0x30, 0x6C, 0x6A }, { 0xE0, 0x00, 0x6D, 0x00 },
+};
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_elf_message/func_8006BF1C.s")
+#ifdef NON_MATCHING
+// minor ordering and regalloc differences
+u32 ElfMessage_CheckCondition(ElfMessage* msg) {
+    u16 temp;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_elf_message/func_8006C0FC.s")
+    switch (msg->byte0 & 0x1E) {
+        case 0:
+            temp = 1 << (msg->byte1 & 0x0F);
+            return ((msg->byte0 & 1) == 1) == !!(gSaveContext.event_chk_inf[(msg->byte1 & 0xF0) >> 4] & temp);
+        case 2:
+            return ((msg->byte0 & 1) == 1) ==
+                   !!(gBitFlags[msg->byte1 - ITEM_KEY_BOSS] & gSaveContext.dungeon_items[gSaveContext.dungeon_index]);
+        case 4:
+            return ((msg->byte0 & 1) == 1) == (msg->byte3 == INV_CONTENT(msg->byte1));
+        case 6:
+            switch (msg->byte1 & 0xF0) {
+                case 0x00:
+                    return ((msg->byte0 & 1) == 1) == ((msg->byte1 & 0x0F) == CUR_UPG_VALUE(UPG_STRENGTH));
+                case 0x10:
+                    return ((msg->byte0 & 1) == 1) ==
+                           !!((gBitFlags[msg->byte3 - ITEM_BOOTS_KOKIRI] << gEquipShifts[EQUIP_BOOTS]) &
+                              gSaveContext.equipment);
+                case 0x20:
+                    return ((msg->byte0 & 1) == 1) ==
+                           !!(gBitFlags[msg->byte3 - ITEM_SONG_MINUET + 6] & gSaveContext.quest_items);
+                case 0x30:
+                    return ((msg->byte0 & 1) == 1) ==
+                           !!(gBitFlags[msg->byte3 - ITEM_MEDALLION_FOREST] & gSaveContext.quest_items);
+                case 0x40:
+                    return ((msg->byte0 & 1) == 1) == !!gSaveContext.magic_acquired;
+            }
+    }
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_elf_message/func_8006C2B0.s")
+    // "Unplanned conditions"
+    LOG_STRING("企画外 条件", "../z_elf_message.c", 156);
+    __assert("0", "../z_elf_message.c", 157);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_elf_message/func_8006C318.s")
+    return false;
+}
+#else
+u32 ElfMessage_CheckCondition(ElfMessage* msg);
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_elf_message/ElfMessage_CheckCondition.s")
+#endif
+
+u32 func_8006BE88(ElfMessage** msgp) {
+    u32 temp = true;
+
+    while (((*msgp)->byte0 & 0xE0) == 0x20) {
+        if (!ElfMessage_CheckCondition(*msgp)) {
+            temp = false;
+        }
+        *msgp += 1;
+    }
+
+    if (temp) {
+        return ElfMessage_CheckCondition(*msgp);
+    } else {
+        return false;
+    }
+}
+
+u32 func_8006BF1C(ElfMessage** msgp) {
+    ElfMessage* msg;
+    u32 sp44[10];
+    s32 temp1;
+    s32 temp2;
+    s32 temp3;
+
+    msg = *msgp;
+    temp1 = 0;
+    temp2 = 0;
+    do {
+        sp44[temp2] = ElfMessage_CheckCondition(msg);
+        temp1 += sp44[temp2];
+        temp2++;
+        msg++;
+    } while ((msg->byte0 & 0xE0) == 0x40);
+
+    if (temp1 == 0) {
+        return false;
+    }
+
+    temp3 = Math_Rand_ZeroFloat(temp1);
+    for (temp1 = 0; temp1 < temp2; temp1++) {
+        if (sp44[temp1]) {
+            if (temp3 > 0) {
+                temp3--;
+            } else {
+                return true;
+            }
+        }
+        *msgp += 1;
+    }
+
+    return false;
+}
+
+u16 ElfMessage_GetTextFromMsgs(ElfMessage* msg) {
+    while (true) {
+        switch (msg->byte0 & 0xE0) {
+            case 0x00:
+                if (ElfMessage_CheckCondition(msg)) {
+                    return msg->byte2 | 0x100;
+                }
+                break;
+            case 0x20:
+                if (func_8006BE88(&msg)) {
+                    return msg->byte2 | 0x100;
+                }
+                break;
+            case 0x40:
+                if (func_8006BF1C(&msg)) {
+                    return msg->byte2 | 0x100;
+                }
+                break;
+            case 0x60:
+                if (ElfMessage_CheckCondition(msg)) {
+                    msg += msg->byte2;
+                    msg--;
+                }
+                break;
+            case 0xE0:
+                return msg->byte2 | 0x100;
+            default:
+                // "Unplanned conditions"
+                LOG_STRING("企画外 条件", "../z_elf_message.c", 281);
+                __assert("0", "../z_elf_message.c", 282);
+        }
+        msg++;
+    }
+}
+
+u16 ElfMessage_GetSariaText(GlobalContext* globalCtx) {
+    Player* player = PLAYER;
+    ElfMessage* msgs;
+
+    if (LINK_IS_CHILD) {
+        if (Actor_FindNearby(globalCtx, &player->actor, ACTOR_EN_SA, 4, 800.0f) == NULL) {
+            msgs = sChildSariaMsgs;
+        } else {
+            return 0x0160; // Special text about Saria preferring to talk to you face-to-face
+        }
+    } else {
+        msgs = sAdultSariaMsgs;
+    }
+
+    return ElfMessage_GetTextFromMsgs(msgs);
+}
+
+u16 ElfMessage_GetCUpText(GlobalContext* globalCtx) {
+    if (globalCtx->cUpElfMsgs == NULL) {
+        return 0;
+    } else {
+        return ElfMessage_GetTextFromMsgs(globalCtx->cUpElfMsgs);
+    }
+}
diff --git a/src/code/z_en_a_keep.c b/src/code/z_en_a_keep.c
index 02bc0a16e..84107e8a4 100644
--- a/src/code/z_en_a_keep.c
+++ b/src/code/z_en_a_keep.c
@@ -1,8 +1,7 @@
 #include <ultra64.h>
 #include <global.h>
 
-typedef enum
-{
+typedef enum {
     /* 0x00 */ A_OBJ_BLOCK_SMALL,
     /* 0x01 */ A_OBJ_BLOCK_LARGE,
     /* 0x02 */ A_OBJ_BLOCK_HUGE,
@@ -17,23 +16,22 @@ typedef enum
     /* 0x0B */ A_OBJ_KNOB
 } AObjType;
 
-typedef struct
-{
+typedef struct {
     /* 0x000 */ Actor actor;
-    /* 0x14C */ u32   dynaPolyId;
-    /* 0x150 */ f32   unk_150;
-    /* 0x154 */ f32   unk_154;
-    /* 0x158 */ s16   unk_158;
-    /* 0x15C */ u32   unk_15C;
-    /* 0x160 */ u8    unk_160;
+    /* 0x14C */ u32 dynaPolyId;
+    /* 0x150 */ f32 unk_150;
+    /* 0x154 */ f32 unk_154;
+    /* 0x158 */ s16 unk_158;
+    /* 0x15C */ u32 unk_15C;
+    /* 0x160 */ u8 unk_160;
     /* 0x164 */ ActorFunc updateFunc;
-    /* 0x168 */ s32   unk_168;
-    /* 0x16C */ s16   textId;
-    /* 0x16E */ s16   unk_16E;
-    /* 0x170 */ s16   unk_170;
-    /* 0x172 */ s16   unk_172;
-    /* 0x174 */ s16   unk_174;
-    /* 0x178 */ f32   unk_178;
+    /* 0x168 */ s32 unk_168;
+    /* 0x16C */ s16 textId;
+    /* 0x16E */ s16 unk_16E;
+    /* 0x170 */ s16 unk_170;
+    /* 0x172 */ s16 unk_172;
+    /* 0x174 */ s16 unk_174;
+    /* 0x178 */ f32 unk_178;
     /* 0x17C */ ColliderCylinderMain cylinderCollider;
 } ActorEnAObj; // size = 0x1C8
 
@@ -54,15 +52,13 @@ extern ColliderCylinderInit D_80115440;
 extern u32 D_8011546C[];
 extern u32 D_80115484[];
 
-void En_A_Obj_SetNewUpdate(ActorEnAObj* this, ActorFunc newUpdateFunc)
-{
+void En_A_Obj_SetNewUpdate(ActorEnAObj* this, ActorFunc newUpdateFunc) {
     this->updateFunc = newUpdateFunc;
 }
 
 #ifdef NON_MATCHING
 // minor ordering and regalloc differences
-void En_A_Obj_Init(ActorEnAObj* this, GlobalContext* globalCtx)
-{
+void En_A_Obj_Init(ActorEnAObj* this, GlobalContext* globalCtx) {
     u32 sp34;
     s16 type;
     s16 initialParams;
@@ -77,8 +73,7 @@ void En_A_Obj_Init(ActorEnAObj* this, GlobalContext* globalCtx)
     this->textId = (initialParams >> 8) & 0xFF;
     this->actor.params = type;
 
-    switch (type & 0xFFFF)
-    {
+    switch (type & 0xFFFF) {
         case A_OBJ_BLOCK_SMALL:
             Actor_SetScale(&this->actor, 0.025f);
             break;
@@ -99,8 +94,9 @@ void En_A_Obj_Init(ActorEnAObj* this, GlobalContext* globalCtx)
             break;
     }
 
-    if (this->actor.params >= 9)
+    if (this->actor.params >= 9) {
         sp28 = 12.0f;
+    }
 
     ActorShape_Init(&this->actor.shape, 0.0f, ActorShadow_DrawFunc_Circle, sp28);
 
@@ -112,8 +108,7 @@ void En_A_Obj_Init(ActorEnAObj* this, GlobalContext* globalCtx)
     params = this->actor.params;
     this->actor.posRot2.pos = this->actor.posRot.pos;
 
-    switch (params)
-    {
+    switch (params) {
         case A_OBJ_BLOCK_LARGE:
         case A_OBJ_BLOCK_HUGE:
             this->dynaPolyId = 1;
@@ -159,12 +154,12 @@ void En_A_Obj_Init(ActorEnAObj* this, GlobalContext* globalCtx)
             func_8001D234(this, params);
             break;
     }
-    
-    if (this->actor.params < 5)
+
+    if (this->actor.params < 5) {
         this->actor.sub_98.mass = 0xFF;
+    }
 
-    if (this->dynaPolyId != -1)
-    {
+    if (this->dynaPolyId != -1) {
         DynaPolyInfo_Alloc(D_8011546C[this->dynaPolyId], &sp34);
         this->dynaPolyId = DynaPolyInfo_RegisterActor(globalCtx, &globalCtx->colCtx.dyna, &this->actor, sp34);
     }
@@ -173,51 +168,44 @@ void En_A_Obj_Init(ActorEnAObj* this, GlobalContext* globalCtx)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_en_a_keep/En_A_Obj_Init.s")
 #endif
 
-void En_A_Obj_Destroy(ActorEnAObj* this, GlobalContext* globalCtx)
-{
+void En_A_Obj_Destroy(ActorEnAObj* this, GlobalContext* globalCtx) {
     ColliderCylinderMain* cylinderCollider = &this->cylinderCollider;
 
     DynaPolyInfo_Free(globalCtx, &globalCtx->colCtx.dyna, this->dynaPolyId);
 
-    switch (this->actor.params)
-    {
+    switch (this->actor.params) {
         case A_OBJ_SIGNPOST_OBLONG:
         case A_OBJ_SIGNPOST_ARROW:
             ActorCollider_FreeCylinder(globalCtx, cylinderCollider);
     }
 }
 
-void func_8001D204(ActorEnAObj* this, GlobalContext* globalCtx)
-{
-    if (func_8002F334(&this->actor, globalCtx))
+void func_8001D204(ActorEnAObj* this, GlobalContext* globalCtx) {
+    if (func_8002F334(&this->actor, globalCtx)) {
         func_8001D234(this, this->actor.params);
+    }
 }
 
-void func_8001D234(ActorEnAObj* this, s16 params)
-{
+void func_8001D234(ActorEnAObj* this, s16 params) {
     En_A_Obj_SetNewUpdate(this, (ActorFunc)func_8001D25C);
 }
 
-void func_8001D25C(ActorEnAObj* this, GlobalContext* globalCtx)
-{
+void func_8001D25C(ActorEnAObj* this, GlobalContext* globalCtx) {
     s16 var;
 
-    if (this->actor.textId != 0)
-    {
+    if (this->actor.textId != 0) {
         var = this->actor.rotTowardsLinkY - this->actor.shape.rot.y;
-        if ((ABS(var) < 0x2800) ||
-            ((this->actor.params == 0xA) && (ABS(var) > 0x5800)))
-        {
-            if (func_8002F194(&this->actor, globalCtx))
+        if ((ABS(var) < 0x2800) || ((this->actor.params == 0xA) && (ABS(var) > 0x5800))) {
+            if (func_8002F194(&this->actor, globalCtx)) {
                 En_A_Obj_SetNewUpdate(this, (ActorFunc)func_8001D204);
-            else
+            } else {
                 func_8002F2F4(&this->actor, globalCtx);
+            }
         }
     }
 }
 
-void func_8001D310(ActorEnAObj* this, s16 params)
-{
+void func_8001D310(ActorEnAObj* this, s16 params) {
     this->unk_16E = 0;
     this->unk_168 = 10;
     this->actor.posRot.rot.y = 0;
@@ -225,41 +213,34 @@ void func_8001D310(ActorEnAObj* this, s16 params)
     En_A_Obj_SetNewUpdate(this, (ActorFunc)func_8001D360);
 }
 
-void func_8001D360(ActorEnAObj* this, GlobalContext* globalCtx)
-{
-    if (this->unk_16E == 0)
-    {
-        if (this->unk_160 != 0)
-        {
+void func_8001D360(ActorEnAObj* this, GlobalContext* globalCtx) {
+    if (this->unk_16E == 0) {
+        if (this->unk_160 != 0) {
             this->unk_16E++;
             this->unk_170 = 20;
 
-            if ((s16)(this->actor.rotTowardsLinkY + 0x4000) < 0)
+            if ((s16)(this->actor.rotTowardsLinkY + 0x4000) < 0) {
                 this->unk_174 = -1000;
-            else
+            } else {
                 this->unk_174 = 1000;
+            }
 
-            if (this->actor.rotTowardsLinkY < 0)
+            if (this->actor.rotTowardsLinkY < 0) {
                 this->unk_172 = -this->unk_174;
-            else
+            } else {
                 this->unk_172 = this->unk_174;
+            }
         }
-    }
-    else
-    {
-        if (this->unk_168 != 0)
-        {
+    } else {
+        if (this->unk_168 != 0) {
             this->unk_168--;
-        }
-        else
-        {
+        } else {
             this->actor.shape.rot.y += this->unk_172;
             this->actor.shape.rot.x += this->unk_174;
             this->unk_170--;
             this->actor.gravity = -1.0f;
 
-            if (this->unk_170 == 0)
-            {
+            if (this->unk_170 == 0) {
                 this->actor.posRot.pos = this->actor.initPosRot.pos;
                 this->unk_16E = 0;
                 this->unk_168 = 10;
@@ -271,82 +252,74 @@ void func_8001D360(ActorEnAObj* this, GlobalContext* globalCtx)
     }
 }
 
-void func_8001D480(ActorEnAObj* this, s16 params)
-{
+void func_8001D480(ActorEnAObj* this, s16 params) {
     En_A_Obj_SetNewUpdate(this, (ActorFunc)func_8001D4A8);
 }
 
-void func_8001D4A8(ActorEnAObj* this, GlobalContext* globalCtx)
-{
+void func_8001D4A8(ActorEnAObj* this, GlobalContext* globalCtx) {
     Math_SmoothScaleMaxMinF(&this->actor.speedXZ, 1.0f, 1.0f, 0.5f, 0.0f);
     this->actor.shape.rot.x = this->actor.shape.rot.x + (this->actor.posRot.rot.x >> 1);
     this->actor.shape.rot.z = this->actor.shape.rot.z + (this->actor.posRot.rot.z >> 1);
 
-    if ((this->actor.speedXZ != 0.0f) && (this->actor.bgCheckFlags & 0x8))
-    {
-        if (1) // Necessary to match
+    if ((this->actor.speedXZ != 0.0f) && (this->actor.bgCheckFlags & 0x8)) {
+        if (1) { // Necessary to match
             this->actor.posRot.rot.y = ((this->actor.unk_7E - this->actor.posRot.rot.y) + this->actor.unk_7E) - 0x8000;
+        }
         this->actor.bgCheckFlags &= ~0x8;
     }
 
-    if (this->actor.bgCheckFlags & 0x2)
-    {
-        if (this->actor.velocity.y < -8.0f)
-        {
+    if (this->actor.bgCheckFlags & 0x2) {
+        if (this->actor.velocity.y < -8.0f) {
             this->actor.velocity.y *= -0.6f;
             this->actor.speedXZ *= 0.6f;
             this->actor.bgCheckFlags &= ~0x3;
-        }
-        else
+        } else {
             Actor_Kill(&this->actor);
+        }
     }
 }
 
-void func_8001D5C8(ActorEnAObj* this, s16 params)
-{
+void func_8001D5C8(ActorEnAObj* this, s16 params) {
     this->actor.unk_FC = 1200.0f;
     this->actor.unk_F8 = 720.0f;
     En_A_Obj_SetNewUpdate(this, (ActorFunc)func_8001D608);
 }
 
-void func_8001D608(ActorEnAObj* this, GlobalContext* globalCtx)
-{
+void func_8001D608(ActorEnAObj* this, GlobalContext* globalCtx) {
     this->actor.speedXZ += this->unk_150;
     this->actor.posRot.rot.y = this->unk_158;
 
-    this->actor.speedXZ = (this->actor.speedXZ < -2.5f) ? -2.5f :
-                          ((this->actor.speedXZ > 2.5f) ? 2.5f :
-                          this->actor.speedXZ);
+    this->actor.speedXZ =
+        (this->actor.speedXZ < -2.5f) ? -2.5f : ((this->actor.speedXZ > 2.5f) ? 2.5f : this->actor.speedXZ);
 
     Math_SmoothScaleMaxMinF(&this->actor.speedXZ, 0.0f, 1.0f, 1.0f, 0.0f);
 
-    if (this->actor.speedXZ != 0.0f)
+    if (this->actor.speedXZ != 0.0f) {
         Audio_PlayActorSound2(&this->actor, 0x200A);
+    }
 
     this->unk_154 = 0.0f;
     this->unk_150 = 0.0f;
 }
 
-void En_A_Obj_Update(ActorEnAObj* this, GlobalContext* globalCtx)
-{
+void En_A_Obj_Update(ActorEnAObj* this, GlobalContext* globalCtx) {
     ColliderCylinderMain* cylinderCollider;
 
     this->updateFunc(this, globalCtx);
     Actor_MoveForward(&this->actor);
 
-    if (this->actor.gravity != 0.0f)
-    {
-        if (this->actor.params != A_OBJ_KNOB)
+    if (this->actor.gravity != 0.0f) {
+        if (this->actor.params != A_OBJ_KNOB) {
             func_8002E4B4(globalCtx, &this->actor, 5.0f, 40.0f, 0.0f, 0x1D);
-        else
+        } else {
             func_8002E4B4(globalCtx, &this->actor, 5.0f, 20.0f, 0.0f, 0x1D);
+        }
     }
 
     this->actor.posRot2.pos = this->actor.posRot.pos;
     this->actor.posRot2.pos.y += this->unk_178;
 
-    switch (this->actor.params)
-    {
+    switch (this->actor.params) {
         case A_OBJ_SIGNPOST_OBLONG:
         case A_OBJ_SIGNPOST_ARROW:
             cylinderCollider = &this->cylinderCollider;
@@ -355,24 +328,26 @@ void En_A_Obj_Update(ActorEnAObj* this, GlobalContext* globalCtx)
     }
 }
 
-void En_A_Obj_Draw(ActorEnAObj* this, GlobalContext* globalCtx)
-{
+void En_A_Obj_Draw(ActorEnAObj* this, GlobalContext* globalCtx) {
     s32 type = this->actor.params;
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_en_a_keep.c", 701);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_a_keep.c", 701);
 
     func_80093D18(globalCtx->state.gfxCtx);
 
-    if (type > A_OBJ_KNOB)
+    if (type > A_OBJ_KNOB) {
         type = A_OBJ_KNOB;
+    }
 
-    if (this->actor.params == A_OBJ_KNOB)
+    if (this->actor.params == A_OBJ_KNOB) {
         gDPSetPrimColor(gfxCtx->polyOpa.p++, 0, 1, 0x3C, 0x3C, 0x3C, 0x32);
+    }
 
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_en_a_keep.c", 712), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_en_a_keep.c", 712),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, D_80115484[type]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_en_a_keep.c", 715);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_a_keep.c", 715);
 }
diff --git a/src/code/z_en_item00.c b/src/code/z_en_item00.c
index 3ce4c4b75..7d71802bb 100644
--- a/src/code/z_en_item00.c
+++ b/src/code/z_en_item00.c
@@ -1,8 +1,7 @@
 #include <ultra64.h>
 #include <global.h>
 
-typedef enum
-{
+typedef enum {
     /* 0x00 */ DROP_RUPEE_GREEN,
     /* 0x01 */ DROP_RUPEE_BLUE,
     /* 0x02 */ DROP_RUPEE_RED,
@@ -31,8 +30,7 @@ typedef enum
     /* 0x19 */ DROP_BOMBS_SPECIAL
 } DropType;
 
-typedef struct
-{
+typedef struct {
     /* 0x000 */ Actor actor;
     /* 0x14C */ ActorFunc updateFunc;
     /* 0x150 */ s16 collectibleFlag;
@@ -65,15 +63,13 @@ extern u8 D_80115664[];
 
 // Internal Actor Functions
 
-void En_Item00_SetNewUpdate(ActorEnItem00* this, ActorFunc newUpdateFunc)
-{
+void En_Item00_SetNewUpdate(ActorEnItem00* this, ActorFunc newUpdateFunc) {
     this->updateFunc = newUpdateFunc;
 }
 
 #ifdef NON_MATCHING
 // Very close to matching, just a single ordering issue
-void En_Item00_Init(ActorEnItem00* this, GlobalContext* globalCtx)
-{
+void En_Item00_Init(ActorEnItem00* this, GlobalContext* globalCtx) {
     s32 pad1;
     s32 pad2;
     f32 sp34;
@@ -91,8 +87,7 @@ void En_Item00_Init(ActorEnItem00* this, GlobalContext* globalCtx)
 
     this->actor.params = this->actor.params & 0x00FF;
 
-    if (Flags_GetCollectible(globalCtx, this->collectibleFlag))
-    {
+    if (Flags_GetCollectible(globalCtx, this->collectibleFlag)) {
         Actor_Kill(&this->actor);
         return;
     }
@@ -103,8 +98,7 @@ void En_Item00_Init(ActorEnItem00* this, GlobalContext* globalCtx)
 
     this->unk_158 = 1;
 
-    switch (this->actor.params)
-    {
+    switch (this->actor.params) {
         case DROP_RUPEE_GREEN:
         case DROP_RUPEE_BLUE:
         case DROP_RUPEE_RED:
@@ -216,8 +210,7 @@ void En_Item00_Init(ActorEnItem00* this, GlobalContext* globalCtx)
     this->unk_152 = 0;
 
     // MISMATCH: minor ordering issues here
-    if (!spawnParam8000)
-    {
+    if (!spawnParam8000) {
         En_Item00_SetNewUpdate(this, (ActorFunc)func_8001DFC8);
         this->unk_15A = -1;
         return;
@@ -230,8 +223,7 @@ void En_Item00_Init(ActorEnItem00* this, GlobalContext* globalCtx)
     this->actor.velocity.y = 0.0f;
     this->actor.gravity = 0.0f;
 
-    switch (this->actor.params)
-    {
+    switch (this->actor.params) {
         case DROP_RUPEE_GREEN:
             Item_Give(globalCtx, ITEM_RUPEE_GREEN);
             break;
@@ -297,8 +289,9 @@ void En_Item00_Init(ActorEnItem00* this, GlobalContext* globalCtx)
             break;
     }
 
-    if ((sp2C != 0) && !func_8002F410(&this->actor, globalCtx))
+    if ((sp2C != 0) && !func_8002F410(&this->actor, globalCtx)) {
         func_8002F554(&this->actor, globalCtx, sp2C);
+    }
 
     En_Item00_SetNewUpdate(this, (ActorFunc)func_8001E5C8);
     this->updateFunc(this, globalCtx);
@@ -307,147 +300,131 @@ void En_Item00_Init(ActorEnItem00* this, GlobalContext* globalCtx)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_en_item00/En_Item00_Init.s")
 #endif
 
-void En_Item00_Destroy(ActorEnItem00* this, GlobalContext* globalCtx)
-{
+void En_Item00_Destroy(ActorEnItem00* this, GlobalContext* globalCtx) {
     ColliderCylinderMain* cylinderCollider = &this->cylinderCollider;
     ActorCollider_FreeCylinder(globalCtx, cylinderCollider);
 }
 
-void func_8001DFC8(ActorEnItem00* this, GlobalContext* globalCtx)
-{
-    if ((this->actor.params <= DROP_RUPEE_RED) ||
-        ((this->actor.params == DROP_HEART) && (this->unk_15A < 0)) ||
-        (this->actor.params == DROP_HEART_PIECE))
-    {
+void func_8001DFC8(ActorEnItem00* this, GlobalContext* globalCtx) {
+    if ((this->actor.params <= DROP_RUPEE_RED) || ((this->actor.params == DROP_HEART) && (this->unk_15A < 0)) ||
+        (this->actor.params == DROP_HEART_PIECE)) {
         this->actor.shape.rot.y += 960;
-    }
-    else
-    {
-        if ((this->actor.params >= DROP_SHIELD_DEKU) && (this->actor.params != DROP_BOMBS_SPECIAL))
-        {
-            if (this->unk_15A == -1)
-            {
-                if (!Math_SmoothScaleMaxMinS(&this->actor.shape.rot.x, this->actor.posRot.rot.x - 0x4000, 2, 3000, 1500))
+    } else {
+        if ((this->actor.params >= DROP_SHIELD_DEKU) && (this->actor.params != DROP_BOMBS_SPECIAL)) {
+            if (this->unk_15A == -1) {
+                if (!Math_SmoothScaleMaxMinS(&this->actor.shape.rot.x, this->actor.posRot.rot.x - 0x4000, 2, 3000,
+                                             1500)) {
                     this->unk_15A = -2;
-            }
-            else
-            {
-                if (!Math_SmoothScaleMaxMinS(&this->actor.shape.rot.x, -this->actor.posRot.rot.x - 0x4000, 2, 3000, 1500))
+                }
+            } else {
+                if (!Math_SmoothScaleMaxMinS(&this->actor.shape.rot.x, -this->actor.posRot.rot.x - 0x4000, 2, 3000,
+                                             1500)) {
                     this->unk_15A = -1;
+                }
             }
             Math_SmoothScaleMaxMinS(&this->actor.posRot.rot.x, 0, 2, 2500, 500);
         }
     }
 
-    if (this->actor.params == DROP_HEART_PIECE)
+    if (this->actor.params == DROP_HEART_PIECE) {
         this->actor.shape.unk_08 = Math_Sins(this->actor.shape.rot.y) * 150.0f + 850.0f;
+    }
 
     Math_SmoothScaleMaxMinF(&this->actor.speedXZ, 0.0f, 1.0f, 0.5f, 0.0f);
 
-    if (this->unk_154 == 0)
-        if ((this->actor.params != DROP_SMALL_KEY) &&
-            (this->actor.params != DROP_HEART_PIECE) &&
-            (this->actor.params != DROP_HEART_CONTAINER))
-        {
+    if (this->unk_154 == 0) {
+        if ((this->actor.params != DROP_SMALL_KEY) && (this->actor.params != DROP_HEART_PIECE) &&
+            (this->actor.params != DROP_HEART_CONTAINER)) {
             this->unk_154 = -1;
         }
+    }
 
-    if (this->unk_15A == 0)
-        if ((this->actor.params != DROP_SMALL_KEY) &&
-            (this->actor.params != DROP_HEART_PIECE) &&
-            (this->actor.params != DROP_HEART_CONTAINER))
-        {
+    if (this->unk_15A == 0) {
+        if ((this->actor.params != DROP_SMALL_KEY) && (this->actor.params != DROP_HEART_PIECE) &&
+            (this->actor.params != DROP_HEART_CONTAINER)) {
             Actor_Kill(&this->actor);
         }
+    }
 
-    if ((this->actor.gravity != 0.0f) && !(this->actor.bgCheckFlags & 0x0001))
+    if ((this->actor.gravity != 0.0f) && !(this->actor.bgCheckFlags & 0x0001)) {
         En_Item00_SetNewUpdate(this, (ActorFunc)func_8001E1C8);
+    }
 }
 
-void func_8001E1C8(ActorEnItem00* this, GlobalContext* globalCtx)
-{
+void func_8001E1C8(ActorEnItem00* this, GlobalContext* globalCtx) {
     f32 originalVelocity;
     Vec3f pos;
 
-    if (this->actor.params <= DROP_RUPEE_RED)
+    if (this->actor.params <= DROP_RUPEE_RED) {
         this->actor.shape.rot.y += 960;
+    }
 
-    if (globalCtx->gameplayFrames & 1)
-    {
+    if (globalCtx->gameplayFrames & 1) {
         pos.x = this->actor.posRot.pos.x + Math_Rand_CenteredFloat(10.0f);
         pos.y = this->actor.posRot.pos.y + Math_Rand_CenteredFloat(10.0f);
         pos.z = this->actor.posRot.pos.z + Math_Rand_CenteredFloat(10.0f);
         func_80028B74(globalCtx, &pos, &D_80115518, &D_80115524, &D_80115510, &D_80115514);
     }
 
-    if (this->actor.bgCheckFlags & 0x0003)
-    {
+    if (this->actor.bgCheckFlags & 0x0003) {
         originalVelocity = this->actor.velocity.y;
-        if (originalVelocity > -2.0f)
-        {
+        if (originalVelocity > -2.0f) {
             En_Item00_SetNewUpdate(this, (ActorFunc)func_8001DFC8);
             this->actor.velocity.y = 0.0f;
-        }
-        else
-        {
+        } else {
             this->actor.velocity.y = originalVelocity * -0.8f;
             this->actor.bgCheckFlags = this->actor.bgCheckFlags & 0xFFFE;
         }
     }
 }
 
-void func_8001E304(ActorEnItem00* this, GlobalContext* globalCtx)
-{
+void func_8001E304(ActorEnItem00* this, GlobalContext* globalCtx) {
     s32 pad;
     Vec3f pos;
     s32 var1;
 
     this->unk_15A++;
 
-    if (this->actor.params == DROP_HEART)
-    {
-        if (this->actor.velocity.y < 0.0f)
-        {
+    if (this->actor.params == DROP_HEART) {
+        if (this->actor.velocity.y < 0.0f) {
             this->actor.speedXZ = 0.0f;
             this->actor.gravity = -0.4f;
-            if (this->actor.velocity.y < -1.5f)
+            if (this->actor.velocity.y < -1.5f) {
                 this->actor.velocity.y = -1.5f;
-            this->actor.initPosRot.rot.z += (s16) ((this->actor.velocity.y + 3.0f) * 1000.0f);
-            this->actor.posRot.pos.x += Math_Coss(this->actor.rotTowardsLinkY) * (-3.0f * Math_Coss(this->actor.initPosRot.rot.z));
-            this->actor.posRot.pos.z += Math_Sins(this->actor.rotTowardsLinkY) * (-3.0f * Math_Coss(this->actor.initPosRot.rot.z));
+            }
+            this->actor.initPosRot.rot.z += (s16)((this->actor.velocity.y + 3.0f) * 1000.0f);
+            this->actor.posRot.pos.x +=
+                Math_Coss(this->actor.rotTowardsLinkY) * (-3.0f * Math_Coss(this->actor.initPosRot.rot.z));
+            this->actor.posRot.pos.z +=
+                Math_Sins(this->actor.rotTowardsLinkY) * (-3.0f * Math_Coss(this->actor.initPosRot.rot.z));
         }
     }
 
-    if (this->actor.params <= DROP_RUPEE_RED)
-    {
+    if (this->actor.params <= DROP_RUPEE_RED) {
         this->actor.shape.rot.y += 960;
-    }
-    else if ((this->actor.params >= DROP_SHIELD_DEKU) && (this->actor.params != DROP_BOMBS_SPECIAL))
-    {
+    } else if ((this->actor.params >= DROP_SHIELD_DEKU) && (this->actor.params != DROP_BOMBS_SPECIAL)) {
         this->actor.posRot.rot.x -= 700;
         this->actor.shape.rot.y += 400;
         this->actor.shape.rot.x = this->actor.posRot.rot.x - 0x4000;
     }
 
-    if (this->actor.velocity.y <= 2.0f)
-    {
+    if (this->actor.velocity.y <= 2.0f) {
         var1 = (u16)this->actor.shape.rot.z + 10000;
-        if (var1 < 65535)
+        if (var1 < 65535) {
             this->actor.shape.rot.z += 10000;
-        else
+        } else {
             this->actor.shape.rot.z = -1;
+        }
     }
 
-    if (!(globalCtx->gameplayFrames & 1))
-    {
+    if (!(globalCtx->gameplayFrames & 1)) {
         pos.x = this->actor.posRot.pos.x + (Math_Rand_ZeroOne() - 0.5f) * 10.0f;
         pos.y = this->actor.posRot.pos.y + (Math_Rand_ZeroOne() - 0.5f) * 10.0f;
         pos.z = this->actor.posRot.pos.z + (Math_Rand_ZeroOne() - 0.5f) * 10.0f;
         func_80028B74(globalCtx, &pos, &D_80115518, &D_80115524, &D_80115510, &D_80115514);
     }
 
-    if (this->actor.bgCheckFlags & 0x0003)
-    {
+    if (this->actor.bgCheckFlags & 0x0003) {
         En_Item00_SetNewUpdate(this, (ActorFunc)func_8001DFC8);
         this->actor.shape.rot.z = 0;
         this->actor.velocity.y = 0.0f;
@@ -455,40 +432,36 @@ void func_8001E304(ActorEnItem00* this, GlobalContext* globalCtx)
     }
 }
 
-void func_8001E5C8(ActorEnItem00* this, GlobalContext* globalCtx)
-{
+void func_8001E5C8(ActorEnItem00* this, GlobalContext* globalCtx) {
     Player* player = PLAYER;
 
-    if (this->unk_152 != 0)
-    {
-        if (!func_8002F410(&this->actor, globalCtx))
-        {
+    if (this->unk_152 != 0) {
+        if (!func_8002F410(&this->actor, globalCtx)) {
             func_8002F434(&this->actor, globalCtx, this->unk_152, 50.0f, 80.0f);
             this->unk_15A++;
-        }
-        else
-        {
+        } else {
             this->unk_152 = 0;
         }
     }
 
-    if (this->unk_15A == 0)
-    {
+    if (this->unk_15A == 0) {
         Actor_Kill(&this->actor);
         return;
     }
 
     this->actor.posRot.pos = player->actor.posRot.pos;
 
-    if (this->actor.params <= DROP_RUPEE_RED)
+    if (this->actor.params <= DROP_RUPEE_RED) {
         this->actor.shape.rot.y += 960;
-    else if (this->actor.params == DROP_HEART)
+    } else if (this->actor.params == DROP_HEART) {
         this->actor.shape.rot.y = 0;
+    }
 
     this->actor.posRot.pos.y += 40.0f + Math_Sins(this->unk_15A * 15000) * (this->unk_15A * 0.3f);
 
-    if LINK_IS_ADULT
-        this->actor.posRot.pos.y += 20.0f;
+    if
+        LINK_IS_ADULT
+    this->actor.posRot.pos.y += 20.0f;
 }
 
 extern s32 D_80157D90;
@@ -497,8 +470,7 @@ extern s16 D_80157D94;
 
 #ifdef NON_MATCHING
 // Almost matching, just a few minor ordering issues
-void En_Item00_Update(ActorEnItem00* this, GlobalContext* globalCtx)
-{
+void En_Item00_Update(ActorEnItem00* this, GlobalContext* globalCtx) {
     s32 pad1;
     s32 pad2;
     s32 sp3C;
@@ -509,11 +481,13 @@ void En_Item00_Update(ActorEnItem00* this, GlobalContext* globalCtx)
     sp3C = 0;
     sp3A = 0;
 
-    if (this->unk_15A > 0)
+    if (this->unk_15A > 0) {
         this->unk_15A--;
+    }
 
-    if ((this->unk_15A > 0) && (this->unk_15A < 41) && (this->unk_154 <= 0))
+    if ((this->unk_15A > 0) && (this->unk_15A < 41) && (this->unk_154 <= 0)) {
         this->unk_156 = this->unk_15A;
+    }
 
     this->updateFunc(this, globalCtx);
 
@@ -521,44 +495,34 @@ void En_Item00_Update(ActorEnItem00* this, GlobalContext* globalCtx)
     this->actor.scale.z = this->actor.scale.x;
     this->actor.scale.y = this->actor.scale.x;
 
-    if (this->actor.gravity)
-    {
-        if (this->actor.bgCheckFlags & 0x0003)
-        {
+    if (this->actor.gravity) {
+        if (this->actor.bgCheckFlags & 0x0003) {
             // Separate symbols seem to be used here for 0x80157D90 since the loads and stores are completely separate
-            if (D_80157D90 != globalCtx->gameplayFrames)
-            {
+            if (D_80157D90 != globalCtx->gameplayFrames) {
                 D_80157D90_ = globalCtx->gameplayFrames;
                 D_80157D94 = 0;
-                for (i = 0; i < 50; i++)
-                {
-                    if (globalCtx->colCtx.dyna.flags[i] & 1)
-                    {
+                for (i = 0; i < 50; i++) {
+                    if (globalCtx->colCtx.dyna.flags[i] & 1) {
                         dynaActor = globalCtx->colCtx.dyna.actorMeshArr[i].actor;
                         if ((dynaActor != NULL) && (dynaActor->update != NULL) &&
                             ((dynaActor->posRot.pos.x != dynaActor->pos4.x) ||
                              (dynaActor->posRot.pos.y != dynaActor->pos4.y) ||
-                             (dynaActor->posRot.pos.z != dynaActor->pos4.z)))
-                        {
+                             (dynaActor->posRot.pos.z != dynaActor->pos4.z))) {
                             D_80157D94++;
                             break;
                         }
                     }
                 }
             }
-        }
-        else
-        {
+        } else {
             sp3A = 1;
             Actor_MoveForward(&this->actor);
         }
 
-        if (sp3A || D_80157D94)
-        {
+        if (sp3A || D_80157D94) {
             func_8002E4B4(globalCtx, &this->actor, 10.0f, 15.0f, 15.0f, 0x1D);
 
-            if (this->actor.unk_80 <= -10000.0f)
-            {
+            if (this->actor.unk_80 <= -10000.0f) {
                 Actor_Kill(&this->actor);
                 return;
             }
@@ -569,31 +533,33 @@ void En_Item00_Update(ActorEnItem00* this, GlobalContext* globalCtx)
     Actor_CollisionCheck_SetAC(globalCtx, &globalCtx->sub_11E60, &this->cylinderCollider);
 
     if ((this->actor.params == DROP_SHIELD_DEKU) || (this->actor.params == DROP_SHIELD_HYLIAN) ||
-        (this->actor.params == DROP_TUNIC_ZORA) || (this->actor.params == DROP_TUNIC_GORON))
-    {
+        (this->actor.params == DROP_TUNIC_ZORA) || (this->actor.params == DROP_TUNIC_GORON)) {
         f32 newUnkBC = Math_Coss(this->actor.shape.rot.x) * 37.0f;
         this->actor.shape.unk_08 = newUnkBC;
-        if (newUnkBC >= 0.0f)
+        if (newUnkBC >= 0.0f) {
             this->actor.shape.unk_08 = this->actor.shape.unk_08;
-        else
+        } else {
             this->actor.shape.unk_08 = -this->actor.shape.unk_08;
+        }
     }
 
-    if (this->unk_154 > 0)
+    if (this->unk_154 > 0) {
         return;
+    }
 
     // MISMATCH: The first function argument is loaded too early here
-    if (!((this->actor.xzDistanceFromLink <= 30.0f) &&
-          (this->actor.yDistanceFromLink >= -50.0f) &&
-          (this->actor.yDistanceFromLink <= 50.0f)))
-        if (!func_8002F410(&this->actor, globalCtx))
+    if (!((this->actor.xzDistanceFromLink <= 30.0f) && (this->actor.yDistanceFromLink >= -50.0f) &&
+          (this->actor.yDistanceFromLink <= 50.0f))) {
+        if (!func_8002F410(&this->actor, globalCtx)) {
             return;
+        }
+    }
 
-    if (globalCtx->unk_10A20 != 0)
+    if (globalCtx->unk_10A20 != 0) {
         return;
+    }
 
-    switch (this->actor.params)
-    {
+    switch (this->actor.params) {
         case DROP_RUPEE_GREEN:
             Item_Give(globalCtx, ITEM_RUPEE_GREEN);
             break;
@@ -672,11 +638,11 @@ void En_Item00_Update(ActorEnItem00* this, GlobalContext* globalCtx)
     }
 
     // MISMATCH: The first function argument is also loaded too early here
-    if ((sp3C != 0) && !func_8002F410(&this->actor, globalCtx))
+    if ((sp3C != 0) && !func_8002F410(&this->actor, globalCtx)) {
         func_8002F554(&this->actor, globalCtx, sp3C);
+    }
 
-    switch (this->actor.params)
-    {
+    switch (this->actor.params) {
         case DROP_HEART_PIECE:
         case DROP_HEART_CONTAINER:
         case DROP_SMALL_KEY:
@@ -684,29 +650,22 @@ void En_Item00_Update(ActorEnItem00* this, GlobalContext* globalCtx)
         case DROP_SHIELD_HYLIAN:
         case DROP_TUNIC_ZORA:
         case DROP_TUNIC_GORON:
-            if (func_8002F410(&this->actor, globalCtx))
-            {
+            if (func_8002F410(&this->actor, globalCtx)) {
                 Flags_SetCollectible(globalCtx, this->collectibleFlag);
                 Actor_Kill(&this->actor);
             }
             return;
     }
 
-    if ((this->actor.params <= DROP_RUPEE_RED) || (this->actor.params == DROP_RUPEE_ORANGE))
-    {
+    if ((this->actor.params <= DROP_RUPEE_RED) || (this->actor.params == DROP_RUPEE_ORANGE)) {
         Audio_PlaySoundGeneral(NA_SE_SY_GET_RUPY, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
-    }
-    else if (sp3C != 0)
-    {
-        if (func_8002F410(&this->actor, globalCtx))
-        {
+    } else if (sp3C != 0) {
+        if (func_8002F410(&this->actor, globalCtx)) {
             Flags_SetCollectible(globalCtx, this->collectibleFlag);
             Actor_Kill(&this->actor);
         }
         return;
-    }
-    else
-    {
+    } else {
         Audio_PlaySoundGeneral(NA_SE_SY_GET_ITEM, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
     }
 
@@ -734,15 +693,12 @@ void func_8001F080(ActorEnItem00* this, GlobalContext* globalCtx);
 void func_8001F1F4(ActorEnItem00* this, GlobalContext* globalCtx);
 void func_8001F334(ActorEnItem00* this, GlobalContext* globalCtx);
 
-void En_Item00_Draw(ActorEnItem00* this, GlobalContext* globalCtx)
-{
+void En_Item00_Draw(ActorEnItem00* this, GlobalContext* globalCtx) {
     s32 pad;
     f32 unkFloat;
 
-    if (!(this->unk_156 & this->unk_158))
-    {
-        switch (this->actor.params)
-        {
+    if (!(this->unk_156 & this->unk_158)) {
+        switch (this->actor.params) {
             case DROP_RUPEE_GREEN:
             case DROP_RUPEE_BLUE:
             case DROP_RUPEE_RED:
@@ -757,20 +713,15 @@ void En_Item00_Draw(ActorEnItem00* this, GlobalContext* globalCtx)
                 func_8001F1F4(this, globalCtx);
                 break;
             case DROP_HEART:
-                if (this->unk_15A < 0)
-                {
-                    if (this->unk_15A == -1)
-                    {
+                if (this->unk_15A < 0) {
+                    if (this->unk_15A == -1) {
                         s8 bankIndex = Object_GetIndex(&globalCtx->objectCtx, OBJECT_GI_HEART);
-                        if (Object_IsLoaded(&globalCtx->objectCtx, bankIndex))
-                        {
+                        if (Object_IsLoaded(&globalCtx->objectCtx, bankIndex)) {
                             this->actor.objBankIndex = bankIndex;
                             Actor_SetObjectDependency(globalCtx, &this->actor);
                             this->unk_15A = -2;
                         }
-                    }
-                    else
-                    {
+                    } else {
                         unkFloat = 16.0f;
                         Matrix_Scale(unkFloat, unkFloat, unkFloat, MTXMODE_APPLY);
                         func_800694A0(globalCtx, 0x08);
@@ -813,141 +764,144 @@ void En_Item00_Draw(ActorEnItem00* this, GlobalContext* globalCtx)
 /**
  * Draw Function used for Rupee types of En_Item00.
  */
-void func_8001EF30(ActorEnItem00* this, GlobalContext* globalCtx)
-{
+void func_8001EF30(ActorEnItem00* this, GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     s32 iconNb;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1546);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_item00.c", 1546);
 
     func_80093D18(globalCtx->state.gfxCtx);
     func_8002EBCC(&this->actor, globalCtx, 0);
 
-    if (1) // Necessary to match
-    {
-        if (this->actor.params <= DROP_RUPEE_RED)
+    if (1) { // Necessary to match
+        if (this->actor.params <= DROP_RUPEE_RED) {
             iconNb = this->actor.params;
-        else
+        } else {
             iconNb = this->actor.params - 0x10;
+        }
     }
 
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_en_item00.c", 1562), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_en_item00.c", 1562),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_80115530[iconNb]));
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &D_04042440);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1568);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_item00.c", 1568);
 }
 
 /**
  * Draw Function used for most collectible types of En_Item00 (ammo, bombs, sticks, nuts, magic...).
  */
-void func_8001F080(ActorEnItem00* this, GlobalContext* globalCtx)
-{
+void func_8001F080(ActorEnItem00* this, GlobalContext* globalCtx) {
     s32 iconNb;
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     iconNb = this->actor.params - 3;
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1594);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_item00.c", 1594);
 
     gfxCtx->polyOpa.p = func_800BC8A0(globalCtx, gfxCtx->polyOpa.p);
 
-    if (this->actor.params == DROP_BOMBS_SPECIAL)
+    if (this->actor.params == DROP_BOMBS_SPECIAL) {
         iconNb = 1;
-    else if (this->actor.params >= DROP_ARROWS_SMALL)
+    } else if (this->actor.params >= DROP_ARROWS_SMALL) {
         iconNb -= 3;
+    }
 
     gfxCtx->polyOpa.p = func_800946E4(gfxCtx->polyOpa.p);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_80115544[iconNb]));
 
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_en_item00.c", 1607), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_en_item00.c", 1607),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, &D_0403F070);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1611);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_item00.c", 1611);
 }
 
 /**
  * Draw Function used for the Heart Container type of En_Item00.
  */
-void func_8001F1F4(ActorEnItem00* this, GlobalContext* globalCtx)
-{
+void func_8001F1F4(ActorEnItem00* this, GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1623);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_item00.c", 1623);
 
     func_80093D18(globalCtx->state.gfxCtx);
     func_8002EBCC(&this->actor, globalCtx, 0);
-    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_en_item00.c", 1634), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_en_item00.c", 1634),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, &D_0403BBA0);
 
     func_80093D84(globalCtx->state.gfxCtx);
     func_8002ED80(&this->actor, globalCtx, 0);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_en_item00.c", 1644), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_en_item00.c", 1644),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, &D_0403BCD8);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1647);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_item00.c", 1647);
 }
 
 /**
  * Draw Function used for the Piece of Heart type of En_Item00.
  */
-void func_8001F334(ActorEnItem00* this, GlobalContext* globalCtx)
-{
+void func_8001F334(ActorEnItem00* this, GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1658);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_item00.c", 1658);
 
     func_80093D84(globalCtx->state.gfxCtx);
     func_8002ED80(&this->actor, globalCtx, 0);
-    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_en_item00.c", 1670), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_en_item00.c", 1670),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, &D_0403B030);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1673);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_item00.c", 1673);
 }
 
 /**
  * Converts a given drop type ID based on link's current age, health and owned items.
  * Returns a new drop type ID or -1 to cancel the drop.
  */
-s16 func_8001F404(s16 dropId)
-{
-    if (LINK_IS_ADULT)
-    {
-        if (dropId == DROP_SEEDS)
+s16 func_8001F404(s16 dropId) {
+    if (LINK_IS_ADULT) {
+        if (dropId == DROP_SEEDS) {
             dropId = DROP_ARROWS_SMALL;
-        else if (dropId == DROP_STICK)
+        } else if (dropId == DROP_STICK) {
             dropId = DROP_RUPEE_GREEN;
-    }
-    else
-    {
-        if (dropId == DROP_ARROWS_SMALL || dropId == DROP_ARROWS_MEDIUM || dropId == DROP_ARROWS_LARGE)
+        }
+    } else {
+        if (dropId == DROP_ARROWS_SMALL || dropId == DROP_ARROWS_MEDIUM || dropId == DROP_ARROWS_LARGE) {
             dropId = DROP_SEEDS;
+        }
     }
 
     // This is convoluted but it seems like it must be a single condition to match
+    // clang-format off
     if (((dropId == DROP_BOMBS_A      || dropId == DROP_BOMBS_SPECIAL || dropId == DROP_BOMBS_B)      && INV_CONTENT(ITEM_BOMB) == ITEM_NONE) ||
         ((dropId == DROP_ARROWS_SMALL || dropId == DROP_ARROWS_MEDIUM || dropId == DROP_ARROWS_LARGE) && INV_CONTENT(ITEM_BOW) == ITEM_NONE) ||
         ((dropId == DROP_MAGIC_LARGE  || dropId == DROP_MAGIC_SMALL)                                  && gSaveContext.magic_level == 0) ||
-        ((dropId == DROP_SEEDS)                                                                       && INV_CONTENT(ITEM_SLINGSHOT) == ITEM_NONE))
+        ((dropId == DROP_SEEDS)                                                                       && INV_CONTENT(ITEM_SLINGSHOT) == ITEM_NONE)) {
         return -1;
+    }
+    // clang-format on
 
-    if (dropId == DROP_HEART && gSaveContext.health_capacity == gSaveContext.health)
+    if (dropId == DROP_HEART && gSaveContext.health_capacity == gSaveContext.health) {
         return DROP_RUPEE_GREEN;
+    }
 
     return dropId;
 }
 
 // External functions used by other actors to drop collectibles, which usually results in spawning an En_Item00 actor.
 
-Actor* Item_DropCollectible(GlobalContext* globalCtx, Vec3f* spawnPos, s16 params)
-{
+Actor* Item_DropCollectible(GlobalContext* globalCtx, Vec3f* spawnPos, s16 params) {
     s32 pad[2];
     ActorEnItem00* spawnedActor = NULL;
     s16 param4000 = params & 0x4000;
@@ -956,26 +910,21 @@ Actor* Item_DropCollectible(GlobalContext* globalCtx, Vec3f* spawnPos, s16 param
 
     params = params & 0x3FFF;
 
-    if (((params & 0x00FF) == DROP_FLEXIBLE) && !param4000)
-    {
+    if (((params & 0x00FF) == DROP_FLEXIBLE) && !param4000) {
         // TODO: Prevent the cast to ActorEnItem00 here since this is a different actor (En_Elf)
-        spawnedActor = (ActorEnItem00*) Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_ELF,
-                                                    spawnPos->x, spawnPos->y + 40.0f, spawnPos->z,
-                                                    0, 0, 0, 0x0002);
+        spawnedActor = (ActorEnItem00*)Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_ELF, spawnPos->x,
+                                                   spawnPos->y + 40.0f, spawnPos->z, 0, 0, 0, 0x0002);
         func_8002A9F4(globalCtx, spawnPos, 0x28E7, 1, 1, 0x28);
-    }
-    else
-    {
-        if (!param8000)
+    } else {
+        if (!param8000) {
             params = func_8001F404(params & 0x00FF);
+        }
 
-        if (params != -1)
-        {
-            spawnedActor = (ActorEnItem00*) Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_ITEM00,
-                                                        spawnPos->x, spawnPos->y, spawnPos->z,
-                                                        0, 0, 0, params | param8000 | param3F00);
-            if ((spawnedActor != NULL) && !param8000)
-            {
+        if (params != -1) {
+            spawnedActor =
+                (ActorEnItem00*)Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_ITEM00, spawnPos->x, spawnPos->y,
+                                            spawnPos->z, 0, 0, 0, params | param8000 | param3F00);
+            if ((spawnedActor != NULL) && !param8000) {
                 spawnedActor->actor.velocity.y = !param4000 ? 8.0f : -2.0f;
                 spawnedActor->actor.speedXZ = 2.0f;
                 spawnedActor->actor.gravity = -0.9f;
@@ -985,8 +934,7 @@ Actor* Item_DropCollectible(GlobalContext* globalCtx, Vec3f* spawnPos, s16 param
                 spawnedActor->unk_15A = 220;
                 if ((spawnedActor->actor.params != DROP_SMALL_KEY) &&
                     (spawnedActor->actor.params != DROP_HEART_PIECE) &&
-                    (spawnedActor->actor.params != DROP_HEART_CONTAINER))
-                {
+                    (spawnedActor->actor.params != DROP_HEART_CONTAINER)) {
                     spawnedActor->actor.room = -1;
                 }
                 spawnedActor->actor.flags |= 0x0010;
@@ -994,11 +942,10 @@ Actor* Item_DropCollectible(GlobalContext* globalCtx, Vec3f* spawnPos, s16 param
         }
     }
 
-    return (Actor*) spawnedActor;
+    return (Actor*)spawnedActor;
 }
 
-Actor* Item_DropCollectible2(GlobalContext* globalCtx, Vec3f* spawnPos, s16 params)
-{
+Actor* Item_DropCollectible2(GlobalContext* globalCtx, Vec3f* spawnPos, s16 params) {
     ActorEnItem00* spawnedActor = NULL;
     s32 pad;
     s16 param4000 = params & 0x4000;
@@ -1007,24 +954,18 @@ Actor* Item_DropCollectible2(GlobalContext* globalCtx, Vec3f* spawnPos, s16 para
 
     params = params & 0x3FFF;
 
-    if (((params & 0x00FF) == DROP_FLEXIBLE) && !param4000)
-    {
+    if (((params & 0x00FF) == DROP_FLEXIBLE) && !param4000) {
         // TODO: Prevent the cast to ActorEnItem00 here since this is a different actor (En_Elf)
-        spawnedActor = (ActorEnItem00*) Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_ELF,
-                                                    spawnPos->x, spawnPos->y + 40.0f, spawnPos->z,
-                                                    0, 0, 0, 0x0002);
+        spawnedActor = (ActorEnItem00*)Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_ELF, spawnPos->x,
+                                                   spawnPos->y + 40.0f, spawnPos->z, 0, 0, 0, 0x0002);
         func_8002A9F4(globalCtx, spawnPos, 0x28E7, 1, 1, 0x28);
-    }
-    else
-    {
+    } else {
         params = func_8001F404(params & 0x00FF);
-        if (params != -1)
-        {
-            spawnedActor = (ActorEnItem00*) Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_ITEM00,
-                                                        spawnPos->x, spawnPos->y, spawnPos->z,
-                                                        0, 0, 0, params | param8000 | param3F00);
-            if ((spawnedActor != NULL) && !param8000)
-            {
+        if (params != -1) {
+            spawnedActor =
+                (ActorEnItem00*)Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_ITEM00, spawnPos->x, spawnPos->y,
+                                            spawnPos->z, 0, 0, 0, params | param8000 | param3F00);
+            if ((spawnedActor != NULL) && !param8000) {
                 spawnedActor->actor.velocity.y = 0.0f;
                 spawnedActor->actor.speedXZ = 0.0f;
                 spawnedActor->actor.gravity = param4000 ? 0.0f : -0.9f;
@@ -1034,11 +975,10 @@ Actor* Item_DropCollectible2(GlobalContext* globalCtx, Vec3f* spawnPos, s16 para
         }
     }
 
-    return (Actor*) spawnedActor;
+    return (Actor*)spawnedActor;
 }
 
-void Item_DropCollectibleRandom(GlobalContext* globalCtx, Actor* fromActor, Vec3f* spawnPos, s16 params)
-{
+void Item_DropCollectibleRandom(GlobalContext* globalCtx, Actor* fromActor, Vec3f* spawnPos, s16 params) {
     s32 pad;
     ActorEnItem00* spawnedActor;
     s16 dropQuantity;
@@ -1050,133 +990,93 @@ void Item_DropCollectibleRandom(GlobalContext* globalCtx, Actor* fromActor, Vec3
     param8000 = params & 0x8000;
     params = params & 0x7FFF;
 
-    if (fromActor != NULL)
-    {
-        if (fromActor->unk_116)
-        {
-            if (fromActor->unk_116 & 0x01)
-            {
+    if (fromActor != NULL) {
+        if (fromActor->unk_116) {
+            if (fromActor->unk_116 & 0x01) {
                 params = 1 * 0x10;
                 dropTableIndex = 0xB;
-            }
-            else if (fromActor->unk_116 & 0x02)
-            {
+            } else if (fromActor->unk_116 & 0x02) {
                 params = 1 * 0x10;
                 dropTableIndex = 0x6;
-            }
-            else if (fromActor->unk_116 & 0x04)
-            {
+            } else if (fromActor->unk_116 & 0x04) {
                 params = 6 * 0x10;
                 dropTableIndex = 0x9;
-            }
-            else if (fromActor->unk_116 & 0x08)
-            {
+            } else if (fromActor->unk_116 & 0x08) {
                 params = 3 * 0x10;
                 dropTableIndex = 0xB;
-            }
-            else if (fromActor->unk_116 & 0x10)
-            {
+            } else if (fromActor->unk_116 & 0x10) {
                 params = 6 * 0x10;
                 dropTableIndex = 0xC;
-            }
-            else if (fromActor->unk_116 & 0x20)
-            {
+            } else if (fromActor->unk_116 & 0x20) {
                 params = 0 * 0x10;
                 dropTableIndex = 0x0;
-            }
-            else if (fromActor->unk_116 & 0x40)
-            {
+            } else if (fromActor->unk_116 & 0x40) {
                 params = 0 * 0x10;
                 dropTableIndex = 0x1;
             }
         }
-        if (fromActor->unk_116 & 0x20)
+        if (fromActor->unk_116 & 0x20) {
             dropId = DROP_RUPEE_PURPLE;
-        else
+        } else {
             dropId = D_80115574[params + dropTableIndex];
-    }
-    else
+        }
+    } else {
         dropId = D_80115574[params + dropTableIndex];
+    }
 
-    if (dropId == DROP_FLEXIBLE)
-    {
-        if (gSaveContext.health <= 0x10) // 1 heart or less
-        {
-            Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_ELF,
-                        spawnPos->x, spawnPos->y + 40.0f, spawnPos->z,
-                        0, 0, 0, 0x0002);
+    if (dropId == DROP_FLEXIBLE) {
+        if (gSaveContext.health <= 0x10) { // 1 heart or less
+            Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_ELF, spawnPos->x, spawnPos->y + 40.0f, spawnPos->z, 0,
+                        0, 0, 0x0002);
             func_8002A9F4(globalCtx, spawnPos, 0x28E7, 1, 1, 0x28);
             return;
-        }
-        else if (gSaveContext.health <= 0x30) // 3 hearts or less
-        {
+        } else if (gSaveContext.health <= 0x30) { // 3 hearts or less
             params = 0xB * 0x10;
             dropTableIndex = 0x0;
             dropId = DROP_HEART;
-        }
-        else if (gSaveContext.health <= 0x50) // 5 hearts or less
-        {
+        } else if (gSaveContext.health <= 0x50) { // 5 hearts or less
             params = 0xA * 0x10;
             dropTableIndex = 0x0;
             dropId = DROP_HEART;
-        }
-        else if ((gSaveContext.magic_level != 0) && (gSaveContext.magic == 0)) // Empty magic meter
-        {
+        } else if ((gSaveContext.magic_level != 0) && (gSaveContext.magic == 0)) { // Empty magic meter
             params = 0xA * 0x10;
             dropTableIndex = 0x0;
             dropId = DROP_MAGIC_LARGE;
-        }
-        else if ((gSaveContext.magic_level != 0) && (gSaveContext.magic <= (gSaveContext.magic_level >> 1))) // Half magic or less
-        {
+        } else if ((gSaveContext.magic_level != 0) &&
+                   (gSaveContext.magic <= (gSaveContext.magic_level >> 1))) { // Half magic or less
             params = 0xA * 0x10;
             dropTableIndex = 0x0;
             dropId = DROP_MAGIC_SMALL;
-        }
-        else if (LINK_IS_CHILD && (AMMO(ITEM_SLINGSHOT) < 6)) // Child and less then 6 deku seeds
-        {
+        } else if (LINK_IS_CHILD && (AMMO(ITEM_SLINGSHOT) < 6)) { // Child and less then 6 deku seeds
             params = 0xA * 0x10;
             dropTableIndex = 0x0;
             dropId = DROP_SEEDS;
-        }
-        else if (LINK_IS_ADULT && (AMMO(ITEM_BOW) < 6)) // Adult and less than 6 arrows
-        {
+        } else if (LINK_IS_ADULT && (AMMO(ITEM_BOW) < 6)) { // Adult and less than 6 arrows
             params = 0xA * 0x10;
             dropTableIndex = 0x0;
             dropId = DROP_ARROWS_MEDIUM;
-        }
-        else if (AMMO(ITEM_BOMB) < 6) // Less than 6 bombs
-        {
+        } else if (AMMO(ITEM_BOMB) < 6) { // Less than 6 bombs
             params = 0xD * 0x10;
             dropTableIndex = 0x0;
             dropId = DROP_BOMBS_A;
-        }
-        else if (gSaveContext.rupees < 11) // Less than 11 Rupees
-        {
+        } else if (gSaveContext.rupees < 11) { // Less than 11 Rupees
             params = 0xA * 0x10;
             dropTableIndex = 0x0;
             dropId = DROP_RUPEE_RED;
-        }
-        else
-        {
+        } else {
             return;
         }
     }
 
-    if (dropId != 0xFF)
-    {
+    if (dropId != 0xFF) {
         dropQuantity = D_80115664[params + dropTableIndex];
-        while (dropQuantity > 0)
-        {
-            if (!param8000)
-            {
+        while (dropQuantity > 0) {
+            if (!param8000) {
                 dropId = func_8001F404(dropId);
-                if (dropId != 0xFF)
-                {
-                    spawnedActor = (ActorEnItem00*) Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_ITEM00,
-                                                                spawnPos->x, spawnPos->y, spawnPos->z,
-                                                                0, 0, 0, dropId);
-                    if ((spawnedActor != NULL) && (dropId != 0xFF))
-                    {
+                if (dropId != 0xFF) {
+                    spawnedActor = (ActorEnItem00*)Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_ITEM00,
+                                                               spawnPos->x, spawnPos->y, spawnPos->z, 0, 0, 0, dropId);
+                    if ((spawnedActor != NULL) && (dropId != 0xFF)) {
                         spawnedActor->actor.velocity.y = 8.0f;
                         spawnedActor->actor.speedXZ = 2.0f;
                         spawnedActor->actor.gravity = -0.9f;
@@ -1186,16 +1086,13 @@ void Item_DropCollectibleRandom(GlobalContext* globalCtx, Actor* fromActor, Vec3
                         spawnedActor->actor.flags |= 0x0010;
                         if ((spawnedActor->actor.params != DROP_SMALL_KEY) &&
                             (spawnedActor->actor.params != DROP_HEART_PIECE) &&
-                            (spawnedActor->actor.params != DROP_HEART_CONTAINER))
-                        {
+                            (spawnedActor->actor.params != DROP_HEART_CONTAINER)) {
                             spawnedActor->actor.room = -1;
                         }
                         spawnedActor->unk_15A = 220;
                     }
                 }
-            }
-            else
-            {
+            } else {
                 Item_DropCollectible(globalCtx, spawnPos, params | 0x8000);
             }
             dropQuantity--;
diff --git a/src/code/z_face_reaction.c b/src/code/z_face_reaction.c
new file mode 100644
index 000000000..1bfe18b7c
--- /dev/null
+++ b/src/code/z_face_reaction.c
@@ -0,0 +1,70 @@
+#include <ultra64.h>
+#include <global.h>
+
+u16 sReactionTextIds[60][9] = {
+    { 0x0000, 0x7124, 0x7127, 0x7126, 0x7125, 0x7127, 0x7124, 0x7125, 0x7127 },
+    { 0x0000, 0x7128, 0x7129, 0x7128, 0x7128, 0x7128, 0x7128, 0x712A, 0x712B },
+    { 0x0000, 0x7128, 0x712B, 0x7128, 0x7128, 0x7129, 0x7128, 0x712B, 0x7128 },
+    { 0x0000, 0x7128, 0x7129, 0x7128, 0x7128, 0x7128, 0x7128, 0x712A, 0x712B },
+    { 0x0000, 0x7128, 0x7129, 0x712B, 0x7128, 0x7128, 0x7128, 0x7129, 0x7128 },
+    { 0x0000, 0x712D, 0x712D, 0x712D, 0x712D, 0x712D, 0x712D, 0x712D, 0x712F },
+    { 0x0000, 0x712C, 0x712C, 0x712C, 0x712E, 0x712C, 0x712C, 0x712F, 0x712F },
+    { 0x0000, 0x712C, 0x712C, 0x712C, 0x712F, 0x712C, 0x712C, 0x712F, 0x712F },
+    { 0x0000, 0x7130, 0x7132, 0x7133, 0x7130, 0x7130, 0x7131, 0x7132, 0x7131 },
+    { 0x0000, 0x7134, 0x7137, 0x7135, 0x7134, 0x7136, 0x7135, 0x7134, 0x7135 },
+    { 0x0000, 0x7138, 0x713A, 0x7138, 0x7139, 0x713A, 0x7138, 0x7139, 0x713B },
+    { 0x0000, 0x7144, 0x7146, 0x7144, 0x7146, 0x7147, 0x7145, 0x7145, 0x7147 },
+    { 0x0000, 0x7148, 0x7149, 0x7149, 0x714A, 0x714A, 0x714B, 0x7149, 0x714B },
+    { 0x0000, 0x714C, 0x714D, 0x714C, 0x714C, 0x714E, 0x714C, 0x714E, 0x714F },
+    { 0x0000, 0x7150, 0x7153, 0x7152, 0x7150, 0x7151, 0x7153, 0x7153, 0x7151 },
+    { 0x0000, 0x7155, 0x7156, 0x7157, 0x7154, 0x7156, 0x7156, 0x7156, 0x7156 },
+    { 0x0000, 0x715A, 0x7159, 0x715B, 0x715A, 0x715A, 0x7158, 0x7158, 0x715B },
+    { 0x0000, 0x715E, 0x715D, 0x715D, 0x715F, 0x715E, 0x715C, 0x715C, 0x715D },
+    { 0x0000, 0x7163, 0x7162, 0x7160, 0x7163, 0x7160, 0x7161, 0x7161, 0x7160 },
+    { 0x0000, 0x7164, 0x7166, 0x7164, 0x7167, 0x7164, 0x7164, 0x7164, 0x7167 },
+    { 0x0000, 0x716B, 0x7169, 0x7168, 0x716B, 0x716A, 0x716B, 0x716B, 0x716A },
+    { 0x0000, 0x716C, 0x716D, 0x716F, 0x716C, 0x716E, 0x716E, 0x716E, 0x716F },
+    { 0x0000, 0x7171, 0x7173, 0x7170, 0x7172, 0x0000, 0x0000, 0x0000, 0x0000 },
+    { 0x0000, 0x7176, 0x7177, 0x7174, 0x7174, 0x7175, 0x7174, 0x7174, 0x7177 },
+    { 0x0000, 0x7178, 0x7179, 0x7179, 0x717B, 0x717A, 0x717B, 0x717A, 0x717B },
+    { 0x0000, 0x717D, 0x717C, 0x717C, 0x717D, 0x717F, 0x717C, 0x717E, 0x717D },
+    { 0x0000, 0x7183, 0x7181, 0x7180, 0x7183, 0x7182, 0x7183, 0x7181, 0x7183 },
+    { 0x0000, 0x7184, 0x7186, 0x7185, 0x7186, 0x7184, 0x7187, 0x7186, 0x7184 },
+    { 0x0000, 0x71A4, 0x71A6, 0x71A5, 0x0000, 0x71A6, 0x71A6, 0x71A6, 0x71A7 },
+    { 0x0000, 0x7188, 0x7188, 0x7189, 0x7188, 0x7189, 0x718B, 0x718A, 0x7189 },
+    { 0x0000, 0x718C, 0x718C, 0x718D, 0x718C, 0x718E, 0x718F, 0x718D, 0x718C },
+    { 0x0000, 0x7190, 0x7190, 0x7191, 0x7192, 0x7191, 0x7193, 0x7190, 0x7191 },
+    { 0x0000, 0x7196, 0x7194, 0x7195, 0x7196, 0x7197, 0x7194, 0x7196, 0x7195 },
+    { 0x0000, 0x7199, 0x719A, 0x7198, 0x7198, 0x719A, 0x719A, 0x719B, 0x7198 },
+    { 0x0000, 0x719D, 0x719C, 0x719E, 0x719D, 0x719D, 0x719C, 0x719F, 0x719E },
+    { 0x0000, 0x71A1, 0x71A0, 0x71A1, 0x71A2, 0x71A1, 0x71A2, 0x71A3, 0x71A2 },
+    { 0x0000, 0x711C, 0x711E, 0x711C, 0x711F, 0x711E, 0x711C, 0x711D, 0x711F },
+    { 0x0000, 0x7104, 0x7105, 0x7107, 0x7107, 0x7105, 0x7106, 0x7107, 0x7107 },
+    { 0x0000, 0x7107, 0x7105, 0x7107, 0x7107, 0x7106, 0x7107, 0x7107, 0x7105 },
+    { 0x0000, 0x7113, 0x7117, 0x7113, 0x7110, 0x7112, 0x7112, 0x7116, 0x7112 },
+    { 0x0000, 0x7113, 0x7113, 0x7113, 0x7113, 0x7113, 0x7113, 0x7111, 0x7113 },
+    { 0x0000, 0x7113, 0x7117, 0x7113, 0x7110, 0x7112, 0x7112, 0x7116, 0x7112 },
+    { 0x0000, 0x7117, 0x7117, 0x7117, 0x7117, 0x7117, 0x7117, 0x7117, 0x7113 },
+    { 0x0000, 0x7101, 0x7100, 0x7102, 0x7103, 0x7101, 0x7100, 0x7102, 0x7103 },
+    { 0x0000, 0x7100, 0x7102, 0x7100, 0x7100, 0x7100, 0x7100, 0x7100, 0x7102 },
+    { 0x0000, 0x710A, 0x7109, 0x7109, 0x710A, 0x710B, 0x7108, 0x7109, 0x710B },
+    { 0x0000, 0x7117, 0x7112, 0x7113, 0x7110, 0x710C, 0x7117, 0x710E, 0x7112 },
+    { 0x0000, 0x710D, 0x710F, 0x710C, 0x7112, 0x710D, 0x710C, 0x710C, 0x710F },
+    { 0x0000, 0x710A, 0x7109, 0x711A, 0x710A, 0x7109, 0x7108, 0x710B, 0x7109 },
+    { 0x0000, 0x710C, 0x710F, 0x7113, 0x7110, 0x710D, 0x7112, 0x7116, 0x710D },
+    { 0x0000, 0x7115, 0x7114, 0x7114, 0x7115, 0x7114, 0x7114, 0x7116, 0x7117 },
+    { 0x0000, 0x7113, 0x710F, 0x7113, 0x7110, 0x710C, 0x711A, 0x710D, 0x7112 },
+    { 0x0000, 0x7101, 0x7102, 0x7103, 0x7101, 0x7100, 0x7100, 0x7102, 0x7100 },
+    { 0x0000, 0x7112, 0x710E, 0x7112, 0x710E, 0x710D, 0x7112, 0x710E, 0x710F },
+    { 0x0000, 0x7142, 0x7141, 0x7142, 0x7143, 0x7140, 0x7140, 0x7141, 0x7143 },
+    { 0x0000, 0x713C, 0x713D, 0x713D, 0x713E, 0x713E, 0x713F, 0x713D, 0x713F },
+    { 0x0000, 0x7101, 0x7102, 0x7103, 0x7101, 0x7100, 0x7100, 0x7102, 0x7100 },
+    { 0x0000, 0x7113, 0x7117, 0x7113, 0x7110, 0x7112, 0x7112, 0x7116, 0x7112 },
+    { 0x0000, 0x7104, 0x7105, 0x7107, 0x7105, 0x7105, 0x7105, 0x7107, 0x7107 },
+    { 0x0000, 0x7104, 0x7105, 0x7107, 0x7105, 0x710C, 0x7105, 0x7107, 0x7107 },
+};
+
+u16 Text_GetFaceReaction(GlobalContext* globalCtx, u32 reactionSet) {
+    u8 currentMask = func_8008F080(globalCtx);
+    return sReactionTextIds[reactionSet][currentMask];
+}
diff --git a/src/code/z_fbdemo.c b/src/code/z_fbdemo.c
index 803562036..e2b6f3cef 100644
--- a/src/code/z_fbdemo.c
+++ b/src/code/z_fbdemo.c
@@ -18,4 +18,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_fbdemo/func_800B23E8.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_fbdemo/func_800B23F0.s")
-
diff --git a/src/code/z_fcurve_data_skelanime.c b/src/code/z_fcurve_data_skelanime.c
index bb9c5e8cd..8feea0af9 100644
--- a/src/code/z_fcurve_data_skelanime.c
+++ b/src/code/z_fcurve_data_skelanime.c
@@ -14,4 +14,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_fcurve_data_skelanime/func_8006CBAC.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_fcurve_data_skelanime/func_8006CF6C.s")
-
diff --git a/src/code/z_game_dlftbls.c b/src/code/z_game_dlftbls.c
new file mode 100644
index 000000000..025cdda6d
--- /dev/null
+++ b/src/code/z_game_dlftbls.c
@@ -0,0 +1,18 @@
+#include <global.h>
+
+#define GAMESTATE_OVERLAY(name, init, destroy, size)                                                         \
+    {                                                                                                        \
+        NULL, (u32)_ovl_##name##SegmentRomStart, (u32)_ovl_##name##SegmentRomEnd, _ovl_##name##SegmentStart, \
+            _ovl_##name##SegmentEnd, 0, init, destroy, 0, 0, 0, size                                         \
+    }
+#define GAMESTATE_OVERLAY_INTERNAL(init, destroy, size) \
+    { NULL, 0, 0, NULL, NULL, 0, init, destroy, 0, 0, 0, size }
+
+GameStateOverlay gGameStateOverlayTable[] = {
+    GAMESTATE_OVERLAY_INTERNAL(TitleSetup_Init, TitleSetup_Destroy, sizeof(GameState)),
+    GAMESTATE_OVERLAY(select, func_80801E44, func_80801E0C, 0x240), // TODO : sizeof(SelectContext)
+    GAMESTATE_OVERLAY(title, Title_Init, Title_Destroy, sizeof(TitleContext)),
+    GAMESTATE_OVERLAY_INTERNAL(func_800BCA64, func_800BC8EC, sizeof(GlobalContext)),
+    GAMESTATE_OVERLAY(opening, Opening_Init, Opening_Destroy, sizeof(OpeningContext)),
+    GAMESTATE_OVERLAY(file_choose, func_80811A20, func_80811A18, 0x1CAE0),
+};
diff --git a/src/code/z_horse.c b/src/code/z_horse.c
index 69a0e6f3a..44612269b 100644
--- a/src/code/z_horse.c
+++ b/src/code/z_horse.c
@@ -2,22 +2,20 @@
 #include <global.h>
 #include <vt.h>
 
-s32 func_8006CFC0(s32 scene)
-{
+s32 func_8006CFC0(s32 scene) {
     s32 validScenes[] = { SCENE_SPOT00, SCENE_SPOT06, SCENE_SPOT09, SCENE_SPOT12, SCENE_SPOT20 };
     s32 i;
 
-    for (i = 0; i < ARRAY_COUNT(validScenes); i++)
-    {
-        if (scene == validScenes[i])
+    for (i = 0; i < ARRAY_COUNT(validScenes); i++) {
+        if (scene == validScenes[i]) {
             return 1;
+        }
     }
 
     return 0;
 }
 
-void func_8006D074(GlobalContext* globalCtx)
-{
+void func_8006D074(GlobalContext* globalCtx) {
     gSaveContext.horse_data.scene = SCENE_SPOT00;
     gSaveContext.horse_data.pos.x = -1840;
     gSaveContext.horse_data.pos.y = 72;
@@ -25,10 +23,8 @@ void func_8006D074(GlobalContext* globalCtx)
     gSaveContext.horse_data.angle = -27353;
 }
 
-void func_8006D0AC(GlobalContext* globalCtx)
-{
-    if (gSaveContext.horse_data.scene == SCENE_SPOT06)
-    {
+void func_8006D0AC(GlobalContext* globalCtx) {
+    if (gSaveContext.horse_data.scene == SCENE_SPOT06) {
         gSaveContext.horse_data.scene = SCENE_SPOT06;
         gSaveContext.horse_data.pos.x = -2065;
         gSaveContext.horse_data.pos.y = -863;
@@ -37,239 +33,209 @@ void func_8006D0AC(GlobalContext* globalCtx)
     }
 }
 
-typedef struct
-{
-    /* 0x00 */ s16   scene;
+typedef struct {
+    /* 0x00 */ s16 scene;
     /* 0x02 */ Vec3s pos;
-    /* 0x08 */ s16   angle;
-    /* 0x0A */ s16   type;
+    /* 0x08 */ s16 angle;
+    /* 0x0A */ s16 type;
 } HorseSpawn;
 
-void func_8006D0EC(GlobalContext* globalCtx, Player* player)
-{
+void func_8006D0EC(GlobalContext* globalCtx, Player* player) {
     s32 i;
-    HorseSpawn horseSpawns[] =
-    {
-        { 81, 0xFE34, 0x0064, 0x19F0, 0, 2 },
-        { 87, 0xF877, 0xFBFF, 0x0300, 0, 2 },
-        { 90, 0x0A06, 0xFEFD, 0x02FF, 0, 2 },
-        { 93, 0xFEB8, 0x000A, 0x03B9, 0, 2 },
+    HorseSpawn horseSpawns[] = {
+        { 81, 0xFE34, 0x0064, 0x19F0, 0, 2 }, { 87, 0xF877, 0xFBFF, 0x0300, 0, 2 },
+        { 90, 0x0A06, 0xFEFD, 0x02FF, 0, 2 }, { 93, 0xFEB8, 0x000A, 0x03B9, 0, 2 },
         { 99, 0x03A0, 0x0000, 0xF718, 0, 2 },
     };
 
-    if ((AREG(6) != 0) && (Flags_GetEventChkInf(0x18) || (DREG(1) != 0)))
-    {
-        player->rideActor = Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE,
-                                        player->actor.posRot.pos.x, player->actor.posRot.pos.y, player->actor.posRot.pos.z,
-                                        player->actor.shape.rot.x, player->actor.shape.rot.y, player->actor.shape.rot.z, 9);
-        if (player->rideActor == NULL)
+    if ((AREG(6) != 0) && (Flags_GetEventChkInf(0x18) || (DREG(1) != 0))) {
+        player->rideActor =
+            Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE, player->actor.posRot.pos.x,
+                        player->actor.posRot.pos.y, player->actor.posRot.pos.z, player->actor.shape.rot.x,
+                        player->actor.shape.rot.y, player->actor.shape.rot.z, 9);
+        if (player->rideActor == NULL) {
             __assert("player->ride.actor != NULL", "../z_horse.c", 343);
+        }
 
         func_8002DECC(globalCtx, player, player->rideActor);
         func_8002DE74(globalCtx, player);
         gSaveContext.horse_data.scene = globalCtx->sceneNum;
 
-        if (globalCtx->sceneNum == SCENE_SPOT12)
+        if (globalCtx->sceneNum == SCENE_SPOT12) {
             player->rideActor->room = -1;
-    }
-    else if ((globalCtx->sceneNum == SCENE_SPOT12) && (gSaveContext.minigame_state == 3))
-    {
+        }
+    } else if ((globalCtx->sceneNum == SCENE_SPOT12) && (gSaveContext.minigame_state == 3)) {
         Actor* horseActor;
         gSaveContext.minigame_state = 0;
-        horseActor = Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE,
-                                 3586.0f, 1413.0f, -402.0f,
-                                 0, 0x4000, 0, 1);
+        horseActor =
+            Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE, 3586.0f, 1413.0f, -402.0f, 0, 0x4000, 0, 1);
         horseActor->room = -1;
-    }
-    else if ((gSaveContext.entrance_index == 1230) && (gSaveContext.event_chk_inf[1] & 0x100))
-    {
+    } else if ((gSaveContext.entrance_index == 1230) && (gSaveContext.event_chk_inf[1] & 0x100)) {
         Actor* horseActor;
-        horseActor = Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE,
-                                 -25.0f, 0.0f, -1600.0f,
-                                 0, -0x4000, 0, 1);
-        if (horseActor == NULL)
+        horseActor =
+            Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE, -25.0f, 0.0f, -1600.0f, 0, -0x4000, 0, 1);
+        if (horseActor == NULL) {
             __assert("horse_actor != NULL", "../z_horse.c", 389);
-    }
-    else if ((globalCtx->sceneNum == gSaveContext.horse_data.scene) && (Flags_GetEventChkInf(0x18) != 0 || DREG(1) != 0))
-    {
+        }
+    } else if ((globalCtx->sceneNum == gSaveContext.horse_data.scene) &&
+               (Flags_GetEventChkInf(0x18) != 0 || DREG(1) != 0)) {
         // Translates to: "SET BY EXISTENCE OF HORSE %d %d %d"
-        osSyncPrintf("馬存在によるセット %d %d %d\n", gSaveContext.horse_data.scene, Flags_GetEventChkInf(0x18), DREG(1));
+        osSyncPrintf("馬存在によるセット %d %d %d\n", gSaveContext.horse_data.scene, Flags_GetEventChkInf(0x18),
+                     DREG(1));
 
-        if (func_8006CFC0(gSaveContext.horse_data.scene))
-        {
+        if (func_8006CFC0(gSaveContext.horse_data.scene)) {
             Actor* horseActor;
-            horseActor = Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE,
-                                     gSaveContext.horse_data.pos.x, gSaveContext.horse_data.pos.y, gSaveContext.horse_data.pos.z,
-                                     0, gSaveContext.horse_data.angle, 0, 1);
-            if (horseActor == NULL)
+            horseActor = Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE, gSaveContext.horse_data.pos.x,
+                                     gSaveContext.horse_data.pos.y, gSaveContext.horse_data.pos.z, 0,
+                                     gSaveContext.horse_data.angle, 0, 1);
+            if (horseActor == NULL) {
                 __assert("horse_actor != NULL", "../z_horse.c", 414);
+            }
 
-            if (globalCtx->sceneNum == SCENE_SPOT12)
+            if (globalCtx->sceneNum == SCENE_SPOT12) {
                 horseActor->room = -1;
-        }
-        else
-        {
+            }
+        } else {
             osSyncPrintf(VT_COL(RED, WHITE));
             // Translates to: "Horse_SetNormal():%d SET SPOT IS NO GOOD."
             osSyncPrintf("Horse_SetNormal():%d セットスポットまずいです。\n", gSaveContext.horse_data.scene);
             osSyncPrintf(VT_RST);
             func_8006D074(globalCtx);
         }
-    }
-    else if ((globalCtx->sceneNum == SCENE_SPOT20) && !Flags_GetEventChkInf(0x18) && (DREG(1) == 0))
-    {
+    } else if ((globalCtx->sceneNum == SCENE_SPOT20) && !Flags_GetEventChkInf(0x18) && (DREG(1) == 0)) {
         Actor* horseActor;
-        horseActor = Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE,
-                                 0.0f, 0.0f, -500.0f,
-                                 0, 0, 0, 1);
-        if (horseActor == 0)
+        horseActor = Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE, 0.0f, 0.0f, -500.0f, 0, 0, 0, 1);
+        if (horseActor == 0) {
             __assert("horse_actor != NULL", "../z_horse.c", 443);
-    }
-    else if (Flags_GetEventChkInf(0x18) || (DREG(1) != 0))
-    {
-        for (i = 0; i < ARRAY_COUNT(horseSpawns); i++)
-        {
+        }
+    } else if (Flags_GetEventChkInf(0x18) || (DREG(1) != 0)) {
+        for (i = 0; i < ARRAY_COUNT(horseSpawns); i++) {
             HorseSpawn* horseSpawn = &horseSpawns[i];
-            if (horseSpawn->scene == globalCtx->sceneNum)
-            {
+            if (horseSpawn->scene == globalCtx->sceneNum) {
                 Actor* horseActor;
-                horseActor = Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE,
-                                         horseSpawn->pos.x, horseSpawn->pos.y, horseSpawn->pos.z,
-                                         0, horseSpawn->angle, 0, horseSpawn->type);
-                if (horseActor == NULL)
+                horseActor =
+                    Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE, horseSpawn->pos.x, horseSpawn->pos.y,
+                                horseSpawn->pos.z, 0, horseSpawn->angle, 0, horseSpawn->type);
+                if (horseActor == NULL) {
                     __assert("horse_actor != NULL", "../z_horse.c", 466);
+                }
 
-                if (globalCtx->sceneNum == SCENE_SPOT12)
+                if (globalCtx->sceneNum == SCENE_SPOT12) {
                     horseActor->room = -1;
+                }
 
                 break;
             }
         }
-    }
-    else if (!Flags_GetEventChkInf(0x18))
-    {
-        if ((DREG(1) == 0) && (globalCtx->sceneNum == SCENE_SOUKO) &&(gSaveContext.night_flag != 0))
-            Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE,
-                        0.0f, 0.0f, -60.0f,
-                        0, 0x7360, 0, 1);
+    } else if (!Flags_GetEventChkInf(0x18)) {
+        if ((DREG(1) == 0) && (globalCtx->sceneNum == SCENE_SOUKO) && (gSaveContext.night_flag != 0)) {
+            Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE, 0.0f, 0.0f, -60.0f, 0, 0x7360, 0, 1);
+        }
     }
 }
 
-typedef struct
-{
-    /* 0x00 */ s16   scene;
-    /* 0x04 */ s32   cutsceneIndex;
+typedef struct {
+    /* 0x00 */ s16 scene;
+    /* 0x04 */ s32 cutsceneIndex;
     /* 0x08 */ Vec3s pos;
-    /* 0x0E */ s16   angle;
-    /* 0x10 */ s16   type;
+    /* 0x0E */ s16 angle;
+    /* 0x10 */ s16 type;
 } struct_8011F9B8;
 
 #ifdef NON_MATCHING
 // regalloc differences
-void func_8006D684(GlobalContext* globalCtx, Player* player)
-{
+void func_8006D684(GlobalContext* globalCtx, Player* player) {
     s32 pad;
     s32 i;
     Vec3s spawnPos;
 
     if ((gSaveContext.entrance_index == 0x028A || gSaveContext.entrance_index == 0x028E ||
          gSaveContext.entrance_index == 0x0292 || gSaveContext.entrance_index == 0x0476) &&
-        (gSaveContext.respawn_flag == 0))
-    {
-        Vec3s spawnPositions[] = 
-        {
+        (gSaveContext.respawn_flag == 0)) {
+        Vec3s spawnPositions[] = {
             { 0xF46F, 0x0139, 0x1E14 },
             { 0xF894, 0x0139, 0x1B67 },
             { 0xF035, 0x0139, 0x1B15 },
             { 0xF6F7, 0x0139, 0x1766 },
         };
 
-        if (gSaveContext.entrance_index == 0x028A)
+        if (gSaveContext.entrance_index == 0x028A) {
             spawnPos = spawnPositions[0];
-        else if (gSaveContext.entrance_index == 0x028E)
+        } else if (gSaveContext.entrance_index == 0x028E) {
             spawnPos = spawnPositions[1];
-        else if (gSaveContext.entrance_index == 0x0292)
+        } else if (gSaveContext.entrance_index == 0x0292) {
             spawnPos = spawnPositions[2];
-        else
+        } else {
             spawnPos = spawnPositions[3];
+        }
 
-        player->rideActor = Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE,
-                                        spawnPos.x, spawnPos.y, spawnPos.z,
-                                        0, player->actor.posRot.rot.y, 0, 7);
-        if (player->rideActor == NULL)
+        player->rideActor = Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE, spawnPos.x, spawnPos.y,
+                                        spawnPos.z, 0, player->actor.posRot.rot.y, 0, 7);
+        if (player->rideActor == NULL) {
             __assert("player->ride.actor != NULL", "../z_horse.c", 561);
+        }
 
         func_8002DECC(globalCtx, player, player->rideActor);
         func_8002DE74(globalCtx, player);
         gSaveContext.horse_data.scene = globalCtx->sceneNum;
-    }
-    else if ((globalCtx->sceneNum == SCENE_SPOT20) && ((gSaveContext.event_inf[0] & 0xF) == 6) &&
-             (Flags_GetEventChkInf(0x18) == 0) && (DREG(1) == 0))
-    {
-        player->rideActor = Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE,
-                                        894.0f, 0.0f, -2084.0f,
-                                        0, -0x7FFF, 0, 5);
-        if (player->rideActor == NULL)
+    } else if ((globalCtx->sceneNum == SCENE_SPOT20) && ((gSaveContext.event_inf[0] & 0xF) == 6) &&
+               (Flags_GetEventChkInf(0x18) == 0) && (DREG(1) == 0)) {
+        player->rideActor =
+            Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE, 894.0f, 0.0f, -2084.0f, 0, -0x7FFF, 0, 5);
+        if (player->rideActor == NULL) {
             __assert("player->ride.actor != NULL", "../z_horse.c", 582);
+        }
 
         func_8002DECC(globalCtx, player, player->rideActor);
         func_8002DE74(globalCtx, player);
         gSaveContext.horse_data.scene = globalCtx->sceneNum;
 
-        if (globalCtx->sceneNum == SCENE_SPOT12)
+        if (globalCtx->sceneNum == SCENE_SPOT12) {
             player->rideActor->room = -1;
-    }
-    else
-    {
-        static struct_8011F9B8 D_8011F9B8[] =
-        {
-            { 93, 0xFFF0, 0x0E10, 0x0585, 0x0168, 0x8001, 8 },
-            { 99, 0xFFF0, 0xFF06, 0x0001, 0xF9D4, 0x4000, 6 },
-            { 99, 0xFFF1, 0x0000, 0x0000, 0x0000, 0x0000, 5 },
-            { 99, 0xFFF5, 0x0000, 0x0000, 0x0000, 0x0000, 7 },
-            { 81, 0xFFF3, 0xF46F, 0x0139, 0x1E14, 0x0000, 7 },
-            { 81, 0xFFF4, 0xF894, 0x0139, 0x1B67, 0x0000, 7 },
-            { 81, 0xFFF5, 0xF035, 0x0139, 0x1B15, 0x0000, 7 },
-            { 81, 0xFFF6, 0xF035, 0x0139, 0x1B15, 0x0000, 7 },
+        }
+    } else {
+        static struct_8011F9B8 D_8011F9B8[] = {
+            { 93, 0xFFF0, 0x0E10, 0x0585, 0x0168, 0x8001, 8 }, { 99, 0xFFF0, 0xFF06, 0x0001, 0xF9D4, 0x4000, 6 },
+            { 99, 0xFFF1, 0x0000, 0x0000, 0x0000, 0x0000, 5 }, { 99, 0xFFF5, 0x0000, 0x0000, 0x0000, 0x0000, 7 },
+            { 81, 0xFFF3, 0xF46F, 0x0139, 0x1E14, 0x0000, 7 }, { 81, 0xFFF4, 0xF894, 0x0139, 0x1B67, 0x0000, 7 },
+            { 81, 0xFFF5, 0xF035, 0x0139, 0x1B15, 0x0000, 7 }, { 81, 0xFFF6, 0xF035, 0x0139, 0x1B15, 0x0000, 7 },
         };
 
-        for (i = 0; i < ARRAY_COUNT(D_8011F9B8); i++)
-        {
-            if ((globalCtx->sceneNum == D_8011F9B8[i].scene) && (gSaveContext.cutscene_index == D_8011F9B8[i].cutsceneIndex))
-            {
-                if (D_8011F9B8[i].type == 7) 
-                {
-                    if ((globalCtx->sceneNum == 99) && (gSaveContext.cutscene_index == 0xFFF1))
-                    {
+        for (i = 0; i < ARRAY_COUNT(D_8011F9B8); i++) {
+            if ((globalCtx->sceneNum == D_8011F9B8[i].scene) &&
+                (gSaveContext.cutscene_index == D_8011F9B8[i].cutsceneIndex)) {
+                if (D_8011F9B8[i].type == 7) {
+                    if ((globalCtx->sceneNum == 99) && (gSaveContext.cutscene_index == 0xFFF1)) {
                         D_8011F9B8[i].pos.x = player->actor.posRot.pos.x;
                         D_8011F9B8[i].pos.y = player->actor.posRot.pos.y;
                         D_8011F9B8[i].pos.z = player->actor.posRot.pos.z;
                     }
 
                     player->rideActor = Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE,
-                                                    D_8011F9B8[i].pos.x, D_8011F9B8[i].pos.y, D_8011F9B8[i].pos.z,
-                                                    0, player->actor.posRot.rot.y, 0, D_8011F9B8[i].type);
-                    if (player->rideActor == NULL)
+                                                    D_8011F9B8[i].pos.x, D_8011F9B8[i].pos.y, D_8011F9B8[i].pos.z, 0,
+                                                    player->actor.posRot.rot.y, 0, D_8011F9B8[i].type);
+                    if (player->rideActor == NULL) {
                         __assert("player->ride.actor != NULL", "../z_horse.c", 628);
+                    }
 
                     func_8002DECC(globalCtx, player, player->rideActor);
                     func_8002DE74(globalCtx, player);
-                }
-                else if ((D_8011F9B8[i].type == 5) || (D_8011F9B8[i].type == 6) || (D_8011F9B8[i].type == 8))
-                {
+                } else if ((D_8011F9B8[i].type == 5) || (D_8011F9B8[i].type == 6) || (D_8011F9B8[i].type == 8)) {
                     Vec3f sp54;
                     s32 temp;
                     s32 pad2;
 
                     temp = 0;
-                    if (((gSaveContext.event_inf[0] & 0x10) >> 4) && D_8011F9B8[i].type == 6)
+                    if (((gSaveContext.event_inf[0] & 0x10) >> 4) && D_8011F9B8[i].type == 6) {
                         temp = 0x8000;
+                    }
 
                     player->rideActor = Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE,
-                                                    D_8011F9B8[i].pos.x, D_8011F9B8[i].pos.y, D_8011F9B8[i].pos.z,
-                                                    0, D_8011F9B8[i].angle, 0, D_8011F9B8[i].type | temp);
-                    if (player->rideActor == NULL)
+                                                    D_8011F9B8[i].pos.x, D_8011F9B8[i].pos.y, D_8011F9B8[i].pos.z, 0,
+                                                    D_8011F9B8[i].angle, 0, D_8011F9B8[i].type | temp);
+                    if (player->rideActor == NULL) {
                         __assert("player->ride.actor != NULL", "../z_horse.c", 667);
+                    }
 
                     player->actor.posRot.pos.x = D_8011F9B8[i].pos.x;
                     player->actor.posRot.pos.y = D_8011F9B8[i].pos.y;
@@ -285,12 +251,10 @@ void func_8006D684(GlobalContext* globalCtx, Player* player)
                     sp54.z = player->actor.posRot.pos.z;
 
                     func_800C04D8(globalCtx, globalCtx->cameraCtx.unk_5C0, &player->actor.posRot, &sp54);
-                }
-                else
-                {
-                    Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE,
-                                D_8011F9B8[i].pos.x, D_8011F9B8[i].pos.y, D_8011F9B8[i].pos.z,
-                                0, D_8011F9B8[i].angle, 0, D_8011F9B8[i].type);
+                } else {
+                    Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_HORSE, D_8011F9B8[i].pos.x,
+                                D_8011F9B8[i].pos.y, D_8011F9B8[i].pos.z, 0, D_8011F9B8[i].angle, 0,
+                                D_8011F9B8[i].type);
                 }
                 break;
             }
@@ -298,33 +262,24 @@ void func_8006D684(GlobalContext* globalCtx, Player* player)
     }
 }
 #else
-Vec3s D_8011F9A0[] = 
-{
+Vec3s D_8011F9A0[] = {
     { 0xF46F, 0x0139, 0x1E14 },
     { 0xF894, 0x0139, 0x1B67 },
     { 0xF035, 0x0139, 0x1B15 },
     { 0xF6F7, 0x0139, 0x1766 },
 };
-struct_8011F9B8 D_8011F9B8[] =
-{
-    { 93, 0xFFF0, 0x0E10, 0x0585, 0x0168, 0x8001, 8 },
-    { 99, 0xFFF0, 0xFF06, 0x0001, 0xF9D4, 0x4000, 6 },
-    { 99, 0xFFF1, 0x0000, 0x0000, 0x0000, 0x0000, 5 },
-    { 99, 0xFFF5, 0x0000, 0x0000, 0x0000, 0x0000, 7 },
-    { 81, 0xFFF3, 0xF46F, 0x0139, 0x1E14, 0x0000, 7 },
-    { 81, 0xFFF4, 0xF894, 0x0139, 0x1B67, 0x0000, 7 },
-    { 81, 0xFFF5, 0xF035, 0x0139, 0x1B15, 0x0000, 7 },
-    { 81, 0xFFF6, 0xF035, 0x0139, 0x1B15, 0x0000, 7 },
+struct_8011F9B8 D_8011F9B8[] = {
+    { 93, 0xFFF0, 0x0E10, 0x0585, 0x0168, 0x8001, 8 }, { 99, 0xFFF0, 0xFF06, 0x0001, 0xF9D4, 0x4000, 6 },
+    { 99, 0xFFF1, 0x0000, 0x0000, 0x0000, 0x0000, 5 }, { 99, 0xFFF5, 0x0000, 0x0000, 0x0000, 0x0000, 7 },
+    { 81, 0xFFF3, 0xF46F, 0x0139, 0x1E14, 0x0000, 7 }, { 81, 0xFFF4, 0xF894, 0x0139, 0x1B67, 0x0000, 7 },
+    { 81, 0xFFF5, 0xF035, 0x0139, 0x1B15, 0x0000, 7 }, { 81, 0xFFF6, 0xF035, 0x0139, 0x1B15, 0x0000, 7 },
 };
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_horse/func_8006D684.s")
 #endif
 
-void func_8006DC68(GlobalContext* globalCtx, Player* player)
-{
-    if (LINK_IS_ADULT)
-    {
-        if (!func_8006CFC0(gSaveContext.horse_data.scene))
-        {
+void func_8006DC68(GlobalContext* globalCtx, Player* player) {
+    if (LINK_IS_ADULT) {
+        if (!func_8006CFC0(gSaveContext.horse_data.scene)) {
             osSyncPrintf(VT_COL(RED, WHITE));
             // Translates to: "Horse_Set_Check():%d SET SPOT IS NO GOOD."
             osSyncPrintf("Horse_Set_Check():%d セットスポットまずいです。\n", gSaveContext.horse_data.scene);
@@ -332,35 +287,31 @@ void func_8006DC68(GlobalContext* globalCtx, Player* player)
             func_8006D074(globalCtx);
         }
 
-        if (func_8006CFC0(globalCtx->sceneNum))
-        {
+        if (func_8006CFC0(globalCtx->sceneNum)) {
             if ((gSaveContext.scene_setup_index > 3) ||
                 ((gSaveContext.entrance_index == 0x028A || gSaveContext.entrance_index == 0x028E ||
                   gSaveContext.entrance_index == 0x0292 || gSaveContext.entrance_index == 0x0476) &&
                  (gSaveContext.respawn_flag == 0)) ||
                 ((globalCtx->sceneNum == SCENE_SPOT20) && ((gSaveContext.event_inf[0] & 0xF) == 6) &&
-                  !Flags_GetEventChkInf(0x18) && (DREG(1) == 0)))
-            {
+                 !Flags_GetEventChkInf(0x18) && (DREG(1) == 0))) {
                 func_8006D684(globalCtx, player);
-            }
-            else
-            {
+            } else {
                 func_8006D0EC(globalCtx, player);
             }
         }
     }
 }
 
-void func_8006DD9C(Actor* actor, Vec3f* arg1, s16 arg2)
-{
+void func_8006DD9C(Actor* actor, Vec3f* arg1, s16 arg2) {
     s16 x = Math_Vec3f_Yaw(&actor->posRot.pos, arg1) - actor->posRot.rot.y;
 
-    if (x > arg2)
+    if (x > arg2) {
         actor->posRot.rot.y += arg2;
-    else if (x < -arg2)
+    } else if (x < -arg2) {
         actor->posRot.rot.y -= arg2;
-    else
+    } else {
         actor->posRot.rot.y += x;
+    }
 
     actor->shape.rot.y = actor->posRot.rot.y;
 }
diff --git a/src/code/z_jpeg.c b/src/code/z_jpeg.c
index 93fe90b27..5031ad823 100644
--- a/src/code/z_jpeg.c
+++ b/src/code/z_jpeg.c
@@ -10,4 +10,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_jpeg/func_8006E0EC.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_jpeg/func_8006E418.s")
-
diff --git a/src/code/z_kaleido_manager.c b/src/code/z_kaleido_manager.c
index ad5761ec7..519639a15 100644
--- a/src/code/z_kaleido_manager.c
+++ b/src/code/z_kaleido_manager.c
@@ -1,15 +1,13 @@
 #include <global.h>
 #include <vt.h>
 
-#define KALEIDO_OVERLAY(name)                                  \
-    {                                                                       \
-        NULL, (u32)_ovl_##name##SegmentRomStart, (u32)_ovl_##name##SegmentRomEnd, \
-        _ovl_##name##SegmentStart, _ovl_##name##SegmentEnd,       \
-        0, #name,                         \
+#define KALEIDO_OVERLAY(name)                                                                                \
+    {                                                                                                        \
+        NULL, (u32)_ovl_##name##SegmentRomStart, (u32)_ovl_##name##SegmentRomEnd, _ovl_##name##SegmentStart, \
+            _ovl_##name##SegmentEnd, 0, #name,                                                               \
     }
 
-KaleidoManagerOvl gKaleidoMgrOverlayTable[] =
-{
+KaleidoManagerOvl gKaleidoMgrOverlayTable[] = {
     KALEIDO_OVERLAY(kaleido_scope),
     KALEIDO_OVERLAY(player_actor),
 };
@@ -18,22 +16,21 @@ void* sKaleidoAreaPtr = NULL;
 KaleidoManagerOvl* gKaleidoMgrCurOvl = NULL;
 u32 D_8012D1E0 = 0;
 
-void KaleidoManager_LoadOvl(KaleidoManagerOvl* ovl)
-{
+void KaleidoManager_LoadOvl(KaleidoManagerOvl* ovl) {
     LogUtils_CheckNullPointer("KaleidoArea_allocp", sKaleidoAreaPtr, "../z_kaleido_manager.c", 99);
     ovl->loadedRamAddr = sKaleidoAreaPtr;
     Overlay_Load(ovl->vromStart, ovl->vromEnd, ovl->vramStart, ovl->vramEnd, ovl->loadedRamAddr);
     osSyncPrintf(VT_FGCOL(GREEN));
-    osSyncPrintf("OVL(k):Seg:%08x-%08x Ram:%08x-%08x Off:%08x %s\n", ovl->vramStart, ovl->vramEnd, ovl->loadedRamAddr, ((u32)ovl->loadedRamAddr + ovl->vramEnd) - (u32)ovl->vramStart, (u32)ovl->vramStart - (u32)ovl->loadedRamAddr, ovl->name);
+    osSyncPrintf("OVL(k):Seg:%08x-%08x Ram:%08x-%08x Off:%08x %s\n", ovl->vramStart, ovl->vramEnd, ovl->loadedRamAddr,
+                 ((u32)ovl->loadedRamAddr + ovl->vramEnd) - (u32)ovl->vramStart,
+                 (u32)ovl->vramStart - (u32)ovl->loadedRamAddr, ovl->name);
     osSyncPrintf(VT_RST);
     ovl->off = (u32)ovl->loadedRamAddr - (u32)ovl->vramStart;
     gKaleidoMgrCurOvl = ovl;
 }
 
-void KaleidoManager_ClearOvl(KaleidoManagerOvl* ovl)
-{
-    if (ovl->loadedRamAddr)
-    {
+void KaleidoManager_ClearOvl(KaleidoManagerOvl* ovl) {
+    if (ovl->loadedRamAddr) {
         ovl->off = 0;
         bzero(ovl->loadedRamAddr, ovl->vramEnd - (u32)ovl->vramStart);
         ovl->loadedRamAddr = NULL;
@@ -41,18 +38,17 @@ void KaleidoManager_ClearOvl(KaleidoManagerOvl* ovl)
     }
 }
 
-void KaleidoManager_Init(GlobalContext* globalCtx)
-{
+void KaleidoManager_Init(GlobalContext* globalCtx) {
     s32 largestOvl;
     s32 vramSize;
     u32 idx;
 
     largestOvl = 0;
-    for (idx = 0; idx < ARRAY_COUNT(gKaleidoMgrOverlayTable); idx++)
-    {
+    for (idx = 0; idx < ARRAY_COUNT(gKaleidoMgrOverlayTable); idx++) {
         vramSize = gKaleidoMgrOverlayTable[idx].vramEnd - (u32)gKaleidoMgrOverlayTable[idx].vramStart;
-        if (largestOvl < vramSize)
+        if (largestOvl < vramSize) {
             largestOvl = vramSize;
+        }
     }
     osSyncPrintf(VT_FGCOL(GREEN));
     osSyncPrintf("KaleidoArea の最大サイズは %d バイトを確保します\n", largestOvl);
@@ -64,46 +60,41 @@ void KaleidoManager_Init(GlobalContext* globalCtx)
     osSyncPrintf(VT_RST);
     gKaleidoMgrCurOvl = 0;
 }
-void KaleidoManager_Destroy()
-{
-    if (gKaleidoMgrCurOvl)
-    {
+void KaleidoManager_Destroy() {
+    if (gKaleidoMgrCurOvl) {
         KaleidoManager_ClearOvl(gKaleidoMgrCurOvl);
         gKaleidoMgrCurOvl = NULL;
     }
     sKaleidoAreaPtr = NULL;
 }
 
-//NOTE: this function looks messed up and probably doesn't work like how the devs wanted it to work
-void* KaleidoManager_GetRamAddr(void* vram)
-{
+// NOTE: this function looks messed up and probably doesn't work like how the devs wanted it to work
+void* KaleidoManager_GetRamAddr(void* vram) {
     KaleidoManagerOvl* iter;
     KaleidoManagerOvl* ovl;
     u32 idx;
 
     iter = gKaleidoMgrCurOvl;
     ovl = iter;
-    if (!ovl)
-    {
+    if (!ovl) {
         iter = &gKaleidoMgrOverlayTable[0];
-        for (idx = 0; idx != ARRAY_COUNT(gKaleidoMgrOverlayTable); idx++)
-        {
-            if ((u32)vram >= (u32)iter->vramStart && (u32)iter->vramEnd >= (u32)vram)
-            {
+        for (idx = 0; idx != ARRAY_COUNT(gKaleidoMgrOverlayTable); idx++) {
+            if ((u32)vram >= (u32)iter->vramStart && (u32)iter->vramEnd >= (u32)vram) {
                 KaleidoManager_LoadOvl(iter);
                 ovl = iter;
                 goto KaleidoManager_GetRamAddr_end;
             }
-            //BUG: devs probably forgot iter++ here
+            // BUG: devs probably forgot iter++ here
         }
-        
-        osSyncPrintf("異常\n"); //Abnormal
+
+        osSyncPrintf("異常\n"); // Abnormal
         return NULL;
     }
 
 KaleidoManager_GetRamAddr_end:
-    if (!ovl || (u32)vram < (u32)ovl->vramStart || (u32)vram >= (u32)ovl->vramEnd)
+    if (!ovl || (u32)vram < (u32)ovl->vramStart || (u32)vram >= (u32)ovl->vramEnd) {
         return NULL;
+    }
 
     return (void*)((u32)vram + ovl->off);
 }
diff --git a/src/code/z_kaleido_scope_call.c b/src/code/z_kaleido_scope_call.c
index 7932415df..60928cc61 100644
--- a/src/code/z_kaleido_scope_call.c
+++ b/src/code/z_kaleido_scope_call.c
@@ -7,67 +7,54 @@ float D_80161398;
 u32 D_8016139C;
 void* D_801613A0;
 
-extern void func_80826CB4(GlobalContext*); //KaleidoScope_Update
-extern void func_808262B8(GlobalContext*); //KaleidoScope_Draw
+extern void func_80826CB4(GlobalContext*); // KaleidoScope_Update
+extern void func_808262B8(GlobalContext*); // KaleidoScope_Draw
 
-void KaleidoScopeCall_LoadPlayer()
-{
-    if ((u32)gKaleidoMgrCurOvl != (u32)&gKaleidoMgrOverlayTable[KALEIDO_OVL_PLAYER_ACTOR])
-    {
-        if (gKaleidoMgrCurOvl)
-        {
+void KaleidoScopeCall_LoadPlayer() {
+    if ((u32)gKaleidoMgrCurOvl != (u32)&gKaleidoMgrOverlayTable[KALEIDO_OVL_PLAYER_ACTOR]) {
+        if (gKaleidoMgrCurOvl) {
             osSyncPrintf(VT_FGCOL(GREEN));
-            osSyncPrintf("カレイド領域 強制排除\n"); //Kaleido area forced exclusion
+            osSyncPrintf("カレイド領域 強制排除\n"); // Kaleido area forced exclusion
             osSyncPrintf(VT_RST);
             KaleidoManager_ClearOvl(gKaleidoMgrCurOvl);
         }
         osSyncPrintf(VT_FGCOL(GREEN));
-        osSyncPrintf("プレイヤーアクター搬入\n"); //Player actor import
+        osSyncPrintf("プレイヤーアクター搬入\n"); // Player actor import
         osSyncPrintf(VT_RST);
         KaleidoManager_LoadOvl(&gKaleidoMgrOverlayTable[KALEIDO_OVL_PLAYER_ACTOR]);
     }
 }
 
-void KaleidoScopeCall_Init(GlobalContext* globalCtx)
-{
-    //Kaleidoscope replacement construct
+void KaleidoScopeCall_Init(GlobalContext* globalCtx) {
+    // Kaleidoscope replacement construct
     osSyncPrintf("カレイド・スコープ入れ替え コンストラクト \n");
     sKaleidoScopeUpdateFunc = KaleidoManager_GetRamAddr(func_80826CB4);
     sKaleidoScopeDrawFunc = KaleidoManager_GetRamAddr(func_808262B8);
-    //Note : the line numbers suggests there was a macro (see logutils.c)
-    LogUtils_LogThreadId("../z_kaleido_scope_call.c", 98);
-    osSyncPrintf("kaleido_scope_move = %08x\n", func_80826CB4);
-    LogUtils_LogThreadId("../z_kaleido_scope_call.c", 99);
-    osSyncPrintf("kaleido_scope_move_func = %08x\n", sKaleidoScopeUpdateFunc);
-    LogUtils_LogThreadId("../z_kaleido_scope_call.c", 100);
-    osSyncPrintf("kaleido_scope_draw = %08x\n", func_808262B8);
-    LogUtils_LogThreadId("../z_kaleido_scope_call.c", 101);
-    osSyncPrintf("kaleido_scope_draw_func = %08x\n", sKaleidoScopeDrawFunc);
+
+    LOG_ADDRESS("kaleido_scope_move", func_80826CB4, "../z_kaleido_scope_call.c", 98);
+    LOG_ADDRESS("kaleido_scope_move_func", sKaleidoScopeUpdateFunc, "../z_kaleido_scope_call.c", 99);
+    LOG_ADDRESS("kaleido_scope_draw", func_808262B8, "../z_kaleido_scope_call.c", 100);
+    LOG_ADDRESS("kaleido_scope_draw_func", sKaleidoScopeDrawFunc, "../z_kaleido_scope_call.c", 101);
     func_8006ECF4(globalCtx);
 }
 
-void KaleidoScopeCall_Destroy(GlobalContext* globalCtx)
-{
-    //Kaleidoscope replacement
+void KaleidoScopeCall_Destroy(GlobalContext* globalCtx) {
+    // Kaleidoscope replacement
     osSyncPrintf("カレイド・スコープ入れ替え デストラクト \n");
     func_8006EE48(globalCtx);
 }
 
-//regalloc
+// regalloc
 #ifdef NON_MATCHING
-void KaleidoScopeCall_Update(GlobalContext* globalCtx)
-{
+void KaleidoScopeCall_Update(GlobalContext* globalCtx) {
     u32 pad;
     PauseContext* pauseCtx;
-    
+
     pauseCtx = &globalCtx->pauseCtx;
 
-    if (pauseCtx->state != 0 || pauseCtx->flag != 0)
-    {
-        if (pauseCtx->state == 1)
-        {
-            if (func_800B38FC() == 0)
-            {
+    if (pauseCtx->state != 0 || pauseCtx->flag != 0) {
+        if (pauseCtx->state == 1) {
+            if (func_800B38FC() == 0) {
                 HREG(80) = 7;
                 HREG(82) = 3;
                 R_PAUSE_MENU_MODE = 1;
@@ -75,45 +62,36 @@ void KaleidoScopeCall_Update(GlobalContext* globalCtx)
                 pauseCtx->unk_1EC = 0;
                 pauseCtx->state++;
             }
-        }
-        else if (pauseCtx->state == 8)
-        {
+        } else if (pauseCtx->state == 8) {
             HREG(80) = 7;
             HREG(82) = 3;
             R_PAUSE_MENU_MODE = 1;
             pauseCtx->unk_1E4 = 0;
             pauseCtx->unk_1EC = 0;
             pauseCtx->state++;
-        }
-        else if (pauseCtx->state == 2 || pauseCtx->state == 9)
-        {
+        } else if (pauseCtx->state == 2 || pauseCtx->state == 9) {
             osSyncPrintf("R_PAUSE_MENU_MODE=%d\n", R_PAUSE_MENU_MODE);
-            if (R_PAUSE_MENU_MODE >= 3)
+            if (R_PAUSE_MENU_MODE >= 3) {
                 pauseCtx->state++;
-        }
-        else if (pauseCtx->state != 0)
-        {
-            if (&gKaleidoMgrOverlayTable[KALEIDO_OVL_KALEIDO_SCOPE] != gKaleidoMgrCurOvl)
-            {
-                if (gKaleidoMgrCurOvl)
-                {
+            }
+        } else if (pauseCtx->state != 0) {
+            if (&gKaleidoMgrOverlayTable[KALEIDO_OVL_KALEIDO_SCOPE] != gKaleidoMgrCurOvl) {
+                if (gKaleidoMgrCurOvl) {
                     osSyncPrintf(VT_FGCOL(GREEN));
-                    osSyncPrintf("カレイド領域 プレイヤー 強制排除\n"); //Kaleid Zone Player Forced Elimination
+                    osSyncPrintf("カレイド領域 プレイヤー 強制排除\n"); // Kaleid Zone Player Forced Elimination
                     osSyncPrintf(VT_RST);
                     KaleidoManager_ClearOvl(gKaleidoMgrCurOvl);
                 }
                 osSyncPrintf(VT_FGCOL(GREEN));
-                osSyncPrintf("カレイド領域 カレイドスコープ搬入\n"); //Kaleid area Kaleidoscope loading
+                osSyncPrintf("カレイド領域 カレイドスコープ搬入\n"); // Kaleid area Kaleidoscope loading
                 osSyncPrintf(VT_RST);
                 KaleidoManager_LoadOvl(&gKaleidoMgrOverlayTable[KALEIDO_OVL_KALEIDO_SCOPE]);
             }
-            if (&gKaleidoMgrOverlayTable[KALEIDO_OVL_KALEIDO_SCOPE] == gKaleidoMgrCurOvl)
-            {
+            if (&gKaleidoMgrOverlayTable[KALEIDO_OVL_KALEIDO_SCOPE] == gKaleidoMgrCurOvl) {
                 sKaleidoScopeUpdateFunc(globalCtx);
-                if (globalCtx->pauseCtx.state == 0 && globalCtx->pauseCtx.flag == 0)
-                {
+                if (globalCtx->pauseCtx.state == 0 && globalCtx->pauseCtx.flag == 0) {
                     osSyncPrintf(VT_FGCOL(GREEN));
-                    osSyncPrintf("カレイド領域 カレイドスコープ排出\n"); //Kaleid area Kaleidoscope emission
+                    osSyncPrintf("カレイド領域 カレイドスコープ排出\n"); // Kaleid area Kaleidoscope emission
                     osSyncPrintf(VT_RST);
                     KaleidoManager_ClearOvl(&gKaleidoMgrOverlayTable[KALEIDO_OVL_KALEIDO_SCOPE]);
                     KaleidoScopeCall_LoadPlayer();
@@ -126,18 +104,16 @@ void KaleidoScopeCall_Update(GlobalContext* globalCtx)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_kaleido_scope_call/KaleidoScopeCall_Update.s")
 #endif
 
-void KaleidoScopeCall_Draw(GlobalContext* globalCtx)
-{
-    KaleidoManagerOvl *kaleidoScopeOvl;
+void KaleidoScopeCall_Draw(GlobalContext* globalCtx) {
+    KaleidoManagerOvl* kaleidoScopeOvl;
 
-    if (R_PAUSE_MENU_MODE >= 3)
-    {
-        if ((globalCtx->pauseCtx.state >= 4 && globalCtx->pauseCtx.state < 8) || (globalCtx->pauseCtx.state >= 11 && globalCtx->pauseCtx.state < 19))
-        {
+    if (R_PAUSE_MENU_MODE >= 3) {
+        if ((globalCtx->pauseCtx.state >= 4 && globalCtx->pauseCtx.state < 8) ||
+            (globalCtx->pauseCtx.state >= 11 && globalCtx->pauseCtx.state < 19)) {
             kaleidoScopeOvl = &gKaleidoMgrOverlayTable[KALEIDO_OVL_KALEIDO_SCOPE];
-            if (gKaleidoMgrCurOvl == kaleidoScopeOvl)
+            if (gKaleidoMgrCurOvl == kaleidoScopeOvl) {
                 sKaleidoScopeDrawFunc(globalCtx);
+            }
         }
     }
-
 }
diff --git a/src/code/z_kanfont.c b/src/code/z_kanfont.c
index fb58245bd..fc2c0b1e8 100644
--- a/src/code/z_kanfont.c
+++ b/src/code/z_kanfont.c
@@ -6,4 +6,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_kanfont/func_8006EEBC.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_kanfont/func_8006EF10.s")
-
diff --git a/src/code/z_kankyo.c b/src/code/z_kankyo.c
index 94f8bf6dc..7caa221e5 100644
--- a/src/code/z_kankyo.c
+++ b/src/code/z_kankyo.c
@@ -31,8 +31,7 @@
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_kankyo/func_80073A5C.s")
 
-f32 func_800746DC()
-{
+f32 func_800746DC() {
     return Math_Rand_ZeroOne() - 0.5f;
 }
 
@@ -70,23 +69,19 @@ f32 func_800746DC()
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_kankyo/func_800773A8.s")
 
-s32 func_800775CC()
-{
+s32 func_800775CC() {
     return gSaveContext.unk_18;
 }
 
-void func_800775D8()
-{
+void func_800775D8() {
     gSaveContext.unk_18 = 0;
 }
 
-s32 func_800775E4()
-{
+s32 func_800775E4() {
     return gSaveContext.unk_14;
 }
 
-void func_800775F0(u16 arg0)
-{
+void func_800775F0(u16 arg0) {
     gSaveContext.unk_140E = arg0;
 }
 
@@ -97,4 +92,3 @@ void func_800775F0(u16 arg0)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_kankyo/func_80077684.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_kankyo/func_800776E4.s")
-
diff --git a/src/code/z_lib.c b/src/code/z_lib.c
index 7b8bcbc2c..c76e400c8 100644
--- a/src/code/z_lib.c
+++ b/src/code/z_lib.c
@@ -1,112 +1,94 @@
 #include <ultra64.h>
 #include <global.h>
 
-#ifdef NON_MATCHING
-void Lib_MemSet(void* dest, size_t size, u8 val)
-{
-    u8* destu = dest;
-    u32 i;
-
-    for (i = 0; i < size; i++)
-    {
-        *destu++ = val;
+void Lib_MemSet(u8* dest, size_t size, u8 val) {
+    u32 i = 0;
+
+    // TODO: Convert this to while/for if possible
+    if (i == size) {
+        return;
     }
+    do {
+        *dest++ = val;
+        i++;
+    } while (i != size);
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_lib/Lib_MemSet.s")
-#endif
 
-f32 Math_Coss(s16 angle)
-{
+f32 Math_Coss(s16 angle) {
     return coss(angle) * (1.0f / 32767);
 }
 
-f32 Math_Sins(s16 angle)
-{
+f32 Math_Sins(s16 angle) {
     return sins(angle) * (1.0f / 32767);
 }
 
-s32 Math_ApproxUpdateScaledS(s16* pValue, s16 target, s16 step)
-{
+s32 Math_ApproxUpdateScaledS(s16* pValue, s16 target, s16 step) {
     f32 updateScale;
 
-    if (step != 0)
-    {
+    if (step != 0) {
         updateScale = R_UPDATE_RATE * 0.5f;
 
-        if ((s16)(*pValue - target) > 0)
+        if ((s16)(*pValue - target) > 0) {
             step = -step;
+        }
 
         *pValue += (s16)(step * updateScale);
 
-        if (((s16)(*pValue - target) * step) >= 0)
-        {
+        if (((s16)(*pValue - target) * step) >= 0) {
             *pValue = target;
             return 1;
         }
-    }
-    else if (target == *pValue)
-    {
+    } else if (target == *pValue) {
         return 1;
     }
 
     return 0;
 }
 
-s32 Math_ApproxS(s16* pValue, s16 target, s16 step)
-{
-    if (step != 0)
-    {
-        if (target < *pValue)
+s32 Math_ApproxS(s16* pValue, s16 target, s16 step) {
+    if (step != 0) {
+        if (target < *pValue) {
             step = -step;
+        }
 
         *pValue += step;
 
-        if (((*pValue - target) * step) >= 0)
-        {
+        if (((*pValue - target) * step) >= 0) {
             *pValue = target;
             return 1;
         }
-    }
-    else if (target == *pValue)
-    {
+    } else if (target == *pValue) {
         return 1;
     }
 
     return 0;
 }
 
-s32 Math_ApproxF(f32* pValue, f32 target, f32 step)
-{
-    if (step != 0.0f)
-    {
-        if (target < *pValue)
+s32 Math_ApproxF(f32* pValue, f32 target, f32 step) {
+    if (step != 0.0f) {
+        if (target < *pValue) {
             step = -step;
+        }
 
         *pValue += step;
 
-        if (((*pValue - target) * step) >= 0)
-        {
+        if (((*pValue - target) * step) >= 0) {
             *pValue = target;
             return 1;
         }
-    }
-    else if (target == *pValue)
-    {
+    } else if (target == *pValue) {
         return 1;
     }
 
     return 0;
 }
 
-s32 func_80077A90(s16* pValue, s16 target, s16 step)
-{
+s32 func_80077A90(s16* pValue, s16 target, s16 step) {
     s16 orig = *pValue;
 
     *pValue += step;
 
-    if (((s16)(*pValue - target) * (s16)(orig - target)) <= 0)
-    {
+    if (((s16)(*pValue - target) * (s16)(orig - target)) <= 0) {
         *pValue = target;
         return 1;
     }
@@ -114,14 +96,12 @@ s32 func_80077A90(s16* pValue, s16 target, s16 step)
     return 0;
 }
 
-s32 func_80077AF8(s16* pValue, s16 target, s16 step)
-{
+s32 func_80077AF8(s16* pValue, s16 target, s16 step) {
     s16 orig = *pValue;
 
     *pValue += step;
 
-    if (((*pValue - target) * ((s16)orig - target)) <= 0)
-    {
+    if (((*pValue - target) * ((s16)orig - target)) <= 0) {
         *pValue = target;
         return 1;
     }
@@ -129,50 +109,41 @@ s32 func_80077AF8(s16* pValue, s16 target, s16 step)
     return 0;
 }
 
-s32 func_80077B58(s16* pValue, s16 target, s16 step)
-{
+s32 func_80077B58(s16* pValue, s16 target, s16 step) {
     s32 phi_v0 = target - *pValue;
 
-    if (phi_v0 < 0)
+    if (phi_v0 < 0) {
         step = -step;
+    }
 
-    if (phi_v0 >= 0x8000)
-    {
+    if (phi_v0 >= 0x8000) {
         step = -step;
         phi_v0 = 0xFFFF0001 - -phi_v0;
-    }
-    else if (phi_v0 <= -0x8000)
-    {
+    } else if (phi_v0 <= -0x8000) {
         phi_v0 += 0xFFFF;
         step = -step;
     }
 
-    if (step != 0)
-    {
+    if (step != 0) {
         *pValue += step;
 
-        if ((phi_v0 * step) <= 0)
-        {
+        if ((phi_v0 * step) <= 0) {
             *pValue = target;
             return 1;
         }
-    }
-    else if (target == *pValue)
-    {
+    } else if (target == *pValue) {
         return 1;
     }
 
     return 0;
 }
 
-s32 func_80077C1C(f32* pValue, f32 target, f32 step)
-{
+s32 func_80077C1C(f32* pValue, f32 target, f32 step) {
     f32 orig = *pValue;
 
     *pValue += step;
 
-    if (((*pValue - target) * (orig - target)) <= 0)
-    {
+    if (((*pValue - target) * (orig - target)) <= 0) {
         *pValue = target;
         return 1;
     }
@@ -180,40 +151,34 @@ s32 func_80077C1C(f32* pValue, f32 target, f32 step)
     return 0;
 }
 
-s32 func_80077C6C(f32* pValue, f32 target, f32 incrStep, f32 decrStep)
-{
+s32 func_80077C6C(f32* pValue, f32 target, f32 incrStep, f32 decrStep) {
     f32 step = (target >= *pValue) ? incrStep : decrStep;
 
-    if (step != 0.0f)
-    {
-        if (target < *pValue)
+    if (step != 0.0f) {
+        if (target < *pValue) {
             step = -step;
+        }
 
         *pValue += step;
 
-        if (((*pValue - target) * step) >= 0)
-        {
+        if (((*pValue - target) * step) >= 0) {
             *pValue = target;
             return 1;
         }
-    }
-    else if (target == *pValue)
-    {
+    } else if (target == *pValue) {
         return 1;
     }
 
     return 0;
 }
 
-typedef struct
-{
+typedef struct {
     /* 0x00 */ char unk_00[0x14];
-    /* 0x14 */ s8   unk_14;
-    /* 0x14 */ s8   unk_15;
+    /* 0x14 */ s8 unk_14;
+    /* 0x14 */ s8 unk_15;
 } struct_80077D10;
 
-void func_80077D10(f32* arg0, s16* arg1, struct_80077D10* arg2)
-{
+void func_80077D10(f32* arg0, s16* arg1, struct_80077D10* arg2) {
     f32 var1 = arg2->unk_14;
     f32 var2 = arg2->unk_15;
 
@@ -223,60 +188,51 @@ void func_80077D10(f32* arg0, s16* arg1, struct_80077D10* arg2)
     *arg1 = atan2s(var2, -var1);
 }
 
-s16 Math_Rand_S16Offset(s16 base, s16 range)
-{
+s16 Math_Rand_S16Offset(s16 base, s16 range) {
     return (s16)(Math_Rand_ZeroOne() * range) + base;
 }
 
-s16 Math_Rand_S16OffsetStride(s16 base, s16 stride, s16 range)
-{
+s16 Math_Rand_S16OffsetStride(s16 base, s16 stride, s16 range) {
     return (s16)(Math_Rand_ZeroOne() * range) * stride + base;
 }
 
-void Math_Vec3f_Copy(Vec3f* dest, Vec3f* src)
-{
+void Math_Vec3f_Copy(Vec3f* dest, Vec3f* src) {
     dest->x = src->x;
     dest->y = src->y;
     dest->z = src->z;
 }
 
-void Math_Vec3s_ToVec3f(Vec3f* dest, Vec3s* src)
-{
+void Math_Vec3s_ToVec3f(Vec3f* dest, Vec3s* src) {
     dest->x = src->x;
     dest->y = src->y;
     dest->z = src->z;
 }
 
-void Math_Vec3f_Sum(Vec3f* a, Vec3f* b, Vec3f* dest)
-{
+void Math_Vec3f_Sum(Vec3f* a, Vec3f* b, Vec3f* dest) {
     dest->x = a->x + b->x;
     dest->y = a->y + b->y;
     dest->z = a->z + b->z;
 }
 
-void Math_Vec3f_Diff(Vec3f* a, Vec3f* b, Vec3f* dest)
-{
+void Math_Vec3f_Diff(Vec3f* a, Vec3f* b, Vec3f* dest) {
     dest->x = a->x - b->x;
     dest->y = a->y - b->y;
     dest->z = a->z - b->z;
 }
 
-void Math_Vec3s_DiffToVec3f(Vec3f* dest, Vec3s* a, Vec3s* b)
-{
+void Math_Vec3s_DiffToVec3f(Vec3f* dest, Vec3s* a, Vec3s* b) {
     dest->x = a->x - b->x;
     dest->y = a->y - b->y;
     dest->z = a->z - b->z;
 }
 
-void Math_Vec3f_Scale(Vec3f* vec, f32 scaleF)
-{
+void Math_Vec3f_Scale(Vec3f* vec, f32 scaleF) {
     vec->x *= scaleF;
     vec->y *= scaleF;
     vec->z *= scaleF;
 }
 
-f32 Math_Vec3f_DistXYZ(Vec3f* a, Vec3f* b)
-{
+f32 Math_Vec3f_DistXYZ(Vec3f* a, Vec3f* b) {
     f32 dx = b->x - a->x;
     f32 dy = b->y - a->y;
     f32 dz = b->z - a->z;
@@ -284,8 +240,7 @@ f32 Math_Vec3f_DistXYZ(Vec3f* a, Vec3f* b)
     return sqrtf(SQ(dx) + SQ(dy) + SQ(dz));
 }
 
-f32 Math_Vec3f_DistXYZAndStoreDiff(Vec3f* a, Vec3f* b, Vec3f* dest)
-{
+f32 Math_Vec3f_DistXYZAndStoreDiff(Vec3f* a, Vec3f* b, Vec3f* dest) {
     dest->x = b->x - a->x;
     dest->y = b->y - a->y;
     dest->z = b->z - a->z;
@@ -293,29 +248,25 @@ f32 Math_Vec3f_DistXYZAndStoreDiff(Vec3f* a, Vec3f* b, Vec3f* dest)
     return sqrtf(SQ(dest->x) + SQ(dest->y) + SQ(dest->z));
 }
 
-f32 Math_Vec3f_DistXZ(Vec3f* a, Vec3f* b)
-{
+f32 Math_Vec3f_DistXZ(Vec3f* a, Vec3f* b) {
     f32 dx = b->x - a->x;
     f32 dz = b->z - a->z;
 
     return sqrtf(SQ(dx) + SQ(dz));
 }
 
-f32 Math_Vec3f_DiffY(Vec3f* a, Vec3f* b)
-{
+f32 Math_Vec3f_DiffY(Vec3f* a, Vec3f* b) {
     return b->y - a->y;
 }
 
-s16 Math_Vec3f_Yaw(Vec3f* a, Vec3f* b)
-{
+s16 Math_Vec3f_Yaw(Vec3f* a, Vec3f* b) {
     f32 dx = b->x - a->x;
     f32 dz = b->z - a->z;
 
     return atan2s(dz, dx);
 }
 
-s16 Math_Vec3f_Pitch(Vec3f* a, Vec3f* b)
-{
+s16 Math_Vec3f_Pitch(Vec3f* a, Vec3f* b) {
     return atan2s(Math_Vec3f_DistXZ(a, b), a->y - b->y);
 }
 
@@ -331,69 +282,51 @@ void IChain_Apply_Vec3f(u8* ptr, InitChainEntry* ichain);
 void IChain_Apply_Vec3fdiv1000(u8* ptr, InitChainEntry* ichain);
 void IChain_Apply_Vec3s(u8* ptr, InitChainEntry* ichain);
 
-void (*sInitChainHandlers[])(u8* ptr, InitChainEntry* ichain) =
-{
-    IChain_Apply_u8,
-    IChain_Apply_s8,
-    IChain_Apply_u16,
-    IChain_Apply_s16,
-    IChain_Apply_u32,
-    IChain_Apply_s32,
-    IChain_Apply_f32,
-    IChain_Apply_f32div1000,
-    IChain_Apply_Vec3f,
-    IChain_Apply_Vec3fdiv1000,
-    IChain_Apply_Vec3s,
+void (*sInitChainHandlers[])(u8* ptr, InitChainEntry* ichain) = {
+    IChain_Apply_u8,    IChain_Apply_s8,           IChain_Apply_u16,   IChain_Apply_s16,
+    IChain_Apply_u32,   IChain_Apply_s32,          IChain_Apply_f32,   IChain_Apply_f32div1000,
+    IChain_Apply_Vec3f, IChain_Apply_Vec3fdiv1000, IChain_Apply_Vec3s,
 };
 
-void Actor_ProcessInitChain(Actor* actor, InitChainEntry* ichain)
-{
-    do sInitChainHandlers[ichain->type]((u8*)actor, ichain);
-    while ((ichain++)->cont);
+void Actor_ProcessInitChain(Actor* actor, InitChainEntry* ichain) {
+    do {
+        sInitChainHandlers[ichain->type]((u8*)actor, ichain);
+    } while ((ichain++)->cont);
 }
 
-void IChain_Apply_u8(u8* ptr, InitChainEntry* ichain)
-{
+void IChain_Apply_u8(u8* ptr, InitChainEntry* ichain) {
     *(u8*)(ptr + ichain->offset) = ichain->value;
 }
 
-void IChain_Apply_s8(u8* ptr, InitChainEntry* ichain)
-{
+void IChain_Apply_s8(u8* ptr, InitChainEntry* ichain) {
     *(s8*)(ptr + ichain->offset) = ichain->value;
 }
 
-void IChain_Apply_u16(u8* ptr, InitChainEntry* ichain)
-{
+void IChain_Apply_u16(u8* ptr, InitChainEntry* ichain) {
     *(u16*)(ptr + ichain->offset) = ichain->value;
 }
 
-void IChain_Apply_s16(u8* ptr, InitChainEntry* ichain)
-{
+void IChain_Apply_s16(u8* ptr, InitChainEntry* ichain) {
     *(s16*)(ptr + ichain->offset) = ichain->value;
 }
 
-void IChain_Apply_u32(u8* ptr, InitChainEntry* ichain)
-{
+void IChain_Apply_u32(u8* ptr, InitChainEntry* ichain) {
     *(u32*)(ptr + ichain->offset) = ichain->value;
 }
 
-void IChain_Apply_s32(u8* ptr, InitChainEntry* ichain)
-{
+void IChain_Apply_s32(u8* ptr, InitChainEntry* ichain) {
     *(s32*)(ptr + ichain->offset) = ichain->value;
 }
 
-void IChain_Apply_f32(u8* ptr, InitChainEntry* ichain)
-{
+void IChain_Apply_f32(u8* ptr, InitChainEntry* ichain) {
     *(f32*)(ptr + ichain->offset) = ichain->value;
 }
 
-void IChain_Apply_f32div1000(u8* ptr, InitChainEntry* ichain)
-{
+void IChain_Apply_f32div1000(u8* ptr, InitChainEntry* ichain) {
     *(f32*)(ptr + ichain->offset) = ichain->value / 1000.0f;
 }
 
-void IChain_Apply_Vec3f(u8* ptr, InitChainEntry* ichain)
-{
+void IChain_Apply_Vec3f(u8* ptr, InitChainEntry* ichain) {
     Vec3f* vec;
     f32 val;
 
@@ -405,8 +338,7 @@ void IChain_Apply_Vec3f(u8* ptr, InitChainEntry* ichain)
     vec->x = val;
 }
 
-void IChain_Apply_Vec3fdiv1000(u8* ptr, InitChainEntry* ichain)
-{
+void IChain_Apply_Vec3fdiv1000(u8* ptr, InitChainEntry* ichain) {
     Vec3f* vec;
     f32 val;
 
@@ -419,8 +351,7 @@ void IChain_Apply_Vec3fdiv1000(u8* ptr, InitChainEntry* ichain)
     vec->x = val;
 }
 
-void IChain_Apply_Vec3s(u8* ptr, InitChainEntry* ichain)
-{
+void IChain_Apply_Vec3s(u8* ptr, InitChainEntry* ichain) {
     Vec3s* vec;
     s16 val;
 
@@ -432,40 +363,37 @@ void IChain_Apply_Vec3s(u8* ptr, InitChainEntry* ichain)
     vec->x = val;
 }
 
-f32 Math_SmoothScaleMaxMinF(f32* pValue, f32 target, f32 scale, f32 maxStep, f32 minStep)
-{
+f32 Math_SmoothScaleMaxMinF(f32* pValue, f32 target, f32 scale, f32 maxStep, f32 minStep) {
     f32 var;
 
-    if (*pValue != target)
-    {
+    if (*pValue != target) {
         var = (target - *pValue) * scale;
 
-        if ((var >= minStep) || (var <= -minStep))
-        {
-            if (var > maxStep)
+        if ((var >= minStep) || (var <= -minStep)) {
+            if (var > maxStep) {
                 var = maxStep;
+            }
 
-            if (var < -maxStep)
+            if (var < -maxStep) {
                 var = -maxStep;
+            }
 
             *pValue += var;
-        }
-        else
-        {
-            if (var < minStep)
-            {
+        } else {
+            if (var < minStep) {
                 *pValue += minStep;
                 var = minStep;
 
-                if (target < *pValue)
+                if (target < *pValue) {
                     *pValue = target;
+                }
             }
-            if (var > -minStep)
-            {
+            if (var > -minStep) {
                 *pValue += -minStep;
 
-                if (*pValue < target)
+                if (*pValue < target) {
                     *pValue = target;
+                }
             }
         }
     }
@@ -473,174 +401,159 @@ f32 Math_SmoothScaleMaxMinF(f32* pValue, f32 target, f32 scale, f32 maxStep, f32
     return fabsf(target - *pValue);
 }
 
-void Math_SmoothScaleMaxF(f32* pValue, f32 target, f32 scale, f32 maxStep)
-{
+void Math_SmoothScaleMaxF(f32* pValue, f32 target, f32 scale, f32 maxStep) {
     f32 step;
 
-    if (*pValue != target)
-    {
+    if (*pValue != target) {
         step = (target - *pValue) * scale;
 
-        if (step > maxStep)
+        if (step > maxStep) {
             step = maxStep;
-        else if (step < -maxStep)
+        } else if (step < -maxStep) {
             step = -maxStep;
+        }
 
         *pValue += step;
     }
 }
 
-void Math_SmoothDownscaleMaxF(f32* pValue, f32 scale, f32 maxStep)
-{
+void Math_SmoothDownscaleMaxF(f32* pValue, f32 scale, f32 maxStep) {
     f32 step;
 
     step = *pValue * scale;
 
-    if (step > maxStep)
+    if (step > maxStep) {
         step = maxStep;
-    else if (step < -maxStep)
+    } else if (step < -maxStep) {
         step = -maxStep;
+    }
 
     *pValue -= step;
 }
 
-f32 func_800784D8(f32* pValue, f32 target, f32 scale, f32 maxStep, f32 minStep)
-{
+f32 func_800784D8(f32* pValue, f32 target, f32 scale, f32 maxStep, f32 minStep) {
     f32 step;
     f32 baseStep;
 
     step = 0.0f;
     baseStep = target - *pValue;
 
-    if (*pValue != target)
-    {
-        if (baseStep > 180.0f)
+    if (*pValue != target) {
+        if (baseStep > 180.0f) {
             baseStep = -(360.0f - baseStep);
-        else if (baseStep < -180.0f)
+        } else if (baseStep < -180.0f) {
             baseStep = 360.0f + baseStep;
+        }
 
         step = baseStep * scale;
 
-        if ((step >= minStep) || (step <= -minStep))
-        {
-            if (step > maxStep)
+        if ((step >= minStep) || (step <= -minStep)) {
+            if (step > maxStep) {
                 step = maxStep;
+            }
 
-            if (step < -maxStep)
+            if (step < -maxStep) {
                 step = -maxStep;
+            }
 
             *pValue += step;
-        }
-        else
-        {
-            if (step < minStep)
-            {
+        } else {
+            if (step < minStep) {
                 step = minStep;
                 *pValue += step;
-                if (*pValue > target)
+                if (*pValue > target) {
                     *pValue = target;
+                }
             }
-            if (step > -minStep)
-            {
+            if (step > -minStep) {
                 step = -minStep;
                 *pValue += step;
-                if (*pValue < target)
+                if (*pValue < target) {
                     *pValue = target;
+                }
             }
         }
     }
 
-    if (*pValue >= 360.0f)
+    if (*pValue >= 360.0f) {
         *pValue -= 360.0f;
+    }
 
-    if (*pValue < 0.0f)
+    if (*pValue < 0.0f) {
         *pValue += 360.0f;
+    }
 
     return step;
 }
 
-#ifdef NON_MATCHING
-// regalloc differences
-s16 Math_SmoothScaleMaxMinS(s16* pValue, s16 target, s16 invScale, s16 maxStep, s16 minStep)
-{
+s16 Math_SmoothScaleMaxMinS(s16* pValue, s16 target, s16 invScale, s16 maxStep, s16 minStep) {
+    s16 step = 0;
     s16 diff = (target - *pValue);
-    s32 baseStep;
-    s16 step;
 
-    baseStep = diff / invScale;
+    s32 baseStep = diff / invScale;
 
-    if (*pValue != target)
-    {
+    if (*pValue != target) {
         step = baseStep;
 
-        if ((step > minStep) || (step < -minStep))
-        {
-            if (step > maxStep)
+        if ((step > minStep) || (step < -minStep)) {
+            if (step > maxStep) {
                 step = maxStep;
+            }
 
-            if (step < -maxStep)
+            if (step < -maxStep) {
                 step = -maxStep;
+            }
 
             *pValue += step;
-        }
-        else
-        {
-            if (diff >= 0)
-            {
+        } else {
+            if (diff >= 0) {
                 *pValue += minStep;
 
-                if ((s16)(target - *pValue) <= 0)
+                if ((s16)(target - *pValue) <= 0) {
                     *pValue = target;
-            }
-            else
-            {
+                }
+            } else {
                 *pValue -= minStep;
 
-                if ((s16)(target - *pValue) >= 0)
+                if ((s16)(target - *pValue) >= 0) {
                     *pValue = target;
+                }
             }
         }
     }
 
     return diff;
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_lib/Math_SmoothScaleMaxMinS.s")
-#endif
 
-void Math_SmoothScaleMaxS(s16* pValue, s16 target, s16 invScale, s16 maxStep)
-{
+void Math_SmoothScaleMaxS(s16* pValue, s16 target, s16 invScale, s16 maxStep) {
     s16 step = target - *pValue;
 
     step /= invScale;
 
-    if (step > maxStep)
+    if (step > maxStep) {
         *pValue += maxStep;
-    else if (step < -maxStep)
+    } else if (step < -maxStep) {
         *pValue -= maxStep;
-    else
+    } else {
         *pValue += step;
+    }
 }
 
-void Color_RGBA8_Copy(Color_RGBA8* dst, Color_RGBA8* src)
-{
+void Color_RGBA8_Copy(Color_RGBA8* dst, Color_RGBA8* src) {
     dst->r = src->r;
     dst->g = src->g;
     dst->b = src->b;
     dst->a = src->a;
 }
 
-void func_80078884(u16 sfxId)
-{
+void func_80078884(u16 sfxId) {
     Audio_PlaySoundGeneral(sfxId, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
 }
 
-void func_800788CC(u16 sfxId)
-{
+void func_800788CC(u16 sfxId) {
     Audio_PlaySoundGeneral(sfxId, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
 }
 
-void func_80078914(Vec3f* arg0, u16 sfxId)
-{
+void func_80078914(Vec3f* arg0, u16 sfxId) {
     Audio_PlaySoundGeneral(sfxId, arg0, 4, &D_801333E0, &D_801333E0, &D_801333E8);
 }
diff --git a/src/code/z_lifemeter.c b/src/code/z_lifemeter.c
index f67235c4a..cd430e55a 100644
--- a/src/code/z_lifemeter.c
+++ b/src/code/z_lifemeter.c
@@ -17,8 +17,7 @@ s16 D_8015FDC8[3];
 s16 D_8015FDD0[6];
 s16 D_8015FDE0[6];
 
-void Health_InitData(GlobalContext* globalCtx)
-{
+void Health_InitData(GlobalContext* globalCtx) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
 
     interfaceCtx->unk_228 = 0x140;
@@ -49,29 +48,23 @@ void Health_InitData(GlobalContext* globalCtx)
 }
 
 #ifdef NON_MATCHING
-// this function still needs some work
-void Health_UpdateData(GlobalContext* globalCtx)
-{
+// this function still needs some work but it should be functionally equivalent
+void Health_UpdateData(GlobalContext* globalCtx) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
     f32 temp_f0 = interfaceCtx->unk_1FE * 0.1f;
     s16 temp1, temp2, temp3;
 
-    if (0) ;
+    if (0) {}
 
-    if (interfaceCtx->unk_200 != 0)
-    {
+    if (interfaceCtx->unk_200 != 0) {
         interfaceCtx->unk_1FE--;
-        if (interfaceCtx->unk_1FE <= 0)
-        {
+        if (interfaceCtx->unk_1FE <= 0) {
             interfaceCtx->unk_1FE = 0;
             interfaceCtx->unk_200 = 0;
         }
-    }
-    else
-    {
+    } else {
         interfaceCtx->unk_1FE++;
-        if (interfaceCtx->unk_1FE >= 10)
-        {
+        if (interfaceCtx->unk_1FE >= 10) {
             interfaceCtx->unk_1FE = 10;
             interfaceCtx->unk_200 = 1;
         }
@@ -153,21 +146,18 @@ void Health_UpdateData(GlobalContext* globalCtx)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_lifemeter/Health_UpdateData.s")
 #endif
 
-s32 func_80078E18(GlobalContext* globalCtx)
-{
+s32 func_80078E18(GlobalContext* globalCtx) {
     gSaveContext.health = globalCtx->interfaceCtx.unk_226;
     return 1;
 }
 
-s32 func_80078E34(GlobalContext* globalCtx)
-{
+s32 func_80078E34(GlobalContext* globalCtx) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
 
     interfaceCtx->unk_228 = 0x140;
     interfaceCtx->unk_226 += 0x10;
 
-    if (interfaceCtx->unk_226 >= gSaveContext.health)
-    {
+    if (interfaceCtx->unk_226 >= gSaveContext.health) {
         interfaceCtx->unk_226 = gSaveContext.health;
         return 1;
     }
@@ -175,21 +165,16 @@ s32 func_80078E34(GlobalContext* globalCtx)
     return 0;
 }
 
-s32 func_80078E84(GlobalContext* globalCtx)
-{
+s32 func_80078E84(GlobalContext* globalCtx) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
 
-    if (interfaceCtx->unk_228 != 0)
-    {
+    if (interfaceCtx->unk_228 != 0) {
         interfaceCtx->unk_228--;
-    }
-    else
-    {
+    } else {
         interfaceCtx->unk_228 = 0x140;
         interfaceCtx->unk_226 -= 0x10;
 
-        if (interfaceCtx->unk_226 <= 0)
-        {
+        if (interfaceCtx->unk_226 <= 0) {
             interfaceCtx->unk_226 = 0;
             globalCtx->unk_11D58(globalCtx, -(gSaveContext.health + 1));
             return 1;
@@ -199,8 +184,7 @@ s32 func_80078E84(GlobalContext* globalCtx)
     return 0;
 }
 
-void Interface_DrawHealth(GlobalContext* globalCtx)
-{
+void Interface_DrawHealth(GlobalContext* globalCtx) {
     s32 pad[5];
     u8* heartBgImg;
     u32 curColorSet;
@@ -222,188 +206,131 @@ void Interface_DrawHealth(GlobalContext* globalCtx)
     s32 curCombineModeSet = 0;
     u8* curBgImgLoaded = NULL;
     s32 ddHeartCountMinusOne = gSaveContext.defense_hearts - 1;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_lifemeter.c", 353);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_lifemeter.c", 353);
 
-    if (!(gSaveContext.health % 0x10))
+    if (!(gSaveContext.health % 0x10)) {
         fullHeartCount--;
+    }
 
     curColorSet = -1;
     offsetY = 0.0f;
     offsetX = 0.0f;
 
-    for (i = 0; i < totalHeartCount; i++)
-    {
-        if ((ddHeartCountMinusOne < 0) || (i > ddHeartCountMinusOne))
-        {
-            if (i < fullHeartCount)
-            {
-                if (curColorSet != 0)
-                {
+    for (i = 0; i < totalHeartCount; i++) {
+        if ((ddHeartCountMinusOne < 0) || (i > ddHeartCountMinusOne)) {
+            if (i < fullHeartCount) {
+                if (curColorSet != 0) {
                     curColorSet = 0;
                     gDPPipeSync(gfxCtx->overlay.p++);
-                    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                                    interfaceCtx->unk_20E[0], interfaceCtx->unk_20E[2],
+                    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, interfaceCtx->unk_20E[0], interfaceCtx->unk_20E[2],
                                     interfaceCtx->unk_20E[4], interfaceCtx->healthAlpha);
-                    gDPSetEnvColor(gfxCtx->overlay.p++,
-                                   interfaceCtx->unk_21A[0], interfaceCtx->unk_21A[2],
+                    gDPSetEnvColor(gfxCtx->overlay.p++, interfaceCtx->unk_21A[0], interfaceCtx->unk_21A[2],
                                    interfaceCtx->unk_21A[4], 0xFF);
                 }
-            }
-            else if (i == fullHeartCount)
-            {
-                if (curColorSet != 1)
-                {
+            } else if (i == fullHeartCount) {
+                if (curColorSet != 1) {
                     curColorSet = 1;
                     gDPPipeSync(gfxCtx->overlay.p++);
-                    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                                    interfaceCtx->unk_202[0], interfaceCtx->unk_202[1],
+                    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, interfaceCtx->unk_202[0], interfaceCtx->unk_202[1],
                                     interfaceCtx->unk_202[2], interfaceCtx->healthAlpha);
-                    gDPSetEnvColor(gfxCtx->overlay.p++,
-                                   interfaceCtx->unk_208[0], interfaceCtx->unk_208[1],
+                    gDPSetEnvColor(gfxCtx->overlay.p++, interfaceCtx->unk_208[0], interfaceCtx->unk_208[1],
                                    interfaceCtx->unk_208[2], 0xFF);
                 }
-            }
-            else if (i > fullHeartCount)
-            {
-                if (curColorSet != 2)
-                {
+            } else if (i > fullHeartCount) {
+                if (curColorSet != 2) {
                     curColorSet = 2;
                     gDPPipeSync(gfxCtx->overlay.p++);
-                    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                                    interfaceCtx->unk_20E[0], interfaceCtx->unk_20E[2],
+                    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, interfaceCtx->unk_20E[0], interfaceCtx->unk_20E[2],
                                     interfaceCtx->unk_20E[4], interfaceCtx->healthAlpha);
-                    gDPSetEnvColor(gfxCtx->overlay.p++,
-                                   interfaceCtx->unk_21A[0], interfaceCtx->unk_21A[2],
+                    gDPSetEnvColor(gfxCtx->overlay.p++, interfaceCtx->unk_21A[0], interfaceCtx->unk_21A[2],
                                    interfaceCtx->unk_21A[4], 0xFF);
                 }
-            }
-            else
-            {
-                if (curColorSet != 3)
-                {
+            } else {
+                if (curColorSet != 3) {
                     curColorSet = 3;
                     gDPPipeSync(gfxCtx->overlay.p++);
-                    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                                    interfaceCtx->unk_20E[1], interfaceCtx->unk_20E[3],
+                    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, interfaceCtx->unk_20E[1], interfaceCtx->unk_20E[3],
                                     interfaceCtx->unk_20E[5], interfaceCtx->healthAlpha);
-                    gDPSetEnvColor(gfxCtx->overlay.p++,
-                                   interfaceCtx->unk_21A[1], interfaceCtx->unk_21A[3],
+                    gDPSetEnvColor(gfxCtx->overlay.p++, interfaceCtx->unk_21A[1], interfaceCtx->unk_21A[3],
                                    interfaceCtx->unk_21A[5], 0xFF);
                 }
             }
 
-            if (i < fullHeartCount)
+            if (i < fullHeartCount) {
                 heartBgImg = D_02000400;
-            else if (i == fullHeartCount)
+            } else if (i == fullHeartCount) {
                 heartBgImg = D_8011FFB0[curHeartFraction];
-            else
+            } else {
                 heartBgImg = D_02000000;
-        }
-        else
-        {
-            if (i < fullHeartCount)
-            {
-                if (curColorSet != 4)
-                {
+            }
+        } else {
+            if (i < fullHeartCount) {
+                if (curColorSet != 4) {
                     curColorSet = 4;
                     gDPPipeSync(gfxCtx->overlay.p++);
-                    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                                    D_8015FDD0[0], D_8015FDD0[1],
-                                    D_8015FDD0[2], interfaceCtx->healthAlpha);
-                    gDPSetEnvColor(gfxCtx->overlay.p++,
-                                   D_8015FDE0[0], D_8015FDE0[1],
-                                   D_8015FDE0[2], 0xFF);
+                    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, D_8015FDD0[0], D_8015FDD0[1], D_8015FDD0[2],
+                                    interfaceCtx->healthAlpha);
+                    gDPSetEnvColor(gfxCtx->overlay.p++, D_8015FDE0[0], D_8015FDE0[1], D_8015FDE0[2], 0xFF);
                 }
-            }
-            else if (i == fullHeartCount)
-            {
-                if (curColorSet != 5)
-                {
+            } else if (i == fullHeartCount) {
+                if (curColorSet != 5) {
                     curColorSet = 5;
                     gDPPipeSync(gfxCtx->overlay.p++);
-                    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                                    D_8015FDC0[0], D_8015FDC0[1],
-                                    D_8015FDC0[2], interfaceCtx->healthAlpha);
-                    gDPSetEnvColor(gfxCtx->overlay.p++,
-                                   D_8015FDC8[0], D_8015FDC8[1],
-                                   D_8015FDC8[2], 0xFF);
+                    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, D_8015FDC0[0], D_8015FDC0[1], D_8015FDC0[2],
+                                    interfaceCtx->healthAlpha);
+                    gDPSetEnvColor(gfxCtx->overlay.p++, D_8015FDC8[0], D_8015FDC8[1], D_8015FDC8[2], 0xFF);
                 }
-            }
-            else if (i > fullHeartCount)
-            {
-                if (curColorSet != 6)
-                {
+            } else if (i > fullHeartCount) {
+                if (curColorSet != 6) {
                     curColorSet = 6;
                     gDPPipeSync(gfxCtx->overlay.p++);
-                    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                                    D_8015FDD0[0], D_8015FDD0[1],
-                                    D_8015FDD0[2], interfaceCtx->healthAlpha);
-                    gDPSetEnvColor(gfxCtx->overlay.p++,
-                                   D_8015FDE0[0], D_8015FDE0[1],
-                                   D_8015FDE0[2], 0xFF);
+                    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, D_8015FDD0[0], D_8015FDD0[1], D_8015FDD0[2],
+                                    interfaceCtx->healthAlpha);
+                    gDPSetEnvColor(gfxCtx->overlay.p++, D_8015FDE0[0], D_8015FDE0[1], D_8015FDE0[2], 0xFF);
                 }
-            }
-            else
-            {
-                if (curColorSet != 7)
-                {
+            } else {
+                if (curColorSet != 7) {
                     curColorSet = 7;
                     gDPPipeSync(gfxCtx->overlay.p++);
-                    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                                    D_8015FDD0[3], D_8015FDD0[4],
-                                    D_8015FDD0[5], interfaceCtx->healthAlpha);
-                    gDPSetEnvColor(gfxCtx->overlay.p++,
-                                   D_8015FDE0[3], D_8015FDE0[4],
-                                   D_8015FDE0[5], 0xFF);
+                    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, D_8015FDD0[3], D_8015FDD0[4], D_8015FDD0[5],
+                                    interfaceCtx->healthAlpha);
+                    gDPSetEnvColor(gfxCtx->overlay.p++, D_8015FDE0[3], D_8015FDE0[4], D_8015FDE0[5], 0xFF);
                 }
             }
 
-            if (i < fullHeartCount)
+            if (i < fullHeartCount) {
                 heartBgImg = D_02000900;
-            else if (i == fullHeartCount)
+            } else if (i == fullHeartCount) {
                 heartBgImg = D_8011FFF0[curHeartFraction];
-            else
+            } else {
                 heartBgImg = D_02000500;
+            }
         }
 
-        if (curBgImgLoaded != heartBgImg)
-        {
+        if (curBgImgLoaded != heartBgImg) {
             curBgImgLoaded = heartBgImg;
-            gDPLoadTextureBlock(gfxCtx->overlay.p++,
-                                heartBgImg,
-                                G_IM_FMT_IA,
-                                G_IM_SIZ_8b,
-                                16, 16,
-                                0,
-                                G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP,
-                                G_TX_NOMASK, G_TX_NOMASK,
+            gDPLoadTextureBlock(gfxCtx->overlay.p++, heartBgImg, G_IM_FMT_IA, G_IM_SIZ_8b, 16, 16, 0,
+                                G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
                                 G_TX_NOLOD, G_TX_NOLOD);
         }
 
-        if (i != fullHeartCount)
-        {
-            if ((ddHeartCountMinusOne < 0) || (i > ddHeartCountMinusOne))
-            {
-                if (curCombineModeSet != 1)
-                {
+        if (i != fullHeartCount) {
+            if ((ddHeartCountMinusOne < 0) || (i > ddHeartCountMinusOne)) {
+                if (curCombineModeSet != 1) {
                     curCombineModeSet = 1;
                     func_80094520(gfxCtx);
-                    gDPSetCombineLERP(gfxCtx->overlay.p++,
-                                      PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
-                                      PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
+                    gDPSetCombineLERP(gfxCtx->overlay.p++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0,
+                                      PRIMITIVE, 0, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE,
+                                      0);
                 }
-            }
-            else
-            {
-                if (curCombineModeSet != 3)
-                {
+            } else {
+                if (curCombineModeSet != 3) {
                     curCombineModeSet = 3;
                     func_80094520(gfxCtx);
-                    gDPSetCombineLERP(gfxCtx->overlay.p++,
-                                      ENVIRONMENT, PRIMITIVE, TEXEL0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0,
-                                      ENVIRONMENT, PRIMITIVE, TEXEL0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0);
+                    gDPSetCombineLERP(gfxCtx->overlay.p++, ENVIRONMENT, PRIMITIVE, TEXEL0, PRIMITIVE, TEXEL0, 0,
+                                      PRIMITIVE, 0, ENVIRONMENT, PRIMITIVE, TEXEL0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0);
                 }
             }
 
@@ -414,40 +341,28 @@ void Interface_DrawHealth(GlobalContext* globalCtx)
             temp4 *= 1024.0f;
             temp1 = 8.0f;
             temp1 *= 0.68f;
-            gSPTextureRectangle(gfxCtx->overlay.p++,
-                                (s32)((temp2 - temp1) * 4), (s32)((temp3 - temp1) * 4),
-                                (s32)((temp2 + temp1) * 4), (s32)((temp3 + temp1) * 4),
-                                G_TX_RENDERTILE,
-                                0, 0,
+            gSPTextureRectangle(gfxCtx->overlay.p++, (s32)((temp2 - temp1) * 4), (s32)((temp3 - temp1) * 4),
+                                (s32)((temp2 + temp1) * 4), (s32)((temp3 + temp1) * 4), G_TX_RENDERTILE, 0, 0,
                                 (s32)temp4, (s32)temp4);
-        }
-        else
-        {
-            if ((ddHeartCountMinusOne < 0) || (i > ddHeartCountMinusOne))
-            {
-                if (curCombineModeSet != 2)
-                {
+        } else {
+            if ((ddHeartCountMinusOne < 0) || (i > ddHeartCountMinusOne)) {
+                if (curCombineModeSet != 2) {
                     curCombineModeSet = 2;
                     func_80094A14(gfxCtx);
-                    gDPSetCombineLERP(gfxCtx->overlay.p++,
-                                      PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
-                                      PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
+                    gDPSetCombineLERP(gfxCtx->overlay.p++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0,
+                                      PRIMITIVE, 0, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE,
+                                      0);
                 }
-            }
-            else
-            {
-                if (curCombineModeSet != 4)
-                {
+            } else {
+                if (curCombineModeSet != 4) {
                     curCombineModeSet = 4;
                     func_80094A14(gfxCtx);
-                    gDPSetCombineLERP(gfxCtx->overlay.p++,
-                                      ENVIRONMENT, PRIMITIVE, TEXEL0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0,
-                                      ENVIRONMENT, PRIMITIVE, TEXEL0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0);
+                    gDPSetCombineLERP(gfxCtx->overlay.p++, ENVIRONMENT, PRIMITIVE, TEXEL0, PRIMITIVE, TEXEL0, 0,
+                                      PRIMITIVE, 0, ENVIRONMENT, PRIMITIVE, TEXEL0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0);
                 }
             }
 
-            if (1)
-            {
+            if (1) {
                 Mtx* matrix = Graph_Alloc(gfxCtx, sizeof(Mtx));
                 func_800D2CEC(matrix, 1.0f - (0.32f * sp144), 1.0f - (0.32f * sp144), 1.0f - (0.32f * sp144),
                               -130.0f + offsetX, 94.5f - offsetY, 0.0f);
@@ -458,62 +373,55 @@ void Interface_DrawHealth(GlobalContext* globalCtx)
         }
 
         offsetX += 10.0f;
-        if (i == 9)
-        {
+        if (i == 9) {
             offsetY += 10.0f;
             offsetX = 0.0f;
         }
     }
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_lifemeter.c", 606);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_lifemeter.c", 606);
 }
 
 u32 Health_IsCritical(void);
 
-void Health_HandleCriticalAlarm(GlobalContext* globalCtx)
-{
+void Health_HandleCriticalAlarm(GlobalContext* globalCtx) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
 
-    if (interfaceCtx->unk_22C != 0)
-    {
+    if (interfaceCtx->unk_22C != 0) {
         interfaceCtx->unk_22A--;
-        if (interfaceCtx->unk_22A <= 0)
-        {
+        if (interfaceCtx->unk_22A <= 0) {
             interfaceCtx->unk_22A = 0;
             interfaceCtx->unk_22C = 0;
-            if (!func_8008E988(globalCtx) && (globalCtx->pauseCtx.state == 0) &&
-                (globalCtx->pauseCtx.flag == 0) && Health_IsCritical() && !func_800BFC84(globalCtx))
-            {
+            if (!func_8008E988(globalCtx) && (globalCtx->pauseCtx.state == 0) && (globalCtx->pauseCtx.flag == 0) &&
+                Health_IsCritical() && !func_800BFC84(globalCtx)) {
                 func_80078884(NA_SE_SY_HITPOINT_ALARM);
             }
         }
-    }
-    else
-    {
+    } else {
         interfaceCtx->unk_22A++;
-        if (interfaceCtx->unk_22A >= 10)
-        {
+        if (interfaceCtx->unk_22A >= 10) {
             interfaceCtx->unk_22A = 10;
             interfaceCtx->unk_22C = 1;
         }
     }
 }
 
-u32 Health_IsCritical(void)
-{
+u32 Health_IsCritical(void) {
     s32 var;
 
-    if (gSaveContext.health_capacity <= 0x50)
+    if (gSaveContext.health_capacity <= 0x50) {
         var = 0x10;
-    else if (gSaveContext.health_capacity <= 0xA0)
+    } else if (gSaveContext.health_capacity <= 0xA0) {
         var = 0x18;
-    else if (gSaveContext.health_capacity <= 0xF0)
+    } else if (gSaveContext.health_capacity <= 0xF0) {
         var = 0x20;
-    else
+    } else {
         var = 0x2C;
+    }
 
-    if ((var >= gSaveContext.health) && (gSaveContext.health > 0))
+    if ((var >= gSaveContext.health) && (gSaveContext.health > 0)) {
         return 1;
-    else
+    } else {
         return 0;
+    }
 }
diff --git a/src/code/z_lights.c b/src/code/z_lights.c
index af6dbad51..46e61fa25 100644
--- a/src/code/z_lights.c
+++ b/src/code/z_lights.c
@@ -3,8 +3,8 @@
 
 extern LightsList sLightsList;
 
-void Lights_InitPositionalLight(LightInfoPositional* info, s16 posX, s16 posY, s16 posZ, u8 red, u8 green, u8 blue, s16 radius, u32 type)
-{
+void Lights_InitPositionalLight(LightInfoPositional* info, s16 posX, s16 posY, s16 posZ, u8 red, u8 green, u8 blue,
+                                s16 radius, u32 type) {
     info->type = type;
     info->params.posX = posX;
     info->params.posY = posY;
@@ -12,26 +12,24 @@ void Lights_InitPositionalLight(LightInfoPositional* info, s16 posX, s16 posY, s
     Lights_SetPositionalLightColorAndRadius(info, red, green, blue, radius);
 }
 
-void Lights_InitType0PositionalLight(LightInfoPositional* info, s16 posX, s16 posY, s16 posZ, u8 red, u8 green, u8 blue, s16 radius)
-{
+void Lights_InitType0PositionalLight(LightInfoPositional* info, s16 posX, s16 posY, s16 posZ, u8 red, u8 green, u8 blue,
+                                     s16 radius) {
     Lights_InitPositionalLight(info, posX, posY, posZ, red, green, blue, radius, 0);
 }
 
-void Lights_InitType2PositionalLight(LightInfoPositional* info, s16 posX, s16 posY, s16 posZ, u8 red, u8 green, u8 blue, s16 radius)
-{
+void Lights_InitType2PositionalLight(LightInfoPositional* info, s16 posX, s16 posY, s16 posZ, u8 red, u8 green, u8 blue,
+                                     s16 radius) {
     Lights_InitPositionalLight(info, posX, posY, posZ, red, green, blue, radius, 2);
 }
 
-void Lights_SetPositionalLightColorAndRadius(LightInfoPositional* info, u8 red, u8 green, u8 blue, s16 radius)
-{
+void Lights_SetPositionalLightColorAndRadius(LightInfoPositional* info, u8 red, u8 green, u8 blue, s16 radius) {
     info->params.red = red;
     info->params.green = green;
     info->params.blue = blue;
     info->params.radius = radius;
 }
 
-void Lights_InitDirectional(LightInfoDirectional* info, s8 dirX, s8 dirY, s8 dirZ, u8 red, u8 green, u8 blue)
-{
+void Lights_InitDirectional(LightInfoDirectional* info, s8 dirX, s8 dirY, s8 dirZ, u8 red, u8 green, u8 blue) {
     info->type = 1;
     info->params.dirX = dirX;
     info->params.dirY = dirY;
@@ -41,8 +39,7 @@ void Lights_InitDirectional(LightInfoDirectional* info, s8 dirX, s8 dirY, s8 dir
     info->params.blue = blue;
 }
 
-void Lights_MapperInit(LightMapper* mapper, u8 red, u8 green, u8 blue)
-{
+void Lights_MapperInit(LightMapper* mapper, u8 red, u8 green, u8 blue) {
     mapper->ambient.l.col[0] = red;
     mapper->ambient.l.colc[0] = red;
     mapper->ambient.l.col[1] = green;
@@ -54,22 +51,20 @@ void Lights_MapperInit(LightMapper* mapper, u8 red, u8 green, u8 blue)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_lights/func_80079EFC.s")
 
-Light* Lights_MapperGetNextFreeSlot(LightMapper* mapper)
-{
-    if (6 < mapper->numLights)
+Light* Lights_MapperGetNextFreeSlot(LightMapper* mapper) {
+    if (6 < mapper->numLights) {
         return NULL;
+    }
 
     return &mapper->lights[mapper->numLights++];
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_lights/func_8007A084.s")
 
-void func_8007A40C(LightMapper* mapper, LightInfoDirectionalParams* params, GlobalContext* globalCtx)
-{
+void func_8007A40C(LightMapper* mapper, LightInfoDirectionalParams* params, GlobalContext* globalCtx) {
     Light* light = Lights_MapperGetNextFreeSlot(mapper);
 
-    if (light != NULL)
-    {
+    if (light != NULL) {
         light->l.col[0] = light->l.colc[0] = params->red;
         light->l.col[1] = light->l.colc[1] = params->green;
         light->l.col[2] = light->l.colc[2] = params->blue;
@@ -81,25 +76,21 @@ void func_8007A40C(LightMapper* mapper, LightInfoDirectionalParams* params, Glob
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_lights/func_8007A474.s")
 
-z_Light* Lights_FindFreeSlot()
-{
+z_Light* Lights_FindFreeSlot() {
     z_Light* ret;
 
-    if (0x1F < sLightsList.numOccupied)
+    if (0x1F < sLightsList.numOccupied) {
         return NULL;
+    }
 
     ret = &sLightsList.lights[sLightsList.nextFree];
 
-    while (ret->info != NULL)
-    {
+    while (ret->info != NULL) {
         sLightsList.nextFree++;
 
-        if (sLightsList.nextFree < 0x20)
-        {
+        if (sLightsList.nextFree < 0x20) {
             ret++;
-        }
-        else
-        {
+        } else {
             sLightsList.nextFree = 0;
             ret = &sLightsList.lights[0];
         }
@@ -112,36 +103,32 @@ z_Light* Lights_FindFreeSlot()
 
 #ifdef NON_MATCHING
 // single ordering difference
-void Lights_Free(z_Light* light)
-{
-    if (light != NULL)
-    {
+void Lights_Free(z_Light* light) {
+    if (light != NULL) {
         sLightsList.numOccupied--;
         light->info = NULL;
-        sLightsList.nextFree = (light - sLightsList.lights) / sizeof(z_Light); //! @bug Due to pointer arithmetic, the division is unnecessary
+        sLightsList.nextFree = (light - sLightsList.lights) /
+                               sizeof(z_Light); //! @bug Due to pointer arithmetic, the division is unnecessary
     }
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_lights/Lights_Free.s")
 #endif
 
-void func_8007A614(GlobalContext* globalCtx, LightingContext* lightCtx)
-{
+void func_8007A614(GlobalContext* globalCtx, LightingContext* lightCtx) {
     Lights_ClearHead(globalCtx, lightCtx);
     Lights_SetAmbientColor(lightCtx, 0x50, 0x50, 0x50);
     func_8007A698(lightCtx, 0, 0, 0, 0x3e4, 0x3200);
     bzero(&sLightsList, sizeof(sLightsList));
 }
 
-void Lights_SetAmbientColor(LightingContext* lightCtx, u8 red, u8 green, u8 blue)
-{
+void Lights_SetAmbientColor(LightingContext* lightCtx, u8 red, u8 green, u8 blue) {
     lightCtx->ambientRed = red;
     lightCtx->ambientGreen = green;
     lightCtx->ambientBlue = blue;
 }
 
-void func_8007A698(LightingContext* lightCtx, u8 arg1, u8 arg2, u8 arg3, s16 arg4, s16 arg5)
-{
+void func_8007A698(LightingContext* lightCtx, u8 arg1, u8 arg2, u8 arg3, s16 arg4, s16 arg5) {
     lightCtx->unk_07 = arg1;
     lightCtx->unk_08 = arg2;
     lightCtx->unk_09 = arg3;
@@ -149,38 +136,33 @@ void func_8007A698(LightingContext* lightCtx, u8 arg1, u8 arg2, u8 arg3, s16 arg
     lightCtx->unk_0C = arg5;
 }
 
-LightMapper* Lights_CreateMapper(LightingContext* lightCtx, GraphicsContext* gfxCtx)
-{
+LightMapper* Lights_CreateMapper(LightingContext* lightCtx, GraphicsContext* gfxCtx) {
     return func_8007A960(gfxCtx, lightCtx->ambientRed, lightCtx->ambientGreen, lightCtx->ambientBlue);
 }
 
-void Lights_ClearHead(GlobalContext* globalCtx, LightingContext* lightCtx)
-{
+void Lights_ClearHead(GlobalContext* globalCtx, LightingContext* lightCtx) {
     lightCtx->lightsHead = NULL;
 }
 
-void Lights_RemoveAll(GlobalContext* globalCtx, LightingContext* lightCtx)
-{
-    while (lightCtx->lightsHead != NULL)
-    {
+void Lights_RemoveAll(GlobalContext* globalCtx, LightingContext* lightCtx) {
+    while (lightCtx->lightsHead != NULL) {
         Lights_Remove(globalCtx, lightCtx, lightCtx->lightsHead);
         lightCtx->lightsHead = lightCtx->lightsHead->next;
     }
 }
 
-z_Light* Lights_Insert(GlobalContext* globalCtx, LightingContext* lightCtx, LightInfo* info)
-{
+z_Light* Lights_Insert(GlobalContext* globalCtx, LightingContext* lightCtx, LightInfo* info) {
     z_Light* light;
 
     light = Lights_FindFreeSlot();
-    if (light != NULL)
-    {
+    if (light != NULL) {
         light->info = info;
         light->prev = NULL;
         light->next = lightCtx->lightsHead;
 
-        if (lightCtx->lightsHead != NULL)
+        if (lightCtx->lightsHead != NULL) {
             lightCtx->lightsHead->prev = light;
+        }
 
         lightCtx->lightsHead = light;
     }
@@ -188,17 +170,17 @@ z_Light* Lights_Insert(GlobalContext* globalCtx, LightingContext* lightCtx, Ligh
     return light;
 }
 
-void Lights_Remove(GlobalContext* globalCtx, LightingContext* lightCtx, z_Light* light)
-{
-    if (light != NULL)
-    {
-        if (light->prev != NULL)
+void Lights_Remove(GlobalContext* globalCtx, LightingContext* lightCtx, z_Light* light) {
+    if (light != NULL) {
+        if (light->prev != NULL) {
             light->prev->next = light->next;
-        else
+        } else {
             lightCtx->lightsHead = light->next;
+        }
 
-        if (light->next != NULL)
+        if (light->next != NULL) {
             light->next->prev = light->prev;
+        }
 
         Lights_Free(light);
     }
@@ -211,4 +193,3 @@ void Lights_Remove(GlobalContext* globalCtx, LightingContext* lightCtx, z_Light*
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_lights/func_8007A9B4.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_lights/func_8007ABBC.s")
-
diff --git a/src/code/z_malloc.c b/src/code/z_malloc.c
index 10a328c49..fd82cca8f 100644
--- a/src/code/z_malloc.c
+++ b/src/code/z_malloc.c
@@ -1,131 +1,112 @@
 #include <global.h>
 
-#define LOG_SEVERITY_NOLOG          0
-#define LOG_SEVERITY_ERROR          2
-#define LOG_SEVERITY_VERBOSE        3
+#define LOG_SEVERITY_NOLOG 0
+#define LOG_SEVERITY_ERROR 2
+#define LOG_SEVERITY_VERBOSE 3
 
 s32 gZeldaArenaLogSeverity = LOG_SEVERITY_ERROR;
 Arena sZeldaArena;
 
-void ZeldaArena_CheckPointer(void* ptr, u32 size, const char* name, const char* action)
-{
-    if (!ptr)
-    {
-        if (gZeldaArenaLogSeverity >= LOG_SEVERITY_ERROR)
-        {
+void ZeldaArena_CheckPointer(void* ptr, u32 size, const char* name, const char* action) {
+    if (!ptr) {
+        if (gZeldaArenaLogSeverity >= LOG_SEVERITY_ERROR) {
             //"%s: %u bytes %s failed\n"
             osSyncPrintf("%s: %u バイトの%sに失敗しました\n", name, size, action);
-            __osDisplayArena(&sZeldaArena);  
+            __osDisplayArena(&sZeldaArena);
             return;
         }
-    }
-    else if (gZeldaArenaLogSeverity >= LOG_SEVERITY_VERBOSE)
-    {
+    } else if (gZeldaArenaLogSeverity >= LOG_SEVERITY_VERBOSE) {
         //"%s: %u bytes %s succeeded\n"
         osSyncPrintf("%s: %u バイトの%sに成功しました\n", name, size, action);
     }
 }
 
-void* ZeldaArena_Malloc(u32 size)
-{
+void* ZeldaArena_Malloc(u32 size) {
     void* ptr;
     ptr = __osMalloc(&sZeldaArena, size);
-    ZeldaArena_CheckPointer(ptr, size, "zelda_malloc", "確保"); //Secure
+    ZeldaArena_CheckPointer(ptr, size, "zelda_malloc", "確保"); // Secure
     return ptr;
 }
 
-void* ZeldaArena_MallocDebug(u32 size, const char* file, s32 line)
-{
+void* ZeldaArena_MallocDebug(u32 size, const char* file, s32 line) {
     void* ptr;
     ptr = __osMallocDebug(&sZeldaArena, size, file, line);
-    ZeldaArena_CheckPointer(ptr, size, "zelda_malloc_DEBUG", "確保"); //Secure
+    ZeldaArena_CheckPointer(ptr, size, "zelda_malloc_DEBUG", "確保"); // Secure
     return ptr;
 }
 
-void* ZeldaArena_MallocR(u32 size)
-{
+void* ZeldaArena_MallocR(u32 size) {
     void* ptr;
     ptr = __osMallocR(&sZeldaArena, size);
-    ZeldaArena_CheckPointer(ptr, size, "zelda_malloc_r", "確保"); //Secure
+    ZeldaArena_CheckPointer(ptr, size, "zelda_malloc_r", "確保"); // Secure
     return ptr;
 }
 
-void* ZeldaArena_MallocRDebug(u32 size, const char* file, s32 line)
-{
+void* ZeldaArena_MallocRDebug(u32 size, const char* file, s32 line) {
     void* ptr;
     ptr = __osMallocRDebug(&sZeldaArena, size, file, line);
-    ZeldaArena_CheckPointer(ptr, size, "zelda_malloc_r_DEBUG", "確保"); //Secure
+    ZeldaArena_CheckPointer(ptr, size, "zelda_malloc_r_DEBUG", "確保"); // Secure
     return ptr;
 }
 
-void* ZeldaArena_Realloc(void* ptr, u32 newSize)
-{
+void* ZeldaArena_Realloc(void* ptr, u32 newSize) {
     ptr = __osRealloc(&sZeldaArena, ptr, newSize);
     ZeldaArena_CheckPointer(ptr, newSize, "zelda_realloc", "再確保"); // Re-securing
     return ptr;
 }
 
-void* ZeldaArena_ReallocDebug(void* ptr, u32 newSize, const char* file, s32 line)
-{
+void* ZeldaArena_ReallocDebug(void* ptr, u32 newSize, const char* file, s32 line) {
     ptr = __osReallocDebug(&sZeldaArena, ptr, newSize, file, line);
     ZeldaArena_CheckPointer(ptr, newSize, "zelda_realloc_DEBUG", "再確保"); // Re-securing
     return ptr;
 }
 
-void ZeldaArena_Free(void* ptr)
-{
+void ZeldaArena_Free(void* ptr) {
     __osFree(&sZeldaArena, ptr);
 }
 
-void ZeldaArena_FreeDebug(void* ptr, const char* file, s32 line)
-{
+void ZeldaArena_FreeDebug(void* ptr, const char* file, s32 line) {
     __osFreeDebug(&sZeldaArena, ptr, file, line);
 }
 
-void* ZeldaArena_Calloc(u32 num, u32 size)
-{
+void* ZeldaArena_Calloc(u32 num, u32 size) {
     void* ret;
     u32 n;
-    
-    n = num*size;
+
+    n = num * size;
     ret = __osMalloc(&sZeldaArena, n);
-    if (ret)
+    if (ret) {
         bzero(ret, n);
+    }
 
     ZeldaArena_CheckPointer(ret, n, "zelda_calloc", "確保");
     return ret;
 }
 
-void ZeldaArena_Display()
-{
-    //Zelda heap display
+void ZeldaArena_Display() {
+    // Zelda heap display
     osSyncPrintf("ゼルダヒープ表示\n");
     __osDisplayArena(&sZeldaArena);
 }
 
-void ZeldaArena_GetSizes(u32* outMaxFree, u32* outFree, u32* outAlloc)
-{
+void ZeldaArena_GetSizes(u32* outMaxFree, u32* outFree, u32* outAlloc) {
     ArenaImpl_GetSizes(&sZeldaArena, outMaxFree, outFree, outAlloc);
 }
 
-void ZeldaArena_Check()
-{
+void ZeldaArena_Check() {
     __osCheckArena(&sZeldaArena);
 }
 
-void ZeldaArena_Init(void* start, u32 size)
-{
+void ZeldaArena_Init(void* start, u32 size) {
     gZeldaArenaLogSeverity = LOG_SEVERITY_NOLOG;
     __osMallocInit(&sZeldaArena, start, size);
 }
 
-void ZeldaArena_Cleanup()
-{
+void ZeldaArena_Cleanup() {
     gZeldaArenaLogSeverity = LOG_SEVERITY_NOLOG;
     __osMallocCleanup(&sZeldaArena);
 }
 
-u8 ZeldaArena_IsInitalized()
-{
+u8 ZeldaArena_IsInitalized() {
     return __osMallocIsInitalized(&sZeldaArena);
 }
diff --git a/src/code/z_map_exp.c b/src/code/z_map_exp.c
index 7498ffe7f..b740bba3c 100644
--- a/src/code/z_map_exp.c
+++ b/src/code/z_map_exp.c
@@ -22,4 +22,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_map_exp/func_80082248.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_map_exp/func_8008226C.s")
-
diff --git a/src/code/z_map_mark.c b/src/code/z_map_mark.c
index bd1187cf8..698715ffe 100644
--- a/src/code/z_map_mark.c
+++ b/src/code/z_map_mark.c
@@ -2,8 +2,7 @@
 #include <global.h>
 #include <vt.h>
 
-typedef struct
-{
+typedef struct {
     /* 0x00 */ void* texture;
     /* 0x04 */ u32 imageFormat;
     /* 0x08 */ u32 imageSize;
@@ -15,76 +14,69 @@ typedef struct
     /* 0x20 */ u32 dtdy;
 } MapMarkInfo; // size = 0x24
 
-typedef struct
-{
+typedef struct {
     /* 0x00 */ void* loadedRamAddr; // original name: "allocp"
-    /* 0x04 */ u32   vromStart;
-    /* 0x08 */ u32   vromEnd;
-    /* 0x0C */ u32   vramStart;
-    /* 0x10 */ u32   vramEnd;
-    /* 0x14 */ u32   vramTable;
+    /* 0x04 */ u32 vromStart;
+    /* 0x08 */ u32 vromEnd;
+    /* 0x0C */ u32 vramStart;
+    /* 0x10 */ u32 vramEnd;
+    /* 0x14 */ u32 vramTable;
 } MapMarkDataOverlay; // size = 0x18
 
-static u32 sBaseImageSizes[]      = { 0, 1, 2, 3 };
+static u32 sBaseImageSizes[] = { 0, 1, 2, 3 };
 static u32 sLoadBlockImageSizes[] = { 2, 2, 2, 3 };
-static u32 sIncrImageSizes[]      = { 3, 1, 0, 0 };
-static u32 sShiftImageSizes[]     = { 2, 1, 0, 0 };
-static u32 sBytesImageSizes[]     = { 0, 1, 2, 4 };
+static u32 sIncrImageSizes[] = { 3, 1, 0, 0 };
+static u32 sShiftImageSizes[] = { 2, 1, 0, 0 };
+static u32 sBytesImageSizes[] = { 0, 1, 2, 4 };
 static u32 sLineBytesImageSizes[] = { 0, 1, 2, 2 };
 
-#define G_IM_SIZ_MARK             sBaseImageSizes[markInfo->imageSize]
-#define G_IM_SIZ_MARK_LOAD_BLOCK  sLoadBlockImageSizes[markInfo->imageSize]
-#define G_IM_SIZ_MARK_INCR        sIncrImageSizes[markInfo->imageSize]
-#define G_IM_SIZ_MARK_SHIFT       sShiftImageSizes[markInfo->imageSize]
-#define G_IM_SIZ_MARK_BYTES       sBytesImageSizes[markInfo->imageSize]
-#define G_IM_SIZ_MARK_LINE_BYTES  sLineBytesImageSizes[markInfo->imageSize]
+#define G_IM_SIZ_MARK sBaseImageSizes[markInfo->imageSize]
+#define G_IM_SIZ_MARK_LOAD_BLOCK sLoadBlockImageSizes[markInfo->imageSize]
+#define G_IM_SIZ_MARK_INCR sIncrImageSizes[markInfo->imageSize]
+#define G_IM_SIZ_MARK_SHIFT sShiftImageSizes[markInfo->imageSize]
+#define G_IM_SIZ_MARK_BYTES sBytesImageSizes[markInfo->imageSize]
+#define G_IM_SIZ_MARK_LINE_BYTES sLineBytesImageSizes[markInfo->imageSize]
 
-static MapMarkInfo sMapMarkInfoTable[] =
-{
+static MapMarkInfo sMapMarkInfoTable[] = {
     { D_02002580, G_IM_FMT_RGBA, G_IM_SIZ_16b, 8, 8, 32, 32, 1024, 1024 }, // Chest Icon
-    { D_02002900, G_IM_FMT_IA,   G_IM_SIZ_8b,  8, 8, 32, 32, 1024, 1024 }, // Boss Skull Icon
+    { D_02002900, G_IM_FMT_IA, G_IM_SIZ_8b, 8, 8, 32, 32, 1024, 1024 },    // Boss Skull Icon
 };
 
-static MapMarkDataOverlay sMapMarkDataOvl =
-{
+static MapMarkDataOverlay sMapMarkDataOvl = {
     NULL,
     (u32)_ovl_map_mark_dataSegmentRomStart,
     (u32)_ovl_map_mark_dataSegmentRomEnd,
     (u32)_ovl_map_mark_dataSegmentStart,
     (u32)_ovl_map_mark_dataSegmentEnd,
-    (u32)gMapMarkDataTable
+    (u32)gMapMarkDataTable,
 };
 
 static MapMarksData** sLoadedMarkDataTable;
 
 extern u8** D_8015FFD0;
 
-void MapMark_Init(GlobalContext* globalCtx)
-{
+void MapMark_Init(GlobalContext* globalCtx) {
     MapMarkDataOverlay* overlay = &sMapMarkDataOvl;
     u32 overlaySize = overlay->vramEnd - overlay->vramStart;
 
     overlay->loadedRamAddr = Game_Alloc(&globalCtx->state, overlaySize, "../z_map_mark.c", 235);
     LogUtils_CheckNullPointer("dlftbl->allocp", overlay->loadedRamAddr, "../z_map_mark.c", 236);
 
-    Overlay_Load(overlay->vromStart, overlay->vromEnd,
-                  overlay->vramStart, overlay->vramEnd,
-                  overlay->loadedRamAddr);
+    Overlay_Load(overlay->vromStart, overlay->vromEnd, overlay->vramStart, overlay->vramEnd, overlay->loadedRamAddr);
 
     sLoadedMarkDataTable = gMapMarkDataTable;
-    sLoadedMarkDataTable = (void*)(s32)((overlay->vramTable != 0) ?
-                           (void*)(overlay->vramTable - (s32)(overlay->vramStart - (s32)overlay->loadedRamAddr)) :
-                           NULL);
+    sLoadedMarkDataTable =
+        (void*)(s32)((overlay->vramTable != 0)
+                         ? (void*)(overlay->vramTable - (s32)(overlay->vramStart - (s32)overlay->loadedRamAddr))
+                         : NULL);
 }
 
-void MapMark_ClearPointers(GlobalContext* globalCtx)
-{
+void MapMark_ClearPointers(GlobalContext* globalCtx) {
     sMapMarkDataOvl.loadedRamAddr = NULL;
     sLoadedMarkDataTable = NULL;
 }
 
-void MapMark_Draw(GlobalContext* globalCtx)
-{
+void MapMark_Draw(GlobalContext* globalCtx) {
     InterfaceContext* interfaceCtx;
     MapMarkData* mapMarkData;
     MapMarkPoint* markPoint;
@@ -94,28 +86,27 @@ void MapMark_Draw(GlobalContext* globalCtx)
     s32 rectLeft;
     s32 rectTop;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     dungeonId = gSaveContext.dungeon_index;
     interfaceCtx = &globalCtx->interfaceCtx;
 
-    if ((D_8015FFD0 != NULL) && (globalCtx->interfaceCtx.roomNum >= D_8015FFD0[7][dungeonId]))
-    {
+    if ((D_8015FFD0 != NULL) && (globalCtx->interfaceCtx.roomNum >= D_8015FFD0[7][dungeonId])) {
         // Translates to: "ROOM NUMBER EXCEEDED, YIKES %d/%d  MapMarkDraw PROCESSING INTERRUPTED"
-        osSyncPrintf(VT_COL(RED, WHITE) "部屋番号がオーバーしてるで,ヤバイで %d/%d  \nMapMarkDraw の処理を中断します\n", VT_RST,
-                     globalCtx->interfaceCtx.roomNum, D_8015FFD0[7][dungeonId]);
+        osSyncPrintf(VT_COL(RED, WHITE) "部屋番号がオーバーしてるで,ヤバイで %d/%d  \nMapMarkDraw の処理を中断します\n",
+                     VT_RST, globalCtx->interfaceCtx.roomNum, D_8015FFD0[7][dungeonId]);
         return;
     }
 
     mapMarkData = &sLoadedMarkDataTable[dungeonId][interfaceCtx->roomNum][0];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_map_mark.c", 303);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_map_mark.c", 303);
 
-    while (1)
-    {
-        if (mapMarkData->markType == -1)
+    while (1) {
+        if (mapMarkData->markType == -1) {
             break;
+        }
 
         gDPPipeSync(gfxCtx->overlay.p++);
         gDPSetTextureLUT(gfxCtx->overlay.p++, G_TT_NONE);
@@ -123,44 +114,31 @@ void MapMark_Draw(GlobalContext* globalCtx)
         gDPSetEnvColor(gfxCtx->overlay.p++, 0x00, 0x00, 0x00, interfaceCtx->minimapAlpha);
 
         markPoint = &mapMarkData->points[0];
-        for (i = 0; i < mapMarkData->count; i++)
-        {
-            if ((mapMarkData->markType != 0) || !Flags_GetTreasure(globalCtx, markPoint->chestFlag))
-            {
+        for (i = 0; i < mapMarkData->count; i++) {
+            if ((mapMarkData->markType != 0) || !Flags_GetTreasure(globalCtx, markPoint->chestFlag)) {
                 markInfo = &sMapMarkInfoTable[mapMarkData->markType];
 
                 gDPPipeSync(gfxCtx->overlay.p++);
-                gDPLoadTextureBlock(gfxCtx->overlay.p++,
-                                    markInfo->texture,
-                                    markInfo->imageFormat,
-                                    G_IM_SIZ_MARK,
-                                    markInfo->textureWidth, markInfo->textureHeight,
-                                    0,
-                                    G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP,
-                                    G_TX_NOMASK, G_TX_NOMASK,
-                                    G_TX_NOLOD, G_TX_NOLOD);
+                gDPLoadTextureBlock(gfxCtx->overlay.p++, markInfo->texture, markInfo->imageFormat, G_IM_SIZ_MARK,
+                                    markInfo->textureWidth, markInfo->textureHeight, 0, G_TX_NOMIRROR | G_TX_WRAP,
+                                    G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
 
                 rectLeft = (GREG(94) + markPoint->x + 204) << 2;
                 rectTop = (GREG(95) + markPoint->y + 140) << 2;
-                gSPTextureRectangle(gfxCtx->overlay.p++,
-                                    rectLeft, rectTop,
-                                    markInfo->rectWidth + rectLeft, rectTop + markInfo->rectHeight,
-                                    G_TX_RENDERTILE,
-                                    0, 0,
-                                    markInfo->dsdx, markInfo->dtdy);
+                gSPTextureRectangle(gfxCtx->overlay.p++, rectLeft, rectTop, markInfo->rectWidth + rectLeft,
+                                    rectTop + markInfo->rectHeight, G_TX_RENDERTILE, 0, 0, markInfo->dsdx,
+                                    markInfo->dtdy);
             }
             markPoint++;
         }
         mapMarkData++;
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_map_mark.c", 339);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_map_mark.c", 339);
 }
 
-void MapMark_DrawConditionally(GlobalContext* globalCtx)
-{
-    switch (globalCtx->sceneNum)
-    {
+void MapMark_DrawConditionally(GlobalContext* globalCtx) {
+    switch (globalCtx->sceneNum) {
         case SCENE_YDAN:
         case SCENE_DDAN:
         case SCENE_BDAN:
diff --git a/src/code/z_message_PAL.c b/src/code/z_message_PAL.c
index cb490341f..970f8bc24 100644
--- a/src/code/z_message_PAL.c
+++ b/src/code/z_message_PAL.c
@@ -82,4 +82,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_message_PAL/func_80110460.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_message_PAL/func_801104C8.s")
-
diff --git a/src/code/z_moji.c b/src/code/z_moji.c
index 754e8a1b6..d6966544f 100644
--- a/src/code/z_moji.c
+++ b/src/code/z_moji.c
@@ -11,107 +11,96 @@ s32 D_80120124 = 0;
 UNK_TYPE D_8015FFC0;
 UNK_TYPE D_8015FFC4;
 
-void func_8007B910(u32 red, u32 green, u32 blue, u32 alpha)
-{
+void func_8007B910(u32 red, u32 green, u32 blue, u32 alpha) {
     sFontColorRed = red;
     sFontColorGreen = green;
     sFontColorBlue = blue;
     sFontColorAlpha = alpha;
 }
 
-void func_8007B934(s32 arg0, s32 arg1)
-{
-    if (arg0 > 39)
+void func_8007B934(s32 arg0, s32 arg1) {
+    if (arg0 > 39) {
         D_80120120 = 39 * 8;
-    else if (arg0 < 0)
+    } else if (arg0 < 0) {
         D_80120120 = 0;
-    else
+    } else {
         D_80120120 = arg0 * 8;
+    }
 
-    if (arg1 > 29)
+    if (arg1 > 29) {
         D_80120124 = 29 * 8;
-    else if (arg1 < 0)
+    } else if (arg1 < 0) {
         D_80120124 = 0;
-    else
+    } else {
         D_80120124 = arg1 * 8;
+    }
 }
 
-void func_8007B9A4(GraphicsContext* gfxCtx, u8 arg1)
-{
-    Gfx* gfxArr[7];
+void func_8007B9A4(GraphicsContext* gfxCtx, u8 arg1) {
+    Gfx* dispRefs[7];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_moji.c", 86);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_moji.c", 86);
 
-    if ((u32)gLetterTLUT & 0xF)
+    if ((u32)gLetterTLUT & 0xF) {
         osSyncPrintf("moji_tlut --> %X\n", gLetterTLUT);
+    }
 
-    if (D_8015FFC0 != (arg1 & 3))
-    {
+    if (D_8015FFC0 != (arg1 & 3)) {
         gDPLoadTLUT(gfxCtx->polyOpa.p++, 16, 256, &gLetterTLUT[arg1 & 3]);
         D_8015FFC0 = arg1 & 3;
     }
 
-    gSPTextureRectangle(gfxCtx->polyOpa.p++,
-                        D_80120120 << 2, D_80120124 << 2,
-                        (D_80120120 + 8) << 2, (D_80120124 + 8) << 2,
-                        G_TX_RENDERTILE,
-                        (u16)(arg1 & 4) * 64, (u16)(arg1 >> 3) * 256,
-                        1024, 1024);
+    gSPTextureRectangle(gfxCtx->polyOpa.p++, D_80120120 << 2, D_80120124 << 2, (D_80120120 + 8) << 2,
+                        (D_80120124 + 8) << 2, G_TX_RENDERTILE, (u16)(arg1 & 4) * 64, (u16)(arg1 >> 3) * 256, 1024,
+                        1024);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_moji.c", 123);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_moji.c", 123);
 }
 
-void func_8007BBA8(GraphicsContext* gfxCtx, u8* arg1)
-{
+void func_8007BBA8(GraphicsContext* gfxCtx, u8* arg1) {
     s32 i;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_moji.c", 137);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_moji.c", 137);
 
-    if ((u32)gFontFF & 0xF)
+    if ((u32)gFontFF & 0xF) {
         osSyncPrintf("font_ff --> %X\n", gFontFF);
+    }
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
-    gDPSetPrimColor(gfxCtx->polyOpa.p++, 0, 0,
-                    sFontColorRed, sFontColorGreen,
-                    sFontColorBlue, sFontColorAlpha);
+    gDPSetPrimColor(gfxCtx->polyOpa.p++, 0, 0, sFontColorRed, sFontColorGreen, sFontColorBlue, sFontColorAlpha);
 
     gDPSetTextureImage(gfxCtx->polyOpa.p++, G_IM_FMT_CI, G_IM_SIZ_16b, 1, (s32)gFontFF);
-    gDPSetTile(gfxCtx->polyOpa.p++, G_IM_FMT_CI, G_IM_SIZ_16b,
-               0, 0, G_TX_LOADTILE, 0,
-               G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-               G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+    gDPSetTile(gfxCtx->polyOpa.p++, G_IM_FMT_CI, G_IM_SIZ_16b, 0, 0, G_TX_LOADTILE, 0, G_TX_NOMIRROR | G_TX_WRAP,
+               G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
     gDPLoadSync(gfxCtx->polyOpa.p++);
     gDPLoadBlock(gfxCtx->polyOpa.p++, G_TX_LOADTILE, 0, 0, 511, 2048);
     gDPPipeSync(gfxCtx->polyOpa.p++);
-    gDPSetTile(gfxCtx->polyOpa.p++, G_IM_FMT_CI, G_IM_SIZ_4b,
-               1, 0, G_TX_RENDERTILE, 0,
-               G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-               G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+    gDPSetTile(gfxCtx->polyOpa.p++, G_IM_FMT_CI, G_IM_SIZ_4b, 1, 0, G_TX_RENDERTILE, 0, G_TX_NOMIRROR | G_TX_WRAP,
+               G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
     gDPSetTileSize(gfxCtx->polyOpa.p++, G_TX_RENDERTILE, 0, 0, 60, 508);
 
     D_8015FFC0 = -1;
 
-    for (i = 0; arg1[i] != 0; i++)
-    {
-        switch (arg1[i])
-        {
+    for (i = 0; arg1[i] != 0; i++) {
+        switch (arg1[i]) {
             case 9:
                 D_80120120 = (((D_80120120 / 8) / 8) + 1) * 8 * 8;
-                if (D_80120120 >= 320)
-                {
+                if (D_80120120 >= 320) {
                     D_80120120 = 0;
                     D_80120124 += 8;
-                    if (D_80120124 >= 240)
+                    if (D_80120124 >= 240) {
                         D_80120124 = 0;
+                    }
                 }
                 break;
             case 10:
             case 13:
                 D_80120120 = 0;
                 D_80120124 += 8;
-                if (D_80120124 >= 240)
+                if (D_80120124 >= 240) {
                     D_80120124 = 0;
+                }
                 break;
             default:
                 func_8007B9A4(gfxCtx, arg1[i]);
@@ -119,5 +108,5 @@ void func_8007BBA8(GraphicsContext* gfxCtx, u8* arg1)
         }
     }
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_moji.c", 181);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_moji.c", 181);
 }
diff --git a/src/code/z_msgevent.c b/src/code/z_msgevent.c
new file mode 100644
index 000000000..8995189f7
--- /dev/null
+++ b/src/code/z_msgevent.c
@@ -0,0 +1,22 @@
+#include <ultra64.h>
+#include <global.h>
+#include <sched.h>
+
+void MsgEvent_SendNullTask() {
+    u32 pad[4];
+    OSScTask task;
+    OSMesgQueue queue;
+    OSMesg msg;
+    u32 pad2[1];
+
+    task.next = NULL;
+    task.flags = OS_SC_RCP_MASK;
+    task.msgQ = &queue;
+    task.msg = NULL;
+    task.framebuffer = NULL;
+    task.list.t.type = M_NULTASK;
+    osCreateMesgQueue(task.msgQ, &msg, 1);
+    osSendMesg(&gSchedContext.cmdQ, &task, OS_MESG_BLOCK);
+    func_800C95F8(&gSchedContext); // osScKickEntryMsg
+    osRecvMesg(&queue, NULL, OS_MESG_BLOCK);
+}
diff --git a/src/code/z_onepointdemo.c b/src/code/z_onepointdemo.c
index 639d87869..faf7ca6b7 100644
--- a/src/code/z_onepointdemo.c
+++ b/src/code/z_onepointdemo.c
@@ -1,8 +1,7 @@
 #include <ultra64.h>
 #include <global.h>
 
-typedef struct
-{
+typedef struct {
     /* 0x00 */ u32 unk_00;
     /* 0x04 */ u32 unk_04;
     /* 0x08 */ s16 unk_08;
@@ -13,29 +12,26 @@ typedef struct
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_onepointdemo/func_8007C704.s")
 
-void func_8007C76C(f32* pfParm1, s16 *puParm2)
-{
-  puParm2[0] = pfParm1[0];
-  puParm2[1] = pfParm1[1];
-  puParm2[2] = pfParm1[2];
+void func_8007C76C(f32* pfParm1, s16* puParm2) {
+    puParm2[0] = pfParm1[0];
+    puParm2[1] = pfParm1[1];
+    puParm2[2] = pfParm1[2];
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_onepointdemo/func_8007C7A8.s")
 
-void func_8007C7F8(u32 uParm1, u32 uParm2)
-{
-  u8 auStack4[4];
-  u8 auStack8[4];
-  
-  func_8003C940(uParm1, auStack4, auStack8, uParm2);
+void func_8007C7F8(u32 uParm1, u32 uParm2) {
+    u8 auStack4[4];
+    u8 auStack8[4];
+
+    func_8003C940(uParm1, auStack4, auStack8, uParm2);
 }
 
-void func_8007C820(struct_8007C820* puParm1, s16 uParm2, s16 uParm3, u32 uParm4, u32 param_5)
-{
-  puParm1->unk_00 = uParm4;
-  puParm1->unk_04 = param_5;
-  puParm1->unk_08 = uParm2;
-  puParm1->unk_0A = uParm3;
+void func_8007C820(struct_8007C820* puParm1, s16 uParm2, s16 uParm3, u32 uParm4, u32 param_5) {
+    puParm1->unk_00 = uParm4;
+    puParm1->unk_04 = param_5;
+    puParm1->unk_08 = uParm2;
+    puParm1->unk_0A = uParm3;
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_onepointdemo/func_8007C850.s")
@@ -52,18 +48,15 @@ void func_8007C820(struct_8007C820* puParm1, s16 uParm2, s16 uParm3, u32 uParm4,
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_onepointdemo/func_800806BC.s")
 
-void func_8008070C()
-{
+void func_8008070C() {
     D_80120130 = 0;
 }
 
-void func_80080718()
-{
+void func_80080718() {
     D_80120130 = 1;
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_onepointdemo/func_80080728.s")
 
-void func_80080788(UNK_TYPE arg0, UNK_TYPE arg1)
-{
+void func_80080788(UNK_TYPE arg0, UNK_TYPE arg1) {
 }
diff --git a/src/code/z_parameter.c b/src/code/z_parameter.c
index cb5fb307c..d94f95a3a 100644
--- a/src/code/z_parameter.c
+++ b/src/code/z_parameter.c
@@ -2,117 +2,115 @@
 #include <global.h>
 #include <vt.h>
 
-typedef struct
-{
+typedef struct {
     /* 0x00 */ u8 scene;
     /* 0x01 */ u8 flags1;
     /* 0x02 */ u8 flags2;
     /* 0x03 */ u8 flags3;
 } RestrictionFlags;
 
-RestrictionFlags sRestrictionFlags[] =
-{
-    { SCENE_SPOT00,             0x00, 0x00, 0x10 },
-    { SCENE_SPOT01,             0x00, 0x00, 0x10 },
-    { SCENE_SPOT02,             0x00, 0x00, 0x10 },
-    { SCENE_SPOT03,             0x00, 0x00, 0x10 },
-    { SCENE_SPOT04,             0x00, 0x00, 0x10 },
-    { SCENE_SPOT05,             0x00, 0x00, 0x10 },
-    { SCENE_SPOT06,             0x00, 0x00, 0x10 },
-    { SCENE_SPOT07,             0x00, 0x00, 0x10 },
-    { SCENE_SPOT08,             0x00, 0x00, 0x10 },
-    { SCENE_SPOT09,             0x00, 0x00, 0x10 },
-    { SCENE_SPOT10,             0x00, 0x00, 0x10 },
-    { SCENE_SPOT11,             0x00, 0x00, 0x10 },
-    { SCENE_SPOT12,             0x00, 0x00, 0x10 },
-    { SCENE_SPOT13,             0x00, 0x00, 0x10 },
-    { SCENE_SPOT15,             0x00, 0x00, 0x10 },
-    { SCENE_GANON_TOU,          0x00, 0x00, 0x10 },
-    { SCENE_SPOT16,             0x00, 0x00, 0x10 },
-    { SCENE_SPOT17,             0x00, 0x00, 0x10 },
-    { SCENE_SPOT18,             0x00, 0x00, 0x10 },
-    { SCENE_SPOT20,             0x00, 0x00, 0x10 },
-    { SCENE_TOKINOMA,           0x00, 0x10, 0x15 },
-    { SCENE_KENJYANOMA,         0xA2, 0xAA, 0xAA },
-    { SCENE_SYATEKIJYOU,        0x11, 0x55, 0x55 },
-    { SCENE_HAIRAL_NIWA,        0x11, 0x55, 0x55 },
-    { SCENE_HAIRAL_NIWA_N,      0x11, 0x55, 0x55 },
-    { SCENE_HAKAANA,            0x00, 0x00, 0xD0 },
-    { SCENE_HAKAANA2,           0x00, 0x00, 0xD0 },
-    { SCENE_HAKAANA_OUKE,       0x00, 0x00, 0xD0 },
-    { SCENE_DAIYOUSEI_IZUMI,    0x00, 0x00, 0x10 },
-    { SCENE_YOUSEI_IZUMI_TATE,  0x00, 0x00, 0xD0 },
-    { SCENE_YOUSEI_IZUMI_YOKO,  0x00, 0x00, 0x10 },
-    { SCENE_GANON_FINAL,        0x00, 0x05, 0x50 },
-    { SCENE_NAKANIWA,           0x00, 0x05, 0x54 },
-    { SCENE_TURIBORI,           0x11, 0x55, 0x55 },
-    { SCENE_BOWLING,            0x11, 0x55, 0x55 },
-    { SCENE_SOUKO,              0x00, 0x10, 0x15 },
-    { SCENE_MIHARIGOYA,         0x00, 0x10, 0x14 },
-    { SCENE_MAHOUYA,            0x10, 0x15, 0x55 },
-    { SCENE_TAKARAYA,           0x10, 0x15, 0x55 },
-    { SCENE_KINSUTA,            0x00, 0x10, 0x15 },
-    { SCENE_ENTRA,              0x00, 0x10, 0x15 },
-    { SCENE_ENTRA_N,            0x00, 0x10, 0x15 },
-    { SCENE_ENRUI,              0x00, 0x10, 0xD5 },
-    { SCENE_MARKET_DAY,         0x00, 0x10, 0x15 },
-    { SCENE_MARKET_NIGHT,       0x00, 0x10, 0x15 },
-    { SCENE_MARKET_RUINS,       0x00, 0x10, 0xD5 },
-    { SCENE_MARKET_ALLEY,       0x00, 0x10, 0x15 },
-    { SCENE_MARKET_ALLEY_N,     0x00, 0x10, 0x15 },
-    { SCENE_SHRINE,             0x00, 0x10, 0x15 },
-    { SCENE_SHRINE_N,           0x00, 0x10, 0x15 },
-    { SCENE_SHRINE_R,           0x00, 0x10, 0xD5 },
-    { SCENE_LINK_HOME,          0x10, 0x10, 0x15 },
-    { SCENE_KAKARIKO,           0x10, 0x10, 0x15 },
-    { SCENE_KAKARIKO3,          0x10, 0x10, 0x15 },
-    { SCENE_KOKIRI_HOME,        0x10, 0x10, 0x15 },
-    { SCENE_KOKIRI_HOME3,       0x10, 0x10, 0x15 },
-    { SCENE_KOKIRI_HOME4,       0x10, 0x10, 0x15 },
-    { SCENE_KOKIRI_HOME5,       0x10, 0x10, 0x15 },
-    { SCENE_MALON_STABLE,       0x10, 0x10, 0x15 },
-    { SCENE_HUT,                0x10, 0x10, 0x15 },
-    { SCENE_IMPA,               0x10, 0x10, 0x15 },
-    { SCENE_LABO,               0x10, 0x10, 0x15 },
-    { SCENE_HYLIA_LABO,         0x00, 0x10, 0x15 },
-    { SCENE_TENT,               0x10, 0x10, 0x15 },
-    { SCENE_SHOP1,              0x10, 0x10, 0x15 },
-    { SCENE_KOKIRI_SHOP,        0x10, 0x10, 0x15 },
-    { SCENE_GOLON,              0x10, 0x10, 0x15 },
-    { SCENE_ZOORA,              0x10, 0x10, 0x15 },
-    { SCENE_DRAG,               0x10, 0x10, 0x15 },
-    { SCENE_ALLEY_SHOP,         0x10, 0x10, 0x15 },
-    { SCENE_NIGHT_SHOP,         0x10, 0x10, 0x15 },
-    { SCENE_FACE_SHOP,          0x10, 0x10, 0x15 },
-    { SCENE_MEN,                0x00, 0x03, 0x10 },
-    { SCENE_YDAN,               0x00, 0x00, 0x00 },
-    { SCENE_YDAN_BOSS,          0x00, 0x45, 0x50 },
-    { SCENE_DDAN,               0x00, 0x00, 0x00 },
-    { SCENE_DDAN_BOSS,          0x00, 0x45, 0x50 },
-    { SCENE_BDAN,               0x00, 0x00, 0x00 },
-    { SCENE_BDAN_BOSS,          0x00, 0x45, 0x50 },
-    { SCENE_BMORI1,             0x00, 0x00, 0x00 },
-    { SCENE_MORIBOSSROOM,       0x00, 0x45, 0x50 },
-    { SCENE_HAKADANCH,          0x00, 0x00, 0x00 },
-    { SCENE_HAKADAN,            0x00, 0x00, 0x00 },
-    { SCENE_HAKADAN_BS,         0x00, 0x45, 0x50 },
-    { SCENE_HIDAN,              0x00, 0x00, 0x00 },
-    { SCENE_FIRE_BS,            0x00, 0x45, 0x50 },
-    { SCENE_MIZUSIN,            0x00, 0x00, 0x00 },
-    { SCENE_MIZUSIN_BS,         0x00, 0x45, 0x50 },
-    { SCENE_JYASINZOU,          0x00, 0x00, 0x00 },
-    { SCENE_JYASINBOSS,         0x00, 0x45, 0x50 },
-    { SCENE_GANON,              0x00, 0x00, 0x00 },
-    { SCENE_GANON_BOSS,         0x00, 0x45, 0x50 },
-    { SCENE_ICE_DOUKUTO,        0x00, 0x00, 0xC0 },
-    { SCENE_HAKASITARELAY,      0x00, 0x03, 0x14 },
-    { SCENE_GANONTIKA,          0x00, 0x03, 0x10 },
-    { SCENE_GANON_DEMO,         0x00, 0x45, 0x50 },
-    { SCENE_GANON_SONOGO,       0x00, 0x05, 0x50 },
-    { SCENE_GANONTIKA_SONOGO,   0x00, 0x05, 0x50 },
-    { SCENE_GERUDOWAY,          0x00, 0x00, 0x10 },
-    { SCENE_KAKUSIANA,          0x00, 0x00, 0xD0 },
-    { 0xFF,                     0x00, 0x00, 0x00 },
+RestrictionFlags sRestrictionFlags[] = {
+    { SCENE_SPOT00, 0x00, 0x00, 0x10 },
+    { SCENE_SPOT01, 0x00, 0x00, 0x10 },
+    { SCENE_SPOT02, 0x00, 0x00, 0x10 },
+    { SCENE_SPOT03, 0x00, 0x00, 0x10 },
+    { SCENE_SPOT04, 0x00, 0x00, 0x10 },
+    { SCENE_SPOT05, 0x00, 0x00, 0x10 },
+    { SCENE_SPOT06, 0x00, 0x00, 0x10 },
+    { SCENE_SPOT07, 0x00, 0x00, 0x10 },
+    { SCENE_SPOT08, 0x00, 0x00, 0x10 },
+    { SCENE_SPOT09, 0x00, 0x00, 0x10 },
+    { SCENE_SPOT10, 0x00, 0x00, 0x10 },
+    { SCENE_SPOT11, 0x00, 0x00, 0x10 },
+    { SCENE_SPOT12, 0x00, 0x00, 0x10 },
+    { SCENE_SPOT13, 0x00, 0x00, 0x10 },
+    { SCENE_SPOT15, 0x00, 0x00, 0x10 },
+    { SCENE_GANON_TOU, 0x00, 0x00, 0x10 },
+    { SCENE_SPOT16, 0x00, 0x00, 0x10 },
+    { SCENE_SPOT17, 0x00, 0x00, 0x10 },
+    { SCENE_SPOT18, 0x00, 0x00, 0x10 },
+    { SCENE_SPOT20, 0x00, 0x00, 0x10 },
+    { SCENE_TOKINOMA, 0x00, 0x10, 0x15 },
+    { SCENE_KENJYANOMA, 0xA2, 0xAA, 0xAA },
+    { SCENE_SYATEKIJYOU, 0x11, 0x55, 0x55 },
+    { SCENE_HAIRAL_NIWA, 0x11, 0x55, 0x55 },
+    { SCENE_HAIRAL_NIWA_N, 0x11, 0x55, 0x55 },
+    { SCENE_HAKAANA, 0x00, 0x00, 0xD0 },
+    { SCENE_HAKAANA2, 0x00, 0x00, 0xD0 },
+    { SCENE_HAKAANA_OUKE, 0x00, 0x00, 0xD0 },
+    { SCENE_DAIYOUSEI_IZUMI, 0x00, 0x00, 0x10 },
+    { SCENE_YOUSEI_IZUMI_TATE, 0x00, 0x00, 0xD0 },
+    { SCENE_YOUSEI_IZUMI_YOKO, 0x00, 0x00, 0x10 },
+    { SCENE_GANON_FINAL, 0x00, 0x05, 0x50 },
+    { SCENE_NAKANIWA, 0x00, 0x05, 0x54 },
+    { SCENE_TURIBORI, 0x11, 0x55, 0x55 },
+    { SCENE_BOWLING, 0x11, 0x55, 0x55 },
+    { SCENE_SOUKO, 0x00, 0x10, 0x15 },
+    { SCENE_MIHARIGOYA, 0x00, 0x10, 0x14 },
+    { SCENE_MAHOUYA, 0x10, 0x15, 0x55 },
+    { SCENE_TAKARAYA, 0x10, 0x15, 0x55 },
+    { SCENE_KINSUTA, 0x00, 0x10, 0x15 },
+    { SCENE_ENTRA, 0x00, 0x10, 0x15 },
+    { SCENE_ENTRA_N, 0x00, 0x10, 0x15 },
+    { SCENE_ENRUI, 0x00, 0x10, 0xD5 },
+    { SCENE_MARKET_DAY, 0x00, 0x10, 0x15 },
+    { SCENE_MARKET_NIGHT, 0x00, 0x10, 0x15 },
+    { SCENE_MARKET_RUINS, 0x00, 0x10, 0xD5 },
+    { SCENE_MARKET_ALLEY, 0x00, 0x10, 0x15 },
+    { SCENE_MARKET_ALLEY_N, 0x00, 0x10, 0x15 },
+    { SCENE_SHRINE, 0x00, 0x10, 0x15 },
+    { SCENE_SHRINE_N, 0x00, 0x10, 0x15 },
+    { SCENE_SHRINE_R, 0x00, 0x10, 0xD5 },
+    { SCENE_LINK_HOME, 0x10, 0x10, 0x15 },
+    { SCENE_KAKARIKO, 0x10, 0x10, 0x15 },
+    { SCENE_KAKARIKO3, 0x10, 0x10, 0x15 },
+    { SCENE_KOKIRI_HOME, 0x10, 0x10, 0x15 },
+    { SCENE_KOKIRI_HOME3, 0x10, 0x10, 0x15 },
+    { SCENE_KOKIRI_HOME4, 0x10, 0x10, 0x15 },
+    { SCENE_KOKIRI_HOME5, 0x10, 0x10, 0x15 },
+    { SCENE_MALON_STABLE, 0x10, 0x10, 0x15 },
+    { SCENE_HUT, 0x10, 0x10, 0x15 },
+    { SCENE_IMPA, 0x10, 0x10, 0x15 },
+    { SCENE_LABO, 0x10, 0x10, 0x15 },
+    { SCENE_HYLIA_LABO, 0x00, 0x10, 0x15 },
+    { SCENE_TENT, 0x10, 0x10, 0x15 },
+    { SCENE_SHOP1, 0x10, 0x10, 0x15 },
+    { SCENE_KOKIRI_SHOP, 0x10, 0x10, 0x15 },
+    { SCENE_GOLON, 0x10, 0x10, 0x15 },
+    { SCENE_ZOORA, 0x10, 0x10, 0x15 },
+    { SCENE_DRAG, 0x10, 0x10, 0x15 },
+    { SCENE_ALLEY_SHOP, 0x10, 0x10, 0x15 },
+    { SCENE_NIGHT_SHOP, 0x10, 0x10, 0x15 },
+    { SCENE_FACE_SHOP, 0x10, 0x10, 0x15 },
+    { SCENE_MEN, 0x00, 0x03, 0x10 },
+    { SCENE_YDAN, 0x00, 0x00, 0x00 },
+    { SCENE_YDAN_BOSS, 0x00, 0x45, 0x50 },
+    { SCENE_DDAN, 0x00, 0x00, 0x00 },
+    { SCENE_DDAN_BOSS, 0x00, 0x45, 0x50 },
+    { SCENE_BDAN, 0x00, 0x00, 0x00 },
+    { SCENE_BDAN_BOSS, 0x00, 0x45, 0x50 },
+    { SCENE_BMORI1, 0x00, 0x00, 0x00 },
+    { SCENE_MORIBOSSROOM, 0x00, 0x45, 0x50 },
+    { SCENE_HAKADANCH, 0x00, 0x00, 0x00 },
+    { SCENE_HAKADAN, 0x00, 0x00, 0x00 },
+    { SCENE_HAKADAN_BS, 0x00, 0x45, 0x50 },
+    { SCENE_HIDAN, 0x00, 0x00, 0x00 },
+    { SCENE_FIRE_BS, 0x00, 0x45, 0x50 },
+    { SCENE_MIZUSIN, 0x00, 0x00, 0x00 },
+    { SCENE_MIZUSIN_BS, 0x00, 0x45, 0x50 },
+    { SCENE_JYASINZOU, 0x00, 0x00, 0x00 },
+    { SCENE_JYASINBOSS, 0x00, 0x45, 0x50 },
+    { SCENE_GANON, 0x00, 0x00, 0x00 },
+    { SCENE_GANON_BOSS, 0x00, 0x45, 0x50 },
+    { SCENE_ICE_DOUKUTO, 0x00, 0x00, 0xC0 },
+    { SCENE_HAKASITARELAY, 0x00, 0x03, 0x14 },
+    { SCENE_GANONTIKA, 0x00, 0x03, 0x10 },
+    { SCENE_GANON_DEMO, 0x00, 0x45, 0x50 },
+    { SCENE_GANON_SONOGO, 0x00, 0x05, 0x50 },
+    { SCENE_GANONTIKA_SONOGO, 0x00, 0x05, 0x50 },
+    { SCENE_GERUDOWAY, 0x00, 0x00, 0x10 },
+    { SCENE_KAKUSIANA, 0x00, 0x00, 0xD0 },
+    { 0xFF, 0x00, 0x00, 0x00 },
 };
 
 s16 sHBAScoreTier = 0;
@@ -128,249 +126,264 @@ s16 sMagicBorderR = 0xFF;
 s16 sMagicBorderG = 0xFF;
 s16 sMagicBorderB = 0xFF;
 
-s16 sExtraItemBases[] =
-{
-    ITEM_STICK, ITEM_STICK, ITEM_NUT, ITEM_NUT, ITEM_BOMB, ITEM_BOMB,
-    ITEM_BOMB, ITEM_BOMB, ITEM_BOW, ITEM_BOW, ITEM_BOW, ITEM_SEEDS,
-    ITEM_BOMBCHU, ITEM_BOMBCHU, ITEM_STICK, ITEM_STICK, ITEM_NUT, ITEM_NUT,
+s16 sExtraItemBases[] = {
+    ITEM_STICK, ITEM_STICK, ITEM_NUT,   ITEM_NUT,     ITEM_BOMB,    ITEM_BOMB,  ITEM_BOMB,  ITEM_BOMB, ITEM_BOW,
+    ITEM_BOW,   ITEM_BOW,   ITEM_SEEDS, ITEM_BOMBCHU, ITEM_BOMBCHU, ITEM_STICK, ITEM_STICK, ITEM_NUT,  ITEM_NUT,
 };
 
 s16 D_80125A58 = 0;
 s16 D_80125A5C = 0;
 
-Gfx sSetupDL_80125A60[] =
-{
+Gfx sSetupDL_80125A60[] = {
     gsDPPipeSync(),
-    gsSPClearGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING |
-                          G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_SHADING_SMOOTH | G_LOD),
-    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP |
-                     G_TT_NONE | G_TL_TILE | G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_1PRIMITIVE,
+    gsSPClearGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN |
+                          G_TEXTURE_GEN_LINEAR | G_SHADING_SMOOTH | G_LOD),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_1PRIMITIVE,
                      G_AC_NONE | G_ZS_PIXEL | G_RM_CLD_SURF | G_RM_CLD_SURF2),
-    gsDPSetCombineLERP(0, 0, 0, PRIMITIVE, 0, 0, 0, PRIMITIVE, 0, 0, 0, PRIMITIVE, 0, 0, 0, PRIMITIVE),
+    gsDPSetCombineMode(G_CC_PRIMITIVE, G_CC_PRIMITIVE),
     gsSPEndDisplayList(),
 };
 
 // original name: "alpha_change"
-void Interface_ChangeAlpha(u16 alphaType)
-{
-    if (alphaType != gSaveContext.unk_13EA)
-    {
+void Interface_ChangeAlpha(u16 alphaType) {
+    if (alphaType != gSaveContext.unk_13EA) {
         osSyncPrintf("ＡＬＰＨＡーＴＹＰＥ＝%d  LAST_TIME_TYPE=%d\n", alphaType, gSaveContext.unk_13EE);
         gSaveContext.unk_13EA = gSaveContext.unk_13E8 = alphaType;
         gSaveContext.unk_13EC = 1;
     }
 }
 
-void func_80082644(GlobalContext* globalCtx, s16 alpha)
-{
+void func_80082644(GlobalContext* globalCtx, s16 alpha) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
 
-    if (gSaveContext.button_status[0] == BTN_DISABLED)
-    {
-        if (interfaceCtx->bAlpha != 0x46)
+    if (gSaveContext.button_status[0] == BTN_DISABLED) {
+        if (interfaceCtx->bAlpha != 0x46) {
             interfaceCtx->bAlpha = 0x46;
-    }
-    else
-    {
-        if (interfaceCtx->bAlpha != 0xFF)
+        }
+    } else {
+        if (interfaceCtx->bAlpha != 0xFF) {
             interfaceCtx->bAlpha = alpha;
+        }
     }
 
-    if (gSaveContext.button_status[1] == BTN_DISABLED)
-    {
-        if (interfaceCtx->cLeftAlpha != 0x46)
+    if (gSaveContext.button_status[1] == BTN_DISABLED) {
+        if (interfaceCtx->cLeftAlpha != 0x46) {
             interfaceCtx->cLeftAlpha = 0x46;
-    }
-    else
-    {
-        if (interfaceCtx->cLeftAlpha != 0xFF)
+        }
+    } else {
+        if (interfaceCtx->cLeftAlpha != 0xFF) {
             interfaceCtx->cLeftAlpha = alpha;
+        }
     }
 
-    if (gSaveContext.button_status[2] == BTN_DISABLED)
-    {
-        if (interfaceCtx->cDownAlpha != 0x46)
+    if (gSaveContext.button_status[2] == BTN_DISABLED) {
+        if (interfaceCtx->cDownAlpha != 0x46) {
             interfaceCtx->cDownAlpha = 0x46;
-    }
-    else
-    {
-        if (interfaceCtx->cDownAlpha != 0xFF)
+        }
+    } else {
+        if (interfaceCtx->cDownAlpha != 0xFF) {
             interfaceCtx->cDownAlpha = alpha;
+        }
     }
 
-    if (gSaveContext.button_status[3] == BTN_DISABLED)
-    {
-        if (interfaceCtx->cRightAlpha != 0x46)
+    if (gSaveContext.button_status[3] == BTN_DISABLED) {
+        if (interfaceCtx->cRightAlpha != 0x46) {
             interfaceCtx->cRightAlpha = 0x46;
-    }
-    else
-    {
-        if (interfaceCtx->cRightAlpha != 0xFF)
+        }
+    } else {
+        if (interfaceCtx->cRightAlpha != 0xFF) {
             interfaceCtx->cRightAlpha = alpha;
+        }
     }
 
-    if (gSaveContext.button_status[4] == BTN_DISABLED)
-    {
-        if (interfaceCtx->aAlpha != 0x46)
+    if (gSaveContext.button_status[4] == BTN_DISABLED) {
+        if (interfaceCtx->aAlpha != 0x46) {
             interfaceCtx->aAlpha = 0x46;
-    }
-    else
-    {
-        if (interfaceCtx->aAlpha != 0xFF)
+        }
+    } else {
+        if (interfaceCtx->aAlpha != 0xFF) {
             interfaceCtx->aAlpha = alpha;
+        }
     }
 }
 
-void func_8008277C(GlobalContext* globalCtx, s16 maxAlpha, s16 alpha)
-{
+void func_8008277C(GlobalContext* globalCtx, s16 maxAlpha, s16 alpha) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
 
-    if (gSaveContext.unk_13E7 != 0)
-    {
+    if (gSaveContext.unk_13E7 != 0) {
         func_80082644(globalCtx, alpha);
         return;
     }
 
-    if ((interfaceCtx->bAlpha != 0) && (interfaceCtx->bAlpha > maxAlpha))
+    if ((interfaceCtx->bAlpha != 0) && (interfaceCtx->bAlpha > maxAlpha)) {
         interfaceCtx->bAlpha = maxAlpha;
+    }
 
-    if ((interfaceCtx->aAlpha != 0) && (interfaceCtx->aAlpha > maxAlpha))
+    if ((interfaceCtx->aAlpha != 0) && (interfaceCtx->aAlpha > maxAlpha)) {
         interfaceCtx->aAlpha = maxAlpha;
+    }
 
-    if ((interfaceCtx->cLeftAlpha != 0) && (interfaceCtx->cLeftAlpha > maxAlpha))
+    if ((interfaceCtx->cLeftAlpha != 0) && (interfaceCtx->cLeftAlpha > maxAlpha)) {
         interfaceCtx->cLeftAlpha = maxAlpha;
+    }
 
-    if ((interfaceCtx->cDownAlpha != 0) && (interfaceCtx->cDownAlpha > maxAlpha))
+    if ((interfaceCtx->cDownAlpha != 0) && (interfaceCtx->cDownAlpha > maxAlpha)) {
         interfaceCtx->cDownAlpha = maxAlpha;
+    }
 
-    if ((interfaceCtx->cRightAlpha != 0) && (interfaceCtx->cRightAlpha > maxAlpha))
+    if ((interfaceCtx->cRightAlpha != 0) && (interfaceCtx->cRightAlpha > maxAlpha)) {
         interfaceCtx->cRightAlpha = maxAlpha;
+    }
 }
 
-void func_80082850(GlobalContext* globalCtx, s16 maxAlpha)
-{
+void func_80082850(GlobalContext* globalCtx, s16 maxAlpha) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
     s16 alpha;
 
     alpha = 0xFF - maxAlpha;
 
-    switch (gSaveContext.unk_13E8)
-    {
+    switch (gSaveContext.unk_13E8) {
         case 1:
         case 2:
         case 8:
             osSyncPrintf("a_alpha=%d, c_alpha=%d   →   ", interfaceCtx->aAlpha, interfaceCtx->cLeftAlpha);
 
-            if (gSaveContext.unk_13E8 == 8)
-            {
-                if (interfaceCtx->bAlpha != 0xFF)
+            if (gSaveContext.unk_13E8 == 8) {
+                if (interfaceCtx->bAlpha != 0xFF) {
                     interfaceCtx->bAlpha = alpha;
-            }
-            else
-            {
-                if ((interfaceCtx->bAlpha != 0) && (interfaceCtx->bAlpha > maxAlpha))
+                }
+            } else {
+                if ((interfaceCtx->bAlpha != 0) && (interfaceCtx->bAlpha > maxAlpha)) {
                     interfaceCtx->bAlpha = maxAlpha;
+                }
             }
 
-            if ((interfaceCtx->aAlpha != 0) && (interfaceCtx->aAlpha > maxAlpha))
+            if ((interfaceCtx->aAlpha != 0) && (interfaceCtx->aAlpha > maxAlpha)) {
                 interfaceCtx->aAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->cLeftAlpha != 0) && (interfaceCtx->cLeftAlpha > maxAlpha))
+            if ((interfaceCtx->cLeftAlpha != 0) && (interfaceCtx->cLeftAlpha > maxAlpha)) {
                 interfaceCtx->cLeftAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->cDownAlpha != 0) && (interfaceCtx->cDownAlpha > maxAlpha))
+            if ((interfaceCtx->cDownAlpha != 0) && (interfaceCtx->cDownAlpha > maxAlpha)) {
                 interfaceCtx->cDownAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->cRightAlpha != 0) && (interfaceCtx->cRightAlpha > maxAlpha))
+            if ((interfaceCtx->cRightAlpha != 0) && (interfaceCtx->cRightAlpha > maxAlpha)) {
                 interfaceCtx->cRightAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->healthAlpha != 0) && (interfaceCtx->healthAlpha > maxAlpha))
+            if ((interfaceCtx->healthAlpha != 0) && (interfaceCtx->healthAlpha > maxAlpha)) {
                 interfaceCtx->healthAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->magicAlpha != 0) && (interfaceCtx->magicAlpha > maxAlpha))
+            if ((interfaceCtx->magicAlpha != 0) && (interfaceCtx->magicAlpha > maxAlpha)) {
                 interfaceCtx->magicAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->minimapAlpha != 0) && (interfaceCtx->minimapAlpha > maxAlpha))
+            if ((interfaceCtx->minimapAlpha != 0) && (interfaceCtx->minimapAlpha > maxAlpha)) {
                 interfaceCtx->minimapAlpha = maxAlpha;
+            }
 
             osSyncPrintf("a_alpha=%d, c_alpha=%d\n", interfaceCtx->aAlpha, interfaceCtx->cLeftAlpha);
 
             break;
         case 3:
-            if ((interfaceCtx->aAlpha != 0) && (interfaceCtx->aAlpha > maxAlpha))
+            if ((interfaceCtx->aAlpha != 0) && (interfaceCtx->aAlpha > maxAlpha)) {
                 interfaceCtx->aAlpha = maxAlpha;
+            }
 
             func_8008277C(globalCtx, maxAlpha, alpha);
 
-            if ((interfaceCtx->magicAlpha != 0) && (interfaceCtx->magicAlpha > maxAlpha))
+            if ((interfaceCtx->magicAlpha != 0) && (interfaceCtx->magicAlpha > maxAlpha)) {
                 interfaceCtx->magicAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->minimapAlpha != 0) && (interfaceCtx->minimapAlpha > maxAlpha))
+            if ((interfaceCtx->minimapAlpha != 0) && (interfaceCtx->minimapAlpha > maxAlpha)) {
                 interfaceCtx->minimapAlpha = maxAlpha;
+            }
 
-            if (interfaceCtx->healthAlpha != 0xFF)
+            if (interfaceCtx->healthAlpha != 0xFF) {
                 interfaceCtx->healthAlpha = alpha;
+            }
 
             break;
         case 4:
-            if ((interfaceCtx->bAlpha != 0) && (interfaceCtx->bAlpha > maxAlpha))
+            if ((interfaceCtx->bAlpha != 0) && (interfaceCtx->bAlpha > maxAlpha)) {
                 interfaceCtx->bAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->aAlpha != 0) && (interfaceCtx->aAlpha > maxAlpha))
+            if ((interfaceCtx->aAlpha != 0) && (interfaceCtx->aAlpha > maxAlpha)) {
                 interfaceCtx->aAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->cLeftAlpha != 0) && (interfaceCtx->cLeftAlpha > maxAlpha))
+            if ((interfaceCtx->cLeftAlpha != 0) && (interfaceCtx->cLeftAlpha > maxAlpha)) {
                 interfaceCtx->cLeftAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->cDownAlpha != 0) && (interfaceCtx->cDownAlpha > maxAlpha))
+            if ((interfaceCtx->cDownAlpha != 0) && (interfaceCtx->cDownAlpha > maxAlpha)) {
                 interfaceCtx->cDownAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->cRightAlpha != 0) && (interfaceCtx->cRightAlpha > maxAlpha))
+            if ((interfaceCtx->cRightAlpha != 0) && (interfaceCtx->cRightAlpha > maxAlpha)) {
                 interfaceCtx->cRightAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->healthAlpha != 0) && (interfaceCtx->healthAlpha > maxAlpha))
+            if ((interfaceCtx->healthAlpha != 0) && (interfaceCtx->healthAlpha > maxAlpha)) {
                 interfaceCtx->healthAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->magicAlpha != 0) && (interfaceCtx->magicAlpha > maxAlpha))
+            if ((interfaceCtx->magicAlpha != 0) && (interfaceCtx->magicAlpha > maxAlpha)) {
                 interfaceCtx->magicAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->minimapAlpha != 0) && (interfaceCtx->minimapAlpha > maxAlpha))
+            if ((interfaceCtx->minimapAlpha != 0) && (interfaceCtx->minimapAlpha > maxAlpha)) {
                 interfaceCtx->minimapAlpha = maxAlpha;
+            }
 
-            if (interfaceCtx->aAlpha != 0xFF)
+            if (interfaceCtx->aAlpha != 0xFF) {
                 interfaceCtx->aAlpha = alpha;
+            }
 
             break;
         case 5:
             func_8008277C(globalCtx, maxAlpha, alpha);
 
-            if ((interfaceCtx->minimapAlpha != 0) && (interfaceCtx->minimapAlpha > maxAlpha))
+            if ((interfaceCtx->minimapAlpha != 0) && (interfaceCtx->minimapAlpha > maxAlpha)) {
                 interfaceCtx->minimapAlpha = maxAlpha;
+            }
 
-            if (interfaceCtx->aAlpha != 0xFF)
+            if (interfaceCtx->aAlpha != 0xFF) {
                 interfaceCtx->aAlpha = alpha;
+            }
 
-            if (interfaceCtx->healthAlpha != 0xFF)
+            if (interfaceCtx->healthAlpha != 0xFF) {
                 interfaceCtx->healthAlpha = alpha;
+            }
 
-            if (interfaceCtx->magicAlpha != 0xFF)
+            if (interfaceCtx->magicAlpha != 0xFF) {
                 interfaceCtx->magicAlpha = alpha;
+            }
 
             break;
         case 6:
             func_8008277C(globalCtx, maxAlpha, alpha);
 
-            if (interfaceCtx->aAlpha != 0xFF)
+            if (interfaceCtx->aAlpha != 0xFF) {
                 interfaceCtx->aAlpha = alpha;
+            }
 
-            if (interfaceCtx->healthAlpha != 0xFF)
+            if (interfaceCtx->healthAlpha != 0xFF) {
                 interfaceCtx->healthAlpha = alpha;
+            }
 
-            if (interfaceCtx->magicAlpha != 0xFF)
+            if (interfaceCtx->magicAlpha != 0xFF) {
                 interfaceCtx->magicAlpha = alpha;
+            }
 
-            switch (globalCtx->sceneNum)
-            {
+            switch (globalCtx->sceneNum) {
                 case SCENE_SPOT00:
                 case SCENE_SPOT01:
                 case SCENE_SPOT02:
@@ -391,158 +404,199 @@ void func_80082850(GlobalContext* globalCtx, s16 maxAlpha)
                 case SCENE_SPOT18:
                 case SCENE_SPOT20:
                 case SCENE_GANON_TOU:
-                    if (interfaceCtx->minimapAlpha < 0xAA)
+                    if (interfaceCtx->minimapAlpha < 0xAA) {
                         interfaceCtx->minimapAlpha = alpha;
-                    else
+                    } else {
                         interfaceCtx->minimapAlpha = 0xAA;
+                    }
                     break;
                 default:
-                    if (interfaceCtx->minimapAlpha != 0xFF)
+                    if (interfaceCtx->minimapAlpha != 0xFF) {
                         interfaceCtx->minimapAlpha = alpha;
+                    }
                     break;
             }
             break;
         case 7:
-            if ((interfaceCtx->minimapAlpha != 0) && (interfaceCtx->minimapAlpha > maxAlpha))
+            if ((interfaceCtx->minimapAlpha != 0) && (interfaceCtx->minimapAlpha > maxAlpha)) {
                 interfaceCtx->minimapAlpha = maxAlpha;
+            }
 
             func_80082644(globalCtx, alpha);
 
-            if (interfaceCtx->healthAlpha != 0xFF)
+            if (interfaceCtx->healthAlpha != 0xFF) {
                 interfaceCtx->healthAlpha = alpha;
+            }
 
-            if (interfaceCtx->magicAlpha != 0xFF)
+            if (interfaceCtx->magicAlpha != 0xFF) {
                 interfaceCtx->magicAlpha = alpha;
+            }
 
             break;
         case 9:
-            if ((interfaceCtx->bAlpha != 0) && (interfaceCtx->bAlpha > maxAlpha))
+            if ((interfaceCtx->bAlpha != 0) && (interfaceCtx->bAlpha > maxAlpha)) {
                 interfaceCtx->bAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->aAlpha != 0) && (interfaceCtx->aAlpha > maxAlpha))
+            if ((interfaceCtx->aAlpha != 0) && (interfaceCtx->aAlpha > maxAlpha)) {
                 interfaceCtx->aAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->cLeftAlpha != 0) && (interfaceCtx->cLeftAlpha > maxAlpha))
+            if ((interfaceCtx->cLeftAlpha != 0) && (interfaceCtx->cLeftAlpha > maxAlpha)) {
                 interfaceCtx->cLeftAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->cDownAlpha != 0) && (interfaceCtx->cDownAlpha > maxAlpha))
+            if ((interfaceCtx->cDownAlpha != 0) && (interfaceCtx->cDownAlpha > maxAlpha)) {
                 interfaceCtx->cDownAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->cRightAlpha != 0) && (interfaceCtx->cRightAlpha > maxAlpha))
+            if ((interfaceCtx->cRightAlpha != 0) && (interfaceCtx->cRightAlpha > maxAlpha)) {
                 interfaceCtx->cRightAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->minimapAlpha != 0) && (interfaceCtx->minimapAlpha > maxAlpha))
+            if ((interfaceCtx->minimapAlpha != 0) && (interfaceCtx->minimapAlpha > maxAlpha)) {
                 interfaceCtx->minimapAlpha = maxAlpha;
+            }
 
-            if (interfaceCtx->healthAlpha != 0xFF)
+            if (interfaceCtx->healthAlpha != 0xFF) {
                 interfaceCtx->healthAlpha = alpha;
+            }
 
-            if (interfaceCtx->magicAlpha != 0xFF)
+            if (interfaceCtx->magicAlpha != 0xFF) {
                 interfaceCtx->magicAlpha = alpha;
+            }
 
             break;
         case 10:
-            if ((interfaceCtx->aAlpha != 0) && (interfaceCtx->aAlpha > maxAlpha))
+            if ((interfaceCtx->aAlpha != 0) && (interfaceCtx->aAlpha > maxAlpha)) {
                 interfaceCtx->aAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->cLeftAlpha != 0) && (interfaceCtx->cLeftAlpha > maxAlpha))
+            if ((interfaceCtx->cLeftAlpha != 0) && (interfaceCtx->cLeftAlpha > maxAlpha)) {
                 interfaceCtx->cLeftAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->cDownAlpha != 0) && (interfaceCtx->cDownAlpha > maxAlpha))
+            if ((interfaceCtx->cDownAlpha != 0) && (interfaceCtx->cDownAlpha > maxAlpha)) {
                 interfaceCtx->cDownAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->cRightAlpha != 0) && (interfaceCtx->cRightAlpha > maxAlpha))
+            if ((interfaceCtx->cRightAlpha != 0) && (interfaceCtx->cRightAlpha > maxAlpha)) {
                 interfaceCtx->cRightAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->healthAlpha != 0) && (interfaceCtx->healthAlpha > maxAlpha))
+            if ((interfaceCtx->healthAlpha != 0) && (interfaceCtx->healthAlpha > maxAlpha)) {
                 interfaceCtx->healthAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->magicAlpha != 0) && (interfaceCtx->magicAlpha > maxAlpha))
+            if ((interfaceCtx->magicAlpha != 0) && (interfaceCtx->magicAlpha > maxAlpha)) {
                 interfaceCtx->magicAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->minimapAlpha != 0) && (interfaceCtx->minimapAlpha > maxAlpha))
+            if ((interfaceCtx->minimapAlpha != 0) && (interfaceCtx->minimapAlpha > maxAlpha)) {
                 interfaceCtx->minimapAlpha = maxAlpha;
+            }
 
-            if (interfaceCtx->bAlpha != 0xFF)
+            if (interfaceCtx->bAlpha != 0xFF) {
                 interfaceCtx->bAlpha = alpha;
+            }
 
             break;
         case 11:
-            if ((interfaceCtx->bAlpha != 0) && (interfaceCtx->bAlpha > maxAlpha))
+            if ((interfaceCtx->bAlpha != 0) && (interfaceCtx->bAlpha > maxAlpha)) {
                 interfaceCtx->bAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->aAlpha != 0) && (interfaceCtx->aAlpha > maxAlpha))
+            if ((interfaceCtx->aAlpha != 0) && (interfaceCtx->aAlpha > maxAlpha)) {
                 interfaceCtx->aAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->cLeftAlpha != 0) && (interfaceCtx->cLeftAlpha > maxAlpha))
+            if ((interfaceCtx->cLeftAlpha != 0) && (interfaceCtx->cLeftAlpha > maxAlpha)) {
                 interfaceCtx->cLeftAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->cDownAlpha != 0) && (interfaceCtx->cDownAlpha > maxAlpha))
+            if ((interfaceCtx->cDownAlpha != 0) && (interfaceCtx->cDownAlpha > maxAlpha)) {
                 interfaceCtx->cDownAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->cRightAlpha != 0) && (interfaceCtx->cRightAlpha > maxAlpha))
+            if ((interfaceCtx->cRightAlpha != 0) && (interfaceCtx->cRightAlpha > maxAlpha)) {
                 interfaceCtx->cRightAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->minimapAlpha != 0) && (interfaceCtx->minimapAlpha > maxAlpha))
+            if ((interfaceCtx->minimapAlpha != 0) && (interfaceCtx->minimapAlpha > maxAlpha)) {
                 interfaceCtx->minimapAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->magicAlpha!= 0) && (interfaceCtx->magicAlpha > maxAlpha))
+            if ((interfaceCtx->magicAlpha != 0) && (interfaceCtx->magicAlpha > maxAlpha)) {
                 interfaceCtx->magicAlpha = maxAlpha;
+            }
 
-            if (interfaceCtx->healthAlpha != 0xFF)
+            if (interfaceCtx->healthAlpha != 0xFF) {
                 interfaceCtx->healthAlpha = alpha;
+            }
 
             break;
         case 12:
-            if (interfaceCtx->aAlpha != 0xFF)
+            if (interfaceCtx->aAlpha != 0xFF) {
                 interfaceCtx->aAlpha = alpha;
+            }
 
-            if (interfaceCtx->bAlpha != 0xFF)
+            if (interfaceCtx->bAlpha != 0xFF) {
                 interfaceCtx->bAlpha = alpha;
+            }
 
-            if (interfaceCtx->minimapAlpha != 0xFF)
+            if (interfaceCtx->minimapAlpha != 0xFF) {
                 interfaceCtx->minimapAlpha = alpha;
+            }
 
-            if ((interfaceCtx->cLeftAlpha != 0) && (interfaceCtx->cLeftAlpha > maxAlpha))
+            if ((interfaceCtx->cLeftAlpha != 0) && (interfaceCtx->cLeftAlpha > maxAlpha)) {
                 interfaceCtx->cLeftAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->cDownAlpha != 0) && (interfaceCtx->cDownAlpha > maxAlpha))
+            if ((interfaceCtx->cDownAlpha != 0) && (interfaceCtx->cDownAlpha > maxAlpha)) {
                 interfaceCtx->cDownAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->cRightAlpha != 0) && (interfaceCtx->cRightAlpha > maxAlpha))
+            if ((interfaceCtx->cRightAlpha != 0) && (interfaceCtx->cRightAlpha > maxAlpha)) {
                 interfaceCtx->cRightAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->magicAlpha != 0) && (interfaceCtx->magicAlpha > maxAlpha))
+            if ((interfaceCtx->magicAlpha != 0) && (interfaceCtx->magicAlpha > maxAlpha)) {
                 interfaceCtx->magicAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->healthAlpha != 0) && (interfaceCtx->healthAlpha > maxAlpha))
+            if ((interfaceCtx->healthAlpha != 0) && (interfaceCtx->healthAlpha > maxAlpha)) {
                 interfaceCtx->healthAlpha = maxAlpha;
+            }
 
             break;
         case 13:
             func_8008277C(globalCtx, maxAlpha, alpha);
 
-            if ((interfaceCtx->minimapAlpha != 0) && (interfaceCtx->minimapAlpha > maxAlpha))
+            if ((interfaceCtx->minimapAlpha != 0) && (interfaceCtx->minimapAlpha > maxAlpha)) {
                 interfaceCtx->minimapAlpha = maxAlpha;
+            }
 
-            if ((interfaceCtx->aAlpha != 0) && (interfaceCtx->aAlpha > maxAlpha))
+            if ((interfaceCtx->aAlpha != 0) && (interfaceCtx->aAlpha > maxAlpha)) {
                 interfaceCtx->aAlpha = maxAlpha;
+            }
 
-            if (interfaceCtx->healthAlpha != 0xFF)
+            if (interfaceCtx->healthAlpha != 0xFF) {
                 interfaceCtx->healthAlpha = alpha;
+            }
 
-            if (interfaceCtx->magicAlpha != 0xFF)
+            if (interfaceCtx->magicAlpha != 0xFF) {
                 interfaceCtx->magicAlpha = alpha;
+            }
 
             break;
     }
 
-    if ((globalCtx->roomCtx.curRoom.unk_03 == 1) && (interfaceCtx->minimapAlpha >= 0xFF))
+    if ((globalCtx->roomCtx.curRoom.unk_03 == 1) && (interfaceCtx->minimapAlpha >= 0xFF)) {
         interfaceCtx->minimapAlpha = 0xFF;
+    }
 }
 
-void func_80083108(GlobalContext* globalCtx)
-{
+void func_80083108(GlobalContext* globalCtx) {
     MessageContext* msgCtx = &globalCtx->msgCtx;
     Player* player = PLAYER;
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
@@ -552,86 +606,72 @@ void func_80083108(GlobalContext* globalCtx)
     sp28 = 0;
 
     if ((gSaveContext.cutscene_index < 0xFFF0) ||
-        ((globalCtx->sceneNum == SCENE_SPOT20) && (gSaveContext.cutscene_index == 0xFFF0)))
-    {
+        ((globalCtx->sceneNum == SCENE_SPOT20) && (gSaveContext.cutscene_index == 0xFFF0))) {
         gSaveContext.unk_13E7 = 0;
 
         if ((player->stateFlags1 & 0x00800000) || (globalCtx->unk_11E5C >= 2) ||
-            ((globalCtx->sceneNum == SCENE_BOWLING) && Flags_GetSwitch(globalCtx, 0x38)))
-        {
-            if (gSaveContext.equips.button_items[0] != ITEM_NONE)
-            {
+            ((globalCtx->sceneNum == SCENE_BOWLING) && Flags_GetSwitch(globalCtx, 0x38))) {
+            if (gSaveContext.equips.button_items[0] != ITEM_NONE) {
                 gSaveContext.unk_13E7 = 1;
 
-                if (gSaveContext.button_status[0] == BTN_DISABLED)
-                {
-                    gSaveContext.button_status[0] = gSaveContext.button_status[1] =
-                    gSaveContext.button_status[2] = gSaveContext.button_status[3] = BTN_ENABLED;
+                if (gSaveContext.button_status[0] == BTN_DISABLED) {
+                    gSaveContext.button_status[0] = gSaveContext.button_status[1] = gSaveContext.button_status[2] =
+                        gSaveContext.button_status[3] = BTN_ENABLED;
                 }
 
                 if ((gSaveContext.equips.button_items[0] != ITEM_SLINGSHOT) &&
                     (gSaveContext.equips.button_items[0] != ITEM_BOW) &&
                     (gSaveContext.equips.button_items[0] != ITEM_BOMBCHU) &&
-                    (gSaveContext.equips.button_items[0] != ITEM_NONE))
-                {
+                    (gSaveContext.equips.button_items[0] != ITEM_NONE)) {
                     gSaveContext.button_status[0] = gSaveContext.equips.button_items[0];
 
-                    if ((globalCtx->sceneNum == SCENE_BOWLING) && Flags_GetSwitch(globalCtx, 0x38))
-                    {
+                    if ((globalCtx->sceneNum == SCENE_BOWLING) && Flags_GetSwitch(globalCtx, 0x38)) {
                         gSaveContext.equips.button_items[0] = ITEM_BOMBCHU;
                         Interface_LoadItemIcon1(globalCtx, 0);
-                    }
-                    else
-                    {
+                    } else {
                         gSaveContext.equips.button_items[0] = ITEM_BOW;
-                        if (globalCtx->unk_11E5C >= 2)
-                        {
-                            if (LINK_AGE_IN_YEARS == YEARS_CHILD)
+                        if (globalCtx->unk_11E5C >= 2) {
+                            if (LINK_AGE_IN_YEARS == YEARS_CHILD) {
                                 gSaveContext.equips.button_items[0] = ITEM_SLINGSHOT;
+                            }
 
                             Interface_LoadItemIcon1(globalCtx, 0);
-                        }
-                        else
-                        {
-                            if (gSaveContext.items[SLOT_BOW] == ITEM_NONE)
+                        } else {
+                            if (gSaveContext.items[SLOT_BOW] == ITEM_NONE) {
                                 gSaveContext.equips.button_items[0] = ITEM_NONE;
-                            else
+                            } else {
                                 Interface_LoadItemIcon1(globalCtx, 0);
+                            }
                         }
                     }
 
-                    gSaveContext.button_status[1] = gSaveContext.button_status[2] = gSaveContext.button_status[3] = BTN_DISABLED;
+                    gSaveContext.button_status[1] = gSaveContext.button_status[2] = gSaveContext.button_status[3] =
+                        BTN_DISABLED;
                     Interface_ChangeAlpha(6);
                 }
 
-                if (globalCtx->unk_1241B != 0)
+                if (globalCtx->unk_1241B != 0) {
                     Interface_ChangeAlpha(1);
-                else if (gSaveContext.minigame_state == 1)
+                } else if (gSaveContext.minigame_state == 1) {
                     Interface_ChangeAlpha(8);
-                else if (globalCtx->unk_11E5C >= 2)
+                } else if (globalCtx->unk_11E5C >= 2) {
                     Interface_ChangeAlpha(8);
-                else if ((globalCtx->sceneNum == SCENE_BOWLING) && Flags_GetSwitch(globalCtx, 0x38))
+                } else if ((globalCtx->sceneNum == SCENE_BOWLING) && Flags_GetSwitch(globalCtx, 0x38)) {
                     Interface_ChangeAlpha(8);
-                else if (player->stateFlags1 & 0x00800000)
+                } else if (player->stateFlags1 & 0x00800000) {
                     Interface_ChangeAlpha(12);
-            }
-            else
-            {
-                if (player->stateFlags1 & 0x00800000)
+                }
+            } else {
+                if (player->stateFlags1 & 0x00800000) {
                     Interface_ChangeAlpha(12);
+                }
             }
-        }
-        else if (globalCtx->sceneNum == SCENE_KENJYANOMA)
-        {
+        } else if (globalCtx->sceneNum == SCENE_KENJYANOMA) {
             Interface_ChangeAlpha(1);
-        }
-        else if (globalCtx->sceneNum == SCENE_TURIBORI)
-        {
+        } else if (globalCtx->sceneNum == SCENE_TURIBORI) {
             gSaveContext.unk_13E7 = 2;
-            if (globalCtx->interfaceCtx.unk_260 != 0)
-            {
-                if (gSaveContext.equips.button_items[0] != ITEM_FISHING_POLE)
-                {
+            if (globalCtx->interfaceCtx.unk_260 != 0) {
+                if (gSaveContext.equips.button_items[0] != ITEM_FISHING_POLE) {
                     gSaveContext.button_status[0] = gSaveContext.equips.button_items[0];
                     gSaveContext.equips.button_items[0] = ITEM_FISHING_POLE;
                     gSaveContext.unk_13EA = 0;
@@ -639,78 +679,69 @@ void func_80083108(GlobalContext* globalCtx)
                     Interface_ChangeAlpha(12);
                 }
 
-                if (gSaveContext.unk_13EA != 12)
+                if (gSaveContext.unk_13EA != 12) {
                     Interface_ChangeAlpha(12);
-            }
-            else if (gSaveContext.equips.button_items[0] == ITEM_FISHING_POLE)
-            {
+                }
+            } else if (gSaveContext.equips.button_items[0] == ITEM_FISHING_POLE) {
                 gSaveContext.equips.button_items[0] = gSaveContext.button_status[0];
                 gSaveContext.unk_13EA = 0;
 
-                if (gSaveContext.equips.button_items[0] != ITEM_NONE)
+                if (gSaveContext.equips.button_items[0] != ITEM_NONE) {
                     Interface_LoadItemIcon1(globalCtx, 0);
+                }
 
-                gSaveContext.button_status[0] = gSaveContext.button_status[1] =
-                gSaveContext.button_status[2] = gSaveContext.button_status[3] = BTN_DISABLED;
+                gSaveContext.button_status[0] = gSaveContext.button_status[1] = gSaveContext.button_status[2] =
+                    gSaveContext.button_status[3] = BTN_DISABLED;
                 Interface_ChangeAlpha(50);
-            }
-            else
-            {
-                if (gSaveContext.button_status[0] == BTN_ENABLED)
+            } else {
+                if (gSaveContext.button_status[0] == BTN_ENABLED) {
                     gSaveContext.unk_13EA = 0;
+                }
 
-                gSaveContext.button_status[0] = gSaveContext.button_status[1] =
-                gSaveContext.button_status[2] = gSaveContext.button_status[3] = BTN_DISABLED;
+                gSaveContext.button_status[0] = gSaveContext.button_status[1] = gSaveContext.button_status[2] =
+                    gSaveContext.button_status[3] = BTN_DISABLED;
                 Interface_ChangeAlpha(50);
             }
-        }
-        else if (msgCtx->msgMode == 0)
-        {
-            if ((func_8008F2F8(globalCtx) >= 2) && (func_8008F2F8(globalCtx) < 5))
-            {
-                if (gSaveContext.button_status[0] != BTN_DISABLED)
+        } else if (msgCtx->msgMode == 0) {
+            if ((func_8008F2F8(globalCtx) >= 2) && (func_8008F2F8(globalCtx) < 5)) {
+                if (gSaveContext.button_status[0] != BTN_DISABLED) {
                     sp28 = 1;
+                }
 
                 gSaveContext.button_status[0] = BTN_DISABLED;
 
-                for (i = 1; i < 4; i++)
-                {
-                    if (func_8008F2F8(globalCtx) == 2)
-                    {
+                for (i = 1; i < 4; i++) {
+                    if (func_8008F2F8(globalCtx) == 2) {
                         if ((gSaveContext.equips.button_items[i] != ITEM_HOOKSHOT) &&
-                            (gSaveContext.equips.button_items[i] != ITEM_LONGSHOT))
-                        {
-                            if (gSaveContext.button_status[i] == BTN_ENABLED)
+                            (gSaveContext.equips.button_items[i] != ITEM_LONGSHOT)) {
+                            if (gSaveContext.button_status[i] == BTN_ENABLED) {
                                 sp28 = 1;
+                            }
 
                             gSaveContext.button_status[i] = BTN_DISABLED;
-                        }
-                        else
-                        {
-                            if (gSaveContext.button_status[i] == BTN_DISABLED)
+                        } else {
+                            if (gSaveContext.button_status[i] == BTN_DISABLED) {
                                 sp28 = 1;
+                            }
 
                             gSaveContext.button_status[i] = BTN_ENABLED;
                         }
-                    }
-                    else
-                    {
-                        if (gSaveContext.button_status[i] == BTN_ENABLED)
+                    } else {
+                        if (gSaveContext.button_status[i] == BTN_ENABLED) {
                             sp28 = 1;
+                        }
 
                         gSaveContext.button_status[i] = BTN_DISABLED;
                     }
                 }
 
-                if (sp28)
+                if (sp28) {
                     gSaveContext.unk_13EA = 0;
+                }
 
                 Interface_ChangeAlpha(50);
-            }
-            else if ((player->stateFlags1 & 0x00200000) || (player->stateFlags2 & 0x00040000))
-            {
-                if (gSaveContext.button_status[0] != BTN_DISABLED)
-                {
+            } else if ((player->stateFlags1 & 0x00200000) || (player->stateFlags2 & 0x00040000)) {
+                if (gSaveContext.button_status[0] != BTN_DISABLED) {
                     gSaveContext.button_status[0] = BTN_DISABLED;
                     gSaveContext.button_status[1] = BTN_DISABLED;
                     gSaveContext.button_status[2] = BTN_DISABLED;
@@ -718,341 +749,278 @@ void func_80083108(GlobalContext* globalCtx)
                     gSaveContext.unk_13EA = 0;
                     Interface_ChangeAlpha(50);
                 }
-            }
-            else if ((gSaveContext.event_inf[0] & 0xF) == 1)
-            {
-                if (player->stateFlags1 & 0x00800000)
-                {
+            } else if ((gSaveContext.event_inf[0] & 0xF) == 1) {
+                if (player->stateFlags1 & 0x00800000) {
                     if ((gSaveContext.equips.button_items[0] != ITEM_NONE) &&
-                        (gSaveContext.equips.button_items[0] != ITEM_BOW))
-                    {
-                        if (gSaveContext.items[SLOT_BOW] == ITEM_NONE)
-                        {
+                        (gSaveContext.equips.button_items[0] != ITEM_BOW)) {
+                        if (gSaveContext.items[SLOT_BOW] == ITEM_NONE) {
                             gSaveContext.equips.button_items[0] = ITEM_NONE;
-                        }
-                        else
-                        {
+                        } else {
                             gSaveContext.equips.button_items[0] = ITEM_BOW;
                             sp28 = 1;
                         }
                     }
-                }
-                else do
-                {
-                    sp28 = 1;
+                } else {
+                    do {
+                        sp28 = 1;
 
-                    if ((gSaveContext.equips.button_items[0] == ITEM_NONE) ||
-                         (gSaveContext.equips.button_items[0] == ITEM_BOW))
-                    {
+                        if ((gSaveContext.equips.button_items[0] == ITEM_NONE) ||
+                            (gSaveContext.equips.button_items[0] == ITEM_BOW)) {
 
-                        if ((gSaveContext.equips.button_items[0] != ITEM_SWORD_KOKIRI) &&
-                            (gSaveContext.equips.button_items[0] != ITEM_SWORD_MASTER) &&
-                            (gSaveContext.equips.button_items[0] != ITEM_SWORD_BGS) &&
-                            (gSaveContext.equips.button_items[0] != ITEM_SWORD_KNIFE))
-                        {
-                            gSaveContext.equips.button_items[0] =  gSaveContext.button_status[0];
-                        }
-                        else
-                        {
-                            gSaveContext.button_status[0] = gSaveContext.equips.button_items[0];
+                            if ((gSaveContext.equips.button_items[0] != ITEM_SWORD_KOKIRI) &&
+                                (gSaveContext.equips.button_items[0] != ITEM_SWORD_MASTER) &&
+                                (gSaveContext.equips.button_items[0] != ITEM_SWORD_BGS) &&
+                                (gSaveContext.equips.button_items[0] != ITEM_SWORD_KNIFE)) {
+                                gSaveContext.equips.button_items[0] = gSaveContext.button_status[0];
+                            } else {
+                                gSaveContext.button_status[0] = gSaveContext.equips.button_items[0];
+                            }
                         }
-                    }
-                } while (0); // Necessary to match
+                    } while (0); // Necessary to match
+                }
 
-                if (sp28)
-                {
+                if (sp28) {
                     Interface_LoadItemIcon1(globalCtx, 0);
                     sp28 = 0;
                 }
 
-                for (i = 1; i < 4; i++)
-                {
+                for (i = 1; i < 4; i++) {
                     if ((gSaveContext.equips.button_items[i] != ITEM_OCARINA_FAIRY) &&
-                        (gSaveContext.equips.button_items[i] != ITEM_OCARINA_TIME))
-                    {
-                        if (gSaveContext.button_status[i] == BTN_ENABLED)
+                        (gSaveContext.equips.button_items[i] != ITEM_OCARINA_TIME)) {
+                        if (gSaveContext.button_status[i] == BTN_ENABLED) {
                             sp28 = 1;
+                        }
 
                         gSaveContext.button_status[i] = BTN_DISABLED;
-                    }
-                    else
-                    {
-                        if (gSaveContext.button_status[i] == BTN_DISABLED)
+                    } else {
+                        if (gSaveContext.button_status[i] == BTN_DISABLED) {
                             sp28 = 1;
+                        }
 
                         gSaveContext.button_status[i] = BTN_ENABLED;
                     }
                 }
 
-                if (sp28)
+                if (sp28) {
                     gSaveContext.unk_13EA = 0;
+                }
 
                 Interface_ChangeAlpha(50);
-            }
-            else
-            {
-                if (interfaceCtx->restrictions.bButton == 0)
-                {
+            } else {
+                if (interfaceCtx->restrictions.bButton == 0) {
                     if ((gSaveContext.equips.button_items[0] == ITEM_SLINGSHOT) ||
                         (gSaveContext.equips.button_items[0] == ITEM_BOW) ||
                         (gSaveContext.equips.button_items[0] == ITEM_BOMBCHU) ||
-                        (gSaveContext.equips.button_items[0] == ITEM_NONE))
-                    {
-                        if ((gSaveContext.equips.button_items[0] != ITEM_NONE) || (gSaveContext.inf_table[29] == 0))
-                        {
+                        (gSaveContext.equips.button_items[0] == ITEM_NONE)) {
+                        if ((gSaveContext.equips.button_items[0] != ITEM_NONE) || (gSaveContext.inf_table[29] == 0)) {
                             gSaveContext.equips.button_items[0] = gSaveContext.button_status[0];
                             sp28 = 1;
 
-                            if (gSaveContext.equips.button_items[0] != ITEM_NONE)
+                            if (gSaveContext.equips.button_items[0] != ITEM_NONE) {
                                 Interface_LoadItemIcon1(globalCtx, 0);
+                            }
                         }
-                    }
-                    else if ((gSaveContext.button_status[0] & 0xFF) == BTN_DISABLED)
-                    {
+                    } else if ((gSaveContext.button_status[0] & 0xFF) == BTN_DISABLED) {
                         sp28 = 1;
 
                         if (((gSaveContext.button_status[0] & 0xFF) == BTN_DISABLED) ||
-                            ((gSaveContext.button_status[0] & 0xFF) == BTN_ENABLED))
-                        {
+                            ((gSaveContext.button_status[0] & 0xFF) == BTN_ENABLED)) {
                             gSaveContext.button_status[0] = BTN_ENABLED;
-                        }
-                        else
-                        {
+                        } else {
                             gSaveContext.equips.button_items[0] = gSaveContext.button_status[0] & 0xFF;
                         }
                     }
-                }
-                else if (interfaceCtx->restrictions.bButton == 1)
-                {
+                } else if (interfaceCtx->restrictions.bButton == 1) {
                     if ((gSaveContext.equips.button_items[0] == ITEM_SLINGSHOT) ||
                         (gSaveContext.equips.button_items[0] == ITEM_BOW) ||
                         (gSaveContext.equips.button_items[0] == ITEM_BOMBCHU) ||
-                        (gSaveContext.equips.button_items[0] == ITEM_NONE))
-                    {
-                        if ((gSaveContext.equips.button_items[0] != ITEM_NONE) || (gSaveContext.inf_table[29] == 0))
-                        {
+                        (gSaveContext.equips.button_items[0] == ITEM_NONE)) {
+                        if ((gSaveContext.equips.button_items[0] != ITEM_NONE) || (gSaveContext.inf_table[29] == 0)) {
                             gSaveContext.equips.button_items[0] = gSaveContext.button_status[0];
                             sp28 = 1;
 
-                            if (gSaveContext.equips.button_items[0] != ITEM_NONE)
+                            if (gSaveContext.equips.button_items[0] != ITEM_NONE) {
                                 Interface_LoadItemIcon1(globalCtx, 0);
+                            }
                         }
-                    }
-                    else
-                    {
-                        if (gSaveContext.button_status[0] == BTN_ENABLED)
+                    } else {
+                        if (gSaveContext.button_status[0] == BTN_ENABLED) {
                             sp28 = 1;
+                        }
 
                         gSaveContext.button_status[0] = BTN_DISABLED;
                     }
                 }
 
-                if (interfaceCtx->restrictions.bottles != 0)
-                {
-                    for (i = 1; i < 4; i++)
-                    {
+                if (interfaceCtx->restrictions.bottles != 0) {
+                    for (i = 1; i < 4; i++) {
                         if ((gSaveContext.equips.button_items[i] >= ITEM_BOTTLE) &&
-                            (gSaveContext.equips.button_items[i] <= ITEM_POE))
-                        {
-                            if (gSaveContext.button_status[i] == BTN_ENABLED)
+                            (gSaveContext.equips.button_items[i] <= ITEM_POE)) {
+                            if (gSaveContext.button_status[i] == BTN_ENABLED) {
                                 sp28 = 1;
+                            }
 
                             gSaveContext.button_status[i] = BTN_DISABLED;
                         }
                     }
-                }
-                else if (interfaceCtx->restrictions.bottles == 0)
-                {
-                    for (i = 1; i < 4; i++)
-                    {
+                } else if (interfaceCtx->restrictions.bottles == 0) {
+                    for (i = 1; i < 4; i++) {
                         if ((gSaveContext.equips.button_items[i] >= ITEM_BOTTLE) &&
-                            (gSaveContext.equips.button_items[i] <= ITEM_POE))
-                        {
-                            if (gSaveContext.button_status[i] == BTN_DISABLED)
+                            (gSaveContext.equips.button_items[i] <= ITEM_POE)) {
+                            if (gSaveContext.button_status[i] == BTN_DISABLED) {
                                 sp28 = 1;
+                            }
 
                             gSaveContext.button_status[i] = BTN_ENABLED;
                         }
                     }
                 }
 
-                if (interfaceCtx->restrictions.tradeItems != 0)
-                {
-                    for (i = 1; i < 4; i++)
-                    {
+                if (interfaceCtx->restrictions.tradeItems != 0) {
+                    for (i = 1; i < 4; i++) {
                         if ((gSaveContext.equips.button_items[i] >= ITEM_WEIRD_EGG) &&
-                            (gSaveContext.equips.button_items[i] <= ITEM_CLAIM_CHECK))
-                        {
-                            if (gSaveContext.button_status[i] == BTN_ENABLED)
+                            (gSaveContext.equips.button_items[i] <= ITEM_CLAIM_CHECK)) {
+                            if (gSaveContext.button_status[i] == BTN_ENABLED) {
                                 sp28 = 1;
+                            }
 
                             gSaveContext.button_status[i] = BTN_DISABLED;
                         }
                     }
-                }
-                else if (interfaceCtx->restrictions.tradeItems == 0)
-                {
-                    for (i = 1; i < 4; i++)
-                    {
+                } else if (interfaceCtx->restrictions.tradeItems == 0) {
+                    for (i = 1; i < 4; i++) {
                         if ((gSaveContext.equips.button_items[i] >= ITEM_WEIRD_EGG) &&
-                            (gSaveContext.equips.button_items[i] <= ITEM_CLAIM_CHECK))
-                        {
-                            if (gSaveContext.button_status[i] == BTN_DISABLED)
+                            (gSaveContext.equips.button_items[i] <= ITEM_CLAIM_CHECK)) {
+                            if (gSaveContext.button_status[i] == BTN_DISABLED) {
                                 sp28 = 1;
+                            }
 
                             gSaveContext.button_status[i] = BTN_ENABLED;
                         }
                     }
                 }
 
-                if (interfaceCtx->restrictions.hookshot != 0)
-                {
-                    for (i = 1; i < 4; i++)
-                    {
+                if (interfaceCtx->restrictions.hookshot != 0) {
+                    for (i = 1; i < 4; i++) {
                         if ((gSaveContext.equips.button_items[i] == ITEM_HOOKSHOT) ||
-                            (gSaveContext.equips.button_items[i] == ITEM_LONGSHOT))
-                        {
-                            if (gSaveContext.button_status[i] == BTN_ENABLED)
+                            (gSaveContext.equips.button_items[i] == ITEM_LONGSHOT)) {
+                            if (gSaveContext.button_status[i] == BTN_ENABLED) {
                                 sp28 = 1;
+                            }
 
                             gSaveContext.button_status[i] = BTN_DISABLED;
                         }
                     }
-                }
-                else if (interfaceCtx->restrictions.hookshot == 0)
-                {
-                    for (i = 1; i < 4; i++)
-                    {
+                } else if (interfaceCtx->restrictions.hookshot == 0) {
+                    for (i = 1; i < 4; i++) {
                         if ((gSaveContext.equips.button_items[i] == ITEM_HOOKSHOT) ||
-                            (gSaveContext.equips.button_items[i] == ITEM_LONGSHOT))
-                        {
-                            if (gSaveContext.button_status[i] == BTN_DISABLED)
+                            (gSaveContext.equips.button_items[i] == ITEM_LONGSHOT)) {
+                            if (gSaveContext.button_status[i] == BTN_DISABLED) {
                                 sp28 = 1;
+                            }
 
                             gSaveContext.button_status[i] = BTN_ENABLED;
                         }
                     }
                 }
 
-                if (interfaceCtx->restrictions.ocarina != 0)
-                {
-                    for (i = 1; i < 4; i++)
-                    {
+                if (interfaceCtx->restrictions.ocarina != 0) {
+                    for (i = 1; i < 4; i++) {
                         if ((gSaveContext.equips.button_items[i] == ITEM_OCARINA_FAIRY) ||
-                            (gSaveContext.equips.button_items[i] == ITEM_OCARINA_TIME))
-                        {
-                            if (gSaveContext.button_status[i] == BTN_ENABLED)
+                            (gSaveContext.equips.button_items[i] == ITEM_OCARINA_TIME)) {
+                            if (gSaveContext.button_status[i] == BTN_ENABLED) {
                                 sp28 = 1;
+                            }
 
                             gSaveContext.button_status[i] = BTN_DISABLED;
                         }
                     }
-                }
-                else if (interfaceCtx->restrictions.ocarina == 0)
-                {
-                    for (i = 1; i < 4; i++)
-                    {
+                } else if (interfaceCtx->restrictions.ocarina == 0) {
+                    for (i = 1; i < 4; i++) {
                         if ((gSaveContext.equips.button_items[i] == ITEM_OCARINA_FAIRY) ||
-                            (gSaveContext.equips.button_items[i] == ITEM_OCARINA_TIME))
-                        {
-                            if (gSaveContext.button_status[i] == BTN_DISABLED)
+                            (gSaveContext.equips.button_items[i] == ITEM_OCARINA_TIME)) {
+                            if (gSaveContext.button_status[i] == BTN_DISABLED) {
                                 sp28 = 1;
+                            }
 
                             gSaveContext.button_status[i] = BTN_ENABLED;
                         }
                     }
                 }
 
-                if (interfaceCtx->restrictions.farores != 0)
-                {
-                    for (i = 1; i < 4; i++)
-                    {
-                        if (gSaveContext.equips.button_items[i] == ITEM_FARORES_WIND)
-                        {
-                            if (gSaveContext.button_status[i] == BTN_ENABLED)
+                if (interfaceCtx->restrictions.farores != 0) {
+                    for (i = 1; i < 4; i++) {
+                        if (gSaveContext.equips.button_items[i] == ITEM_FARORES_WIND) {
+                            if (gSaveContext.button_status[i] == BTN_ENABLED) {
                                 sp28 = 1;
+                            }
 
                             gSaveContext.button_status[i] = BTN_DISABLED;
                             osSyncPrintf("***(i=%d)***  ", i);
                         }
                     }
-                }
-                else if (interfaceCtx->restrictions.farores == 0)
-                {
-                    for (i = 1; i < 4; i++)
-                    {
-                        if (gSaveContext.equips.button_items[i] == ITEM_FARORES_WIND)
-                        {
-                            if (gSaveContext.button_status[i] == BTN_DISABLED)
+                } else if (interfaceCtx->restrictions.farores == 0) {
+                    for (i = 1; i < 4; i++) {
+                        if (gSaveContext.equips.button_items[i] == ITEM_FARORES_WIND) {
+                            if (gSaveContext.button_status[i] == BTN_DISABLED) {
                                 sp28 = 1;
+                            }
 
                             gSaveContext.button_status[i] = BTN_ENABLED;
                         }
                     }
                 }
 
-                if (interfaceCtx->restrictions.dinsNayrus != 0)
-                {
-                    for (i = 1; i < 4; i++)
-                    {
+                if (interfaceCtx->restrictions.dinsNayrus != 0) {
+                    for (i = 1; i < 4; i++) {
                         if ((gSaveContext.equips.button_items[i] == ITEM_DINS_FIRE) ||
-                            (gSaveContext.equips.button_items[i] == ITEM_NAYRUS_LOVE))
-                        {
-                            if (gSaveContext.button_status[i] == BTN_ENABLED)
+                            (gSaveContext.equips.button_items[i] == ITEM_NAYRUS_LOVE)) {
+                            if (gSaveContext.button_status[i] == BTN_ENABLED) {
                                 sp28 = 1;
+                            }
 
                             gSaveContext.button_status[i] = BTN_DISABLED;
                         }
                     }
-                }
-                else if (interfaceCtx->restrictions.dinsNayrus == 0)
-                {
-                    for (i = 1; i < 4; i++)
-                    {
+                } else if (interfaceCtx->restrictions.dinsNayrus == 0) {
+                    for (i = 1; i < 4; i++) {
                         if ((gSaveContext.equips.button_items[i] == ITEM_DINS_FIRE) ||
-                            (gSaveContext.equips.button_items[i] == ITEM_NAYRUS_LOVE))
-                        {
-                            if (gSaveContext.button_status[i] == BTN_DISABLED)
+                            (gSaveContext.equips.button_items[i] == ITEM_NAYRUS_LOVE)) {
+                            if (gSaveContext.button_status[i] == BTN_DISABLED) {
                                 sp28 = 1;
+                            }
 
                             gSaveContext.button_status[i] = BTN_ENABLED;
                         }
                     }
                 }
 
-                if (interfaceCtx->restrictions.all != 0)
-                {
-                    for (i = 1; i < 4; i++)
-                    {
+                if (interfaceCtx->restrictions.all != 0) {
+                    for (i = 1; i < 4; i++) {
                         if ((gSaveContext.equips.button_items[i] != ITEM_OCARINA_FAIRY) &&
                             (gSaveContext.equips.button_items[i] != ITEM_OCARINA_TIME) &&
                             !((gSaveContext.equips.button_items[i] >= ITEM_BOTTLE) &&
                               (gSaveContext.equips.button_items[i] <= ITEM_POE)) &&
                             !((gSaveContext.equips.button_items[i] >= ITEM_WEIRD_EGG) &&
-                              (gSaveContext.equips.button_items[i] <= ITEM_CLAIM_CHECK)))
-                        {
+                              (gSaveContext.equips.button_items[i] <= ITEM_CLAIM_CHECK))) {
                             if ((globalCtx->sceneNum != SCENE_TAKARAYA) ||
-                                (gSaveContext.equips.button_items[i] != ITEM_LENS))
-                            {
-                                if (gSaveContext.button_status[i] == BTN_ENABLED)
+                                (gSaveContext.equips.button_items[i] != ITEM_LENS)) {
+                                if (gSaveContext.button_status[i] == BTN_ENABLED) {
                                     sp28 = 1;
+                                }
 
                                 gSaveContext.button_status[i] = BTN_DISABLED;
-                            }
-                            else
-                            {
-                                if (gSaveContext.button_status[i] == BTN_DISABLED)
+                            } else {
+                                if (gSaveContext.button_status[i] == BTN_DISABLED) {
                                     sp28 = 1;
+                                }
 
                                 gSaveContext.button_status[i] = BTN_ENABLED;
                             }
                         }
                     }
-                }
-                else if (interfaceCtx->restrictions.all == 0)
-                {
-                    for (i = 1; i < 4; i++)
-                    {
+                } else if (interfaceCtx->restrictions.all == 0) {
+                    for (i = 1; i < 4; i++) {
                         if ((gSaveContext.equips.button_items[i] != ITEM_DINS_FIRE) &&
                             (gSaveContext.equips.button_items[i] != ITEM_HOOKSHOT) &&
                             (gSaveContext.equips.button_items[i] != ITEM_LONGSHOT) &&
@@ -1063,10 +1031,10 @@ void func_80083108(GlobalContext* globalCtx)
                             !((gSaveContext.equips.button_items[i] >= ITEM_BOTTLE) &&
                               (gSaveContext.equips.button_items[i] <= ITEM_POE)) &&
                             !((gSaveContext.equips.button_items[i] >= ITEM_WEIRD_EGG) &&
-                              (gSaveContext.equips.button_items[i] <= ITEM_CLAIM_CHECK)))
-                        {
-                            if (gSaveContext.button_status[i] == BTN_DISABLED)
+                              (gSaveContext.equips.button_items[i] <= ITEM_CLAIM_CHECK))) {
+                            if (gSaveContext.button_status[i] == BTN_DISABLED) {
                                 sp28 = 1;
+                            }
 
                             gSaveContext.button_status[i] = BTN_ENABLED;
                         }
@@ -1076,44 +1044,39 @@ void func_80083108(GlobalContext* globalCtx)
         }
     }
 
-    if (sp28)
-    {
+    if (sp28) {
         gSaveContext.unk_13EA = 0;
-        if ((globalCtx->sceneLoadFlag == 0) && (globalCtx->unk_1241B == 0))
-        {
+        if ((globalCtx->sceneLoadFlag == 0) && (globalCtx->unk_1241B == 0)) {
             Interface_ChangeAlpha(50);
             osSyncPrintf("????????  alpha_change( 50 );  ?????\n");
-        }
-        else
-        {
+        } else {
             osSyncPrintf("game_play->fade_direction || game_play->fbdemo_wipe_modem");
         }
     }
 }
 
-void Interface_SetSceneRestrictions(GlobalContext* globalCtx)
-{
+void Interface_SetSceneRestrictions(GlobalContext* globalCtx) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
     s16 i;
     u8 currentScene;
 
+    // clang-format off
     interfaceCtx->restrictions.hGauge = interfaceCtx->restrictions.bButton =
     interfaceCtx->restrictions.aButton = interfaceCtx->restrictions.bottles =
-    interfaceCtx->restrictions.tradeItems = interfaceCtx->restrictions.hookshot =
+    interfaceCtx->restrictions.tradeItems = interfaceCtx->restrictions.hookshot = 
     interfaceCtx->restrictions.ocarina = interfaceCtx->restrictions.warpSongs =
     interfaceCtx->restrictions.sunsSong = interfaceCtx->restrictions.farores =
     interfaceCtx->restrictions.dinsNayrus = interfaceCtx->restrictions.all = 0;
+    // clang-format on
 
     i = 0;
 
     // Translates to: "Data settings related to button display scene_data_ID=%d\n"
     osSyncPrintf("ボタン表示関係データ設定 scene_data_ID=%d\n", globalCtx->sceneNum);
 
-    do
-    {
+    do {
         currentScene = (u8)globalCtx->sceneNum;
-        if (sRestrictionFlags[i].scene == currentScene)
-        {
+        if (sRestrictionFlags[i].scene == currentScene) {
             interfaceCtx->restrictions.hGauge = (sRestrictionFlags[i].flags1 & 0xC0) >> 6;
             interfaceCtx->restrictions.bButton = (sRestrictionFlags[i].flags1 & 0x30) >> 4;
             interfaceCtx->restrictions.aButton = (sRestrictionFlags[i].flags1 & 0x0C) >> 2;
@@ -1128,104 +1091,76 @@ void Interface_SetSceneRestrictions(GlobalContext* globalCtx)
             interfaceCtx->restrictions.all = (sRestrictionFlags[i].flags3 & 0x03) >> 0;
 
             osSyncPrintf(VT_FGCOL(YELLOW));
-            osSyncPrintf("parameter->button_status = %x,%x,%x\n",
-                         sRestrictionFlags[i].flags1, sRestrictionFlags[i].flags2, sRestrictionFlags[i].flags3);
-            osSyncPrintf("h_gage=%d, b_button=%d, a_button=%d, c_bottle=%d\n",
-                         interfaceCtx->restrictions.hGauge, interfaceCtx->restrictions.bButton,
-                         interfaceCtx->restrictions.aButton, interfaceCtx->restrictions.bottles);
-            osSyncPrintf("c_warasibe=%d, c_hook=%d, c_ocarina=%d, c_warp=%d\n",
-                         interfaceCtx->restrictions.tradeItems, interfaceCtx->restrictions.hookshot,
-                         interfaceCtx->restrictions.ocarina, interfaceCtx->restrictions.warpSongs);
-            osSyncPrintf("c_sunmoon=%d, m_wind=%d, m_magic=%d, another=%d\n",
-                         interfaceCtx->restrictions.sunsSong, interfaceCtx->restrictions.farores,
-                         interfaceCtx->restrictions.dinsNayrus, interfaceCtx->restrictions.all);
+            osSyncPrintf("parameter->button_status = %x,%x,%x\n", sRestrictionFlags[i].flags1,
+                         sRestrictionFlags[i].flags2, sRestrictionFlags[i].flags3);
+            osSyncPrintf("h_gage=%d, b_button=%d, a_button=%d, c_bottle=%d\n", interfaceCtx->restrictions.hGauge,
+                         interfaceCtx->restrictions.bButton, interfaceCtx->restrictions.aButton,
+                         interfaceCtx->restrictions.bottles);
+            osSyncPrintf("c_warasibe=%d, c_hook=%d, c_ocarina=%d, c_warp=%d\n", interfaceCtx->restrictions.tradeItems,
+                         interfaceCtx->restrictions.hookshot, interfaceCtx->restrictions.ocarina,
+                         interfaceCtx->restrictions.warpSongs);
+            osSyncPrintf("c_sunmoon=%d, m_wind=%d, m_magic=%d, another=%d\n", interfaceCtx->restrictions.sunsSong,
+                         interfaceCtx->restrictions.farores, interfaceCtx->restrictions.dinsNayrus,
+                         interfaceCtx->restrictions.all);
             osSyncPrintf(VT_RST);
             return;
         }
         i++;
-    }
-    while (sRestrictionFlags[i].scene != 0xFF);
+    } while (sRestrictionFlags[i].scene != 0xFF);
 }
 
-Gfx* Draw_TextureIA8(Gfx* displayListHead, void* texture, s16 textureWidth, s16 textureHeight,
-                     s16 rectLeft, s16 rectTop, s16 rectWidth, s16 rectHeight, u16 dsdx, u16 dtdy)
-{
-    gDPLoadTextureBlock(displayListHead++,
-                        texture,
-                        G_IM_FMT_IA,
-                        G_IM_SIZ_8b,
-                        textureWidth, textureHeight,
-                        0,
-                        G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP,
-                        G_TX_NOMASK, G_TX_NOMASK,
-                        G_TX_NOLOD, G_TX_NOLOD);
-
-    gSPTextureRectangle(displayListHead++,
-                        rectLeft * 4, rectTop * 4,
-                        (rectLeft + rectWidth) * 4, (rectTop + rectHeight) * 4,
-                        G_TX_RENDERTILE,
-                        0, 0,
-                        dsdx, dtdy);
+Gfx* Gfx_TextureIA8(Gfx* displayListHead, void* texture, s16 textureWidth, s16 textureHeight, s16 rectLeft, s16 rectTop,
+                    s16 rectWidth, s16 rectHeight, u16 dsdx, u16 dtdy) {
+    gDPLoadTextureBlock(displayListHead++, texture, G_IM_FMT_IA, G_IM_SIZ_8b, textureWidth, textureHeight, 0,
+                        G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
+                        G_TX_NOLOD);
+
+    gSPTextureRectangle(displayListHead++, rectLeft * 4, rectTop * 4, (rectLeft + rectWidth) * 4,
+                        (rectTop + rectHeight) * 4, G_TX_RENDERTILE, 0, 0, dsdx, dtdy);
 
     return displayListHead;
 }
 
-Gfx* Draw_TextureI8(Gfx* displayListHead, void* texture, s16 textureWidth, s16 textureHeight,
-                    s16 rectLeft, s16 rectTop, s16 rectWidth, s16 rectHeight, u16 dsdx, u16 dtdy)
-{
-    gDPLoadTextureBlock(displayListHead++,
-                        texture,
-                        G_IM_FMT_I,
-                        G_IM_SIZ_8b,
-                        textureWidth, textureHeight,
-                        0,
-                        G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP,
-                        G_TX_NOMASK, G_TX_NOMASK,
-                        G_TX_NOLOD, G_TX_NOLOD);
-
-    gSPTextureRectangle(displayListHead++,
-                        rectLeft * 4, rectTop * 4,
-                        (rectLeft + rectWidth) * 4, (rectTop + rectHeight) * 4,
-                        G_TX_RENDERTILE,
-                        0, 0,
-                        dsdx, dtdy);
+Gfx* Gfx_TextureI8(Gfx* displayListHead, void* texture, s16 textureWidth, s16 textureHeight, s16 rectLeft, s16 rectTop,
+                   s16 rectWidth, s16 rectHeight, u16 dsdx, u16 dtdy) {
+    gDPLoadTextureBlock(displayListHead++, texture, G_IM_FMT_I, G_IM_SIZ_8b, textureWidth, textureHeight, 0,
+                        G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
+                        G_TX_NOLOD);
+
+    gSPTextureRectangle(displayListHead++, rectLeft * 4, rectTop * 4, (rectLeft + rectWidth) * 4,
+                        (rectTop + rectHeight) * 4, G_TX_RENDERTILE, 0, 0, dsdx, dtdy);
 
     return displayListHead;
 }
 
 #ifdef NON_MATCHING
 // regalloc differences
-void Inventory_SwapAgeEquipment(void)
-{
+void Inventory_SwapAgeEquipment(void) {
     s16 i;
     u16 temp;
 
-    if (LINK_AGE_IN_YEARS == YEARS_CHILD)
-    {
-        for (i = 0; i < 4; i++)
-        {
-            if (i != 0)
+    if (LINK_AGE_IN_YEARS == YEARS_CHILD) {
+        for (i = 0; i < 4; i++) {
+            if (i != 0) {
                 gSaveContext.child_equips.button_items[i] = gSaveContext.equips.button_items[i];
-            else
+            } else {
                 gSaveContext.child_equips.button_items[i] = ITEM_SWORD_KOKIRI;
+            }
 
-            if (i != 0)
-                gSaveContext.child_equips.c_button_slots[i-1] = gSaveContext.equips.c_button_slots[i-1];
+            if (i != 0) {
+                gSaveContext.child_equips.c_button_slots[i - 1] = gSaveContext.equips.c_button_slots[i - 1];
+            }
         }
 
         gSaveContext.child_equips.equipment = gSaveContext.equips.equipment;
 
-        if (gSaveContext.adult_equips.button_items[0] == ITEM_NONE)
-        {
+        if (gSaveContext.adult_equips.button_items[0] == ITEM_NONE) {
             gSaveContext.equips.button_items[0] = ITEM_SWORD_MASTER;
 
-            if (gSaveContext.items[SLOT_NUT] != ITEM_NONE)
-            {
+            if (gSaveContext.items[SLOT_NUT] != ITEM_NONE) {
                 gSaveContext.equips.button_items[1] = ITEM_NUT;
                 gSaveContext.equips.c_button_slots[0] = SLOT_NUT;
-            }
-            else
-            {
+            } else {
                 gSaveContext.equips.c_button_slots[0] = SLOT_NONE;
                 gSaveContext.equips.button_items[1] = ITEM_NONE;
             }
@@ -1235,57 +1170,50 @@ void Inventory_SwapAgeEquipment(void)
             gSaveContext.equips.c_button_slots[2] = SLOT_OCARINA;
             gSaveContext.equips.equipment = 0x1122;
             gSaveContext.equips.button_items[3] = gSaveContext.items[SLOT_OCARINA];
-        }
-        else
-        {
-            for (i = 0; i < 4; i++)
-            {
+        } else {
+            for (i = 0; i < 4; i++) {
                 gSaveContext.equips.button_items[i] = gSaveContext.adult_equips.button_items[i];
 
-                if (i != 0)
-                    gSaveContext.equips.c_button_slots[i-1] = gSaveContext.adult_equips.c_button_slots[i-1];
+                if (i != 0) {
+                    gSaveContext.equips.c_button_slots[i - 1] = gSaveContext.adult_equips.c_button_slots[i - 1];
+                }
 
                 if (((gSaveContext.equips.button_items[i] >= ITEM_BOTTLE) &&
                      (gSaveContext.equips.button_items[i] <= ITEM_POE)) ||
                     ((gSaveContext.equips.button_items[i] >= ITEM_WEIRD_EGG) &&
-                     (gSaveContext.equips.button_items[i] <= ITEM_CLAIM_CHECK)))
-                {
-                    osSyncPrintf("Register_Item_Pt(%d)=%d\n", i, gSaveContext.equips.c_button_slots[i-1]);
-                    gSaveContext.equips.button_items[i] = gSaveContext.items[gSaveContext.equips.c_button_slots[i-1]];
+                     (gSaveContext.equips.button_items[i] <= ITEM_CLAIM_CHECK))) {
+                    osSyncPrintf("Register_Item_Pt(%d)=%d\n", i, gSaveContext.equips.c_button_slots[i - 1]);
+                    gSaveContext.equips.button_items[i] = gSaveContext.items[gSaveContext.equips.c_button_slots[i - 1]];
                 }
             }
 
             gSaveContext.equips.equipment = gSaveContext.adult_equips.equipment;
         }
-    }
-    else
-    {
-        for (i = 0; i < 4; i++)
-        {
+    } else {
+        for (i = 0; i < 4; i++) {
             gSaveContext.adult_equips.button_items[i] = gSaveContext.equips.button_items[i];
 
-            if (i != 0)
-                gSaveContext.adult_equips.c_button_slots[i-1] = gSaveContext.equips.c_button_slots[i-1];
+            if (i != 0) {
+                gSaveContext.adult_equips.c_button_slots[i - 1] = gSaveContext.equips.c_button_slots[i - 1];
+            }
         }
 
         gSaveContext.adult_equips.equipment = gSaveContext.equips.equipment;
 
-        if (gSaveContext.child_equips.button_items[0] != ITEM_NONE)
-        {
-            for (i = 0; i < 4; i++)
-            {
+        if (gSaveContext.child_equips.button_items[0] != ITEM_NONE) {
+            for (i = 0; i < 4; i++) {
                 gSaveContext.equips.button_items[i] = gSaveContext.child_equips.button_items[i];
 
-                if (i != 0)
-                    gSaveContext.equips.c_button_slots[i-1] = gSaveContext.child_equips.c_button_slots[i-1];
+                if (i != 0) {
+                    gSaveContext.equips.c_button_slots[i - 1] = gSaveContext.child_equips.c_button_slots[i - 1];
+                }
 
                 if (((gSaveContext.equips.button_items[i] >= ITEM_BOTTLE) &&
                      (gSaveContext.equips.button_items[i] <= ITEM_POE)) ||
                     ((gSaveContext.equips.button_items[i] >= ITEM_WEIRD_EGG) &&
-                     (gSaveContext.equips.button_items[i] <= ITEM_CLAIM_CHECK)))
-                {
-                    osSyncPrintf("Register_Item_Pt(%d)=%d\n", i, gSaveContext.equips.c_button_slots[i-1]);
-                    gSaveContext.equips.button_items[i] = gSaveContext.items[gSaveContext.equips.c_button_slots[i-1]];
+                     (gSaveContext.equips.button_items[i] <= ITEM_CLAIM_CHECK))) {
+                    osSyncPrintf("Register_Item_Pt(%d)=%d\n", i, gSaveContext.equips.c_button_slots[i - 1]);
+                    gSaveContext.equips.button_items[i] = gSaveContext.items[gSaveContext.equips.c_button_slots[i - 1]];
                 }
             }
 
@@ -1296,19 +1224,18 @@ void Inventory_SwapAgeEquipment(void)
     }
 
     temp = gEquipMasks[EQUIP_SHIELD] & gSaveContext.equips.equipment;
-    if (temp != 0)
-    {
+    if (temp != 0) {
         temp >>= gEquipShifts[EQUIP_SHIELD];
-        if (!(gBitFlags[temp + 3] & gSaveContext.equipment))
+        if (!(gBitFlags[temp + 3] & gSaveContext.equipment)) {
             gSaveContext.equips.equipment &= gEquipNegMasks[EQUIP_SHIELD];
+        }
     }
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_parameter/Inventory_SwapAgeEquipment.s")
 #endif
 
-void Interface_InitHorsebackArchery(GlobalContext* globalCtx)
-{
+void Interface_InitHorsebackArchery(GlobalContext* globalCtx) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
 
     gSaveContext.minigame_state = 1;
@@ -1317,21 +1244,20 @@ void Interface_InitHorsebackArchery(GlobalContext* globalCtx)
     interfaceCtx->hbaAmmo = 20;
 }
 
-void func_800849EC(GlobalContext* globalCtx)
-{
+void func_800849EC(GlobalContext* globalCtx) {
     gSaveContext.equipment |= gBitFlags[2] << gEquipShifts[0];
     gSaveContext.equipment ^= 8 << gEquipShifts[0];
 
-    if (gBitFlags[3] & gSaveContext.equipment)
+    if (gBitFlags[3] & gSaveContext.equipment) {
         gSaveContext.equips.button_items[0] = ITEM_SWORD_KNIFE;
-    else
+    } else {
         gSaveContext.equips.button_items[0] = ITEM_SWORD_BGS;
+    }
 
     Interface_LoadItemIcon1(globalCtx, 0);
 }
 
-void Interface_LoadItemIcon1(GlobalContext* globalCtx, u16 button)
-{
+void Interface_LoadItemIcon1(GlobalContext* globalCtx, u16 button) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
 
     osCreateMesgQueue(&interfaceCtx->loadQueue, &interfaceCtx->loadMsg, OS_MESG_BLOCK);
@@ -1341,8 +1267,7 @@ void Interface_LoadItemIcon1(GlobalContext* globalCtx, u16 button)
     osRecvMesg(&interfaceCtx->loadQueue, NULL, OS_MESG_BLOCK);
 }
 
-void Interface_LoadItemIcon2(GlobalContext* globalCtx, u16 button)
-{
+void Interface_LoadItemIcon2(GlobalContext* globalCtx, u16 button) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
 
     osCreateMesgQueue(&interfaceCtx->loadQueue, &interfaceCtx->loadMsg, OS_MESG_BLOCK);
@@ -1352,42 +1277,33 @@ void Interface_LoadItemIcon2(GlobalContext* globalCtx, u16 button)
     osRecvMesg(&interfaceCtx->loadQueue, NULL, OS_MESG_BLOCK);
 }
 
-void func_80084BF4(GlobalContext* globalCtx, u16 flag)
-{
-    if (flag)
-    {
+void func_80084BF4(GlobalContext* globalCtx, u16 flag) {
+    if (flag) {
         if ((gSaveContext.equips.button_items[0] == ITEM_SLINGSHOT) ||
             (gSaveContext.equips.button_items[0] == ITEM_BOW) ||
             (gSaveContext.equips.button_items[0] == ITEM_BOMBCHU) ||
             (gSaveContext.equips.button_items[0] == ITEM_FISHING_POLE) ||
-            (gSaveContext.button_status[0] == BTN_DISABLED))
-        {
+            (gSaveContext.button_status[0] == BTN_DISABLED)) {
             if ((gSaveContext.equips.button_items[0] == ITEM_SLINGSHOT) ||
                 (gSaveContext.equips.button_items[0] == ITEM_BOW) ||
                 (gSaveContext.equips.button_items[0] == ITEM_BOMBCHU) ||
-                (gSaveContext.equips.button_items[0] == ITEM_FISHING_POLE))
-            {
+                (gSaveContext.equips.button_items[0] == ITEM_FISHING_POLE)) {
                 gSaveContext.equips.button_items[0] = gSaveContext.button_status[0];
                 Interface_LoadItemIcon1(globalCtx, 0);
             }
-        }
-        else if (gSaveContext.equips.button_items[0] == ITEM_NONE)
-        {
-            if ((gSaveContext.equips.button_items[0] != ITEM_NONE) || (gSaveContext.inf_table[29] == 0))
-            {
+        } else if (gSaveContext.equips.button_items[0] == ITEM_NONE) {
+            if ((gSaveContext.equips.button_items[0] != ITEM_NONE) || (gSaveContext.inf_table[29] == 0)) {
                 gSaveContext.equips.button_items[0] = gSaveContext.button_status[0];
                 Interface_LoadItemIcon1(globalCtx, 0);
             }
         }
 
-        gSaveContext.button_status[0] = gSaveContext.button_status[1] =
-        gSaveContext.button_status[2] = gSaveContext.button_status[3] = BTN_ENABLED;
+        gSaveContext.button_status[0] = gSaveContext.button_status[1] = gSaveContext.button_status[2] =
+            gSaveContext.button_status[3] = BTN_ENABLED;
         Interface_ChangeAlpha(7);
-    }
-    else
-    {
-        gSaveContext.button_status[0] = gSaveContext.button_status[1] =
-        gSaveContext.button_status[2] = gSaveContext.button_status[3] = BTN_ENABLED;
+    } else {
+        gSaveContext.button_status[0] = gSaveContext.button_status[1] = gSaveContext.button_status[2] =
+            gSaveContext.button_status[3] = BTN_ENABLED;
         func_80083108(globalCtx);
     }
 }
@@ -1396,8 +1312,7 @@ s16 sAmmoRefillCounts[] = { 5, 10, 20, 30, 5, 10, 30, 0, 5, 20, 1, 5, 20, 50, 20
 
 #ifdef NON_MATCHING
 // regalloc, minor ordering and stack usage differences
-u8 Item_Give(GlobalContext* globalCtx, u8 item)
-{
+u8 Item_Give(GlobalContext* globalCtx, u8 item) {
     s16 i;
     s16 slot;
     s16 oldItem;
@@ -1406,15 +1321,15 @@ u8 Item_Give(GlobalContext* globalCtx, u8 item)
     s8 bombCount;
 
     slot = SLOT(item);
-    if (item >= ITEM_STICKS_5)
+    if (item >= ITEM_STICKS_5) {
         slot = SLOT(sExtraItemBases[item - ITEM_STICKS_5]);
+    }
 
     osSyncPrintf(VT_FGCOL(YELLOW));
     osSyncPrintf("item_get_setting=%d  pt=%d  z=%x\n", item, slot, gSaveContext.items[slot]);
     osSyncPrintf(VT_RST);
 
-    if ((item >= ITEM_MEDALLION_FOREST) && (item <= ITEM_MEDALLION_LIGHT))
-    {
+    if ((item >= ITEM_MEDALLION_FOREST) && (item <= ITEM_MEDALLION_LIGHT)) {
         gSaveContext.quest_items |= gBitFlags[item - ITEM_MEDALLION_FOREST];
 
         osSyncPrintf(VT_FGCOL(YELLOW));
@@ -1422,27 +1337,24 @@ u8 Item_Give(GlobalContext* globalCtx, u8 item)
         osSyncPrintf("封印 = %x\n", gSaveContext.quest_items);
         osSyncPrintf(VT_RST);
 
-        if (item == ITEM_MEDALLION_WATER)
+        if (item == ITEM_MEDALLION_WATER) {
             func_8006D0AC(globalCtx);
+        }
 
         return ITEM_NONE;
-    }
-    else if ((item >= ITEM_SONG_MINUET) && (item <= ITEM_SONG_STORMS))
-    {
+    } else if ((item >= ITEM_SONG_MINUET) && (item <= ITEM_SONG_STORMS)) {
         gSaveContext.quest_items |= gBitFlags[item - ITEM_SONG_MINUET + 6];
 
         osSyncPrintf(VT_FGCOL(YELLOW));
         // Translates to: "Musical scores = %x"
         osSyncPrintf("楽譜 = %x\n", gSaveContext.quest_items);
         // Translates to: "Musical scores = %x (%x) (%x)"
-        osSyncPrintf("楽譜 = %x (%x) (%x)\n", gSaveContext.quest_items,
-                     gBitFlags[item - ITEM_SONG_MINUET + 6], gBitFlags[item - ITEM_SONG_MINUET]);
+        osSyncPrintf("楽譜 = %x (%x) (%x)\n", gSaveContext.quest_items, gBitFlags[item - ITEM_SONG_MINUET + 6],
+                     gBitFlags[item - ITEM_SONG_MINUET]);
         osSyncPrintf(VT_RST);
 
         return ITEM_NONE;
-    }
-    else if ((item >= ITEM_KOKIRI_EMERALD) && (item <= ITEM_ZORA_SAPPHIRE))
-    {
+    } else if ((item >= ITEM_KOKIRI_EMERALD) && (item <= ITEM_ZORA_SAPPHIRE)) {
         gSaveContext.quest_items |= gBitFlags[item - ITEM_KOKIRI_EMERALD + 18];
 
         osSyncPrintf(VT_FGCOL(YELLOW));
@@ -1451,9 +1363,7 @@ u8 Item_Give(GlobalContext* globalCtx, u8 item)
         osSyncPrintf(VT_RST);
 
         return ITEM_NONE;
-    }
-    else if ((item == ITEM_STONE_OF_AGONY) || (item == ITEM_GERUDO_CARD))
-    {
+    } else if ((item == ITEM_STONE_OF_AGONY) || (item == ITEM_GERUDO_CARD)) {
         gSaveContext.quest_items |= gBitFlags[item - ITEM_STONE_OF_AGONY + 21];
 
         osSyncPrintf(VT_FGCOL(YELLOW));
@@ -1462,9 +1372,7 @@ u8 Item_Give(GlobalContext* globalCtx, u8 item)
         osSyncPrintf(VT_RST);
 
         return ITEM_NONE;
-    }
-    else if (item == ITEM_SKULL_TOKEN)
-    {
+    } else if (item == ITEM_SKULL_TOKEN) {
         gSaveContext.quest_items |= gBitFlags[item - ITEM_SKULL_TOKEN + 23];
         gSaveContext.gs_tokens++;
 
@@ -1474,27 +1382,20 @@ u8 Item_Give(GlobalContext* globalCtx, u8 item)
         osSyncPrintf(VT_RST);
 
         return ITEM_NONE;
-    }
-    else if ((item >= ITEM_SWORD_KOKIRI) && (item <= ITEM_SWORD_BGS))
-    {
+    } else if ((item >= ITEM_SWORD_KOKIRI) && (item <= ITEM_SWORD_BGS)) {
         gSaveContext.equipment |= gBitFlags[item - ITEM_SWORD_KOKIRI] << gEquipShifts[EQUIP_SWORD];
 
-        if (item == ITEM_SWORD_BGS)
-        {
+        if (item == ITEM_SWORD_BGS) {
             gSaveContext.bgs_hits_left = 8;
 
-            if (ALL_EQUIP_VALUE(EQUIP_SWORD) == 0xF)
-            {
+            if (ALL_EQUIP_VALUE(EQUIP_SWORD) == 0xF) {
                 gSaveContext.equipment ^= 8 << gEquipShifts[EQUIP_SWORD];
-                if (gSaveContext.equips.button_items[0] == ITEM_SWORD_KNIFE)
-                {
+                if (gSaveContext.equips.button_items[0] == ITEM_SWORD_KNIFE) {
                     gSaveContext.equips.button_items[0] = ITEM_SWORD_BGS;
                     Interface_LoadItemIcon1(globalCtx, 0);
                 }
             }
-        }
-        else if (item == ITEM_SWORD_MASTER)
-        {
+        } else if (item == ITEM_SWORD_MASTER) {
             gSaveContext.equips.button_items[0] = ITEM_SWORD_MASTER;
             gSaveContext.equips.equipment &= 0xFFF0;
             gSaveContext.equips.equipment |= 0x0002;
@@ -1502,481 +1403,353 @@ u8 Item_Give(GlobalContext* globalCtx, u8 item)
         }
 
         return ITEM_NONE;
-    }
-    else if ((item >= ITEM_SHIELD_DEKU) && (item <= ITEM_SHIELD_MIRROR))
-    {
+    } else if ((item >= ITEM_SHIELD_DEKU) && (item <= ITEM_SHIELD_MIRROR)) {
         gSaveContext.equipment |= (gBitFlags[item - ITEM_SHIELD_DEKU] << gEquipShifts[EQUIP_SHIELD]);
         return ITEM_NONE;
-    }
-    else if ((item >= ITEM_TUNIC_KOKIRI) && (item <= ITEM_TUNIC_ZORA))
-    {
+    } else if ((item >= ITEM_TUNIC_KOKIRI) && (item <= ITEM_TUNIC_ZORA)) {
         gSaveContext.equipment |= (gBitFlags[item - ITEM_TUNIC_KOKIRI] << gEquipShifts[EQUIP_TUNIC]);
         return ITEM_NONE;
-    }
-    else if ((item >= ITEM_BOOTS_KOKIRI) && (item <= ITEM_BOOTS_HOVER))
-    {
+    } else if ((item >= ITEM_BOOTS_KOKIRI) && (item <= ITEM_BOOTS_HOVER)) {
         gSaveContext.equipment |= (gBitFlags[item - ITEM_BOOTS_KOKIRI] << gEquipShifts[EQUIP_BOOTS]);
         return ITEM_NONE;
-    }
-    else if ((item == ITEM_KEY_BOSS) || (item == ITEM_COMPASS) || (item == ITEM_DUNGEON_MAP))
-    {
+    } else if ((item == ITEM_KEY_BOSS) || (item == ITEM_COMPASS) || (item == ITEM_DUNGEON_MAP)) {
         gSaveContext.dungeon_items[gSaveContext.dungeon_index] |= gBitFlags[item - ITEM_KEY_BOSS];
         return ITEM_NONE;
-    }
-    else if (item == ITEM_KEY_SMALL)
-    {
-        if (gSaveContext.dungeon_keys[gSaveContext.dungeon_index] < 0)
-        {
+    } else if (item == ITEM_KEY_SMALL) {
+        if (gSaveContext.dungeon_keys[gSaveContext.dungeon_index] < 0) {
             gSaveContext.dungeon_keys[gSaveContext.dungeon_index] = 1;
             return ITEM_NONE;
-        }
-        else
-        {
+        } else {
             gSaveContext.dungeon_keys[gSaveContext.dungeon_index]++;
             return ITEM_NONE;
         }
-    }
-    else if ((item == ITEM_QUIVER_30) || (item == ITEM_BOW))
-    {
-        if (CUR_UPG_VALUE(UPG_QUIVER) == 0)
-        {
+    } else if ((item == ITEM_QUIVER_30) || (item == ITEM_BOW)) {
+        if (CUR_UPG_VALUE(UPG_QUIVER) == 0) {
             Inventory_ChangeUpgrade(UPG_QUIVER, 1);
             INV_CONTENT(ITEM_BOW) = ITEM_BOW;
             AMMO(ITEM_BOW) = CAPACITY(UPG_QUIVER, 1);
             return ITEM_NONE;
-        }
-        else
-        {
+        } else {
             AMMO(ITEM_BOW)++;
-            if (AMMO(ITEM_BOW) > CUR_CAPACITY(UPG_QUIVER))
+            if (AMMO(ITEM_BOW) > CUR_CAPACITY(UPG_QUIVER)) {
                 AMMO(ITEM_BOW) = CUR_CAPACITY(UPG_QUIVER);
+            }
         }
-    }
-    else if (item == ITEM_QUIVER_40)
-    {
+    } else if (item == ITEM_QUIVER_40) {
         Inventory_ChangeUpgrade(UPG_QUIVER, 2);
         AMMO(ITEM_BOW) = CAPACITY(UPG_QUIVER, 2);
         return ITEM_NONE;
-    }
-    else if (item == ITEM_QUIVER_50)
-    {
+    } else if (item == ITEM_QUIVER_50) {
         Inventory_ChangeUpgrade(UPG_QUIVER, 3);
         AMMO(ITEM_BOW) = CAPACITY(UPG_QUIVER, 3);
         return ITEM_NONE;
-    }
-    else if (item == ITEM_BULLET_BAG_40)
-    {
+    } else if (item == ITEM_BULLET_BAG_40) {
         Inventory_ChangeUpgrade(UPG_BULLET_BAG, 2);
         AMMO(ITEM_SLINGSHOT) = CAPACITY(UPG_BULLET_BAG, 2);
         return ITEM_NONE;
-    }
-    else if (item == ITEM_BULLET_BAG_50)
-    {
+    } else if (item == ITEM_BULLET_BAG_50) {
         Inventory_ChangeUpgrade(UPG_BULLET_BAG, 3);
         AMMO(ITEM_SLINGSHOT) = CAPACITY(UPG_BULLET_BAG, 3);
         return ITEM_NONE;
-    }
-    else if (item == ITEM_BOMB_BAG_20)
-    {
-        if (CUR_UPG_VALUE(UPG_BOMB_BAG) == 0)
-        {
+    } else if (item == ITEM_BOMB_BAG_20) {
+        if (CUR_UPG_VALUE(UPG_BOMB_BAG) == 0) {
             Inventory_ChangeUpgrade(UPG_BOMB_BAG, 1);
             INV_CONTENT(ITEM_BOMB) = ITEM_BOMB;
             AMMO(ITEM_BOMB) = CAPACITY(UPG_BOMB_BAG, 1);
             return ITEM_NONE;
-        }
-        else
-        {
+        } else {
             AMMO(ITEM_BOMB)++;
-            if (AMMO(ITEM_BOMB) > CUR_CAPACITY(UPG_BOMB_BAG))
+            if (AMMO(ITEM_BOMB) > CUR_CAPACITY(UPG_BOMB_BAG)) {
                 AMMO(ITEM_BOMB) = CUR_CAPACITY(UPG_BOMB_BAG);
+            }
         }
-    }
-    else if (item == ITEM_BOMB_BAG_30)
-    {
+    } else if (item == ITEM_BOMB_BAG_30) {
         Inventory_ChangeUpgrade(UPG_BOMB_BAG, 2);
         AMMO(ITEM_BOMB) = CAPACITY(UPG_BOMB_BAG, 2);
         return ITEM_NONE;
-    }
-    else if (item == ITEM_BOMB_BAG_40)
-    {
+    } else if (item == ITEM_BOMB_BAG_40) {
         Inventory_ChangeUpgrade(UPG_BOMB_BAG, 3);
         AMMO(ITEM_BOMB) = CAPACITY(UPG_BOMB_BAG, 3);
         return ITEM_NONE;
-    }
-    else if (item == ITEM_BRACELET)
-    {
+    } else if (item == ITEM_BRACELET) {
         Inventory_ChangeUpgrade(UPG_STRENGTH, 1);
         return ITEM_NONE;
-    }
-    else if (item == ITEM_GAUNTLETS_SILVER)
-    {
+    } else if (item == ITEM_GAUNTLETS_SILVER) {
         Inventory_ChangeUpgrade(UPG_STRENGTH, 2);
         return ITEM_NONE;
-    }
-    else if (item == ITEM_GAUNTLETS_GOLD)
-    {
+    } else if (item == ITEM_GAUNTLETS_GOLD) {
         Inventory_ChangeUpgrade(UPG_STRENGTH, 3);
         return ITEM_NONE;
-    }
-    else if (item == ITEM_SCALE_SILVER)
-    {
+    } else if (item == ITEM_SCALE_SILVER) {
         Inventory_ChangeUpgrade(UPG_SCALE, 1);
         return ITEM_NONE;
-    }
-    else if (item == ITEM_SCALE_GOLDEN)
-    {
+    } else if (item == ITEM_SCALE_GOLDEN) {
         Inventory_ChangeUpgrade(UPG_SCALE, 2);
         return ITEM_NONE;
-    }
-    else if (item == ITEM_WALLET_ADULT)
-    {
+    } else if (item == ITEM_WALLET_ADULT) {
         Inventory_ChangeUpgrade(UPG_WALLET, 1);
         return ITEM_NONE;
-    }
-    else if (item == ITEM_WALLET_GIANT)
-    {
+    } else if (item == ITEM_WALLET_GIANT) {
         Inventory_ChangeUpgrade(UPG_WALLET, 2);
         return ITEM_NONE;
-    }
-    else if (item == ITEM_STICK_UPGRADE_20)
-    {
-        if (gSaveContext.items[slot] == ITEM_NONE)
+    } else if (item == ITEM_STICK_UPGRADE_20) {
+        if (gSaveContext.items[slot] == ITEM_NONE) {
             INV_CONTENT(ITEM_STICK) = ITEM_STICK;
+        }
         Inventory_ChangeUpgrade(UPG_STICKS, 2);
         AMMO(ITEM_STICK) = CAPACITY(UPG_STICKS, 2);
         return ITEM_NONE;
-    }
-    else if (item == ITEM_STICK_UPGRADE_30)
-    {
-        if (gSaveContext.items[slot] == ITEM_NONE)
+    } else if (item == ITEM_STICK_UPGRADE_30) {
+        if (gSaveContext.items[slot] == ITEM_NONE) {
             INV_CONTENT(ITEM_STICK) = ITEM_STICK;
+        }
         Inventory_ChangeUpgrade(UPG_STICKS, 3);
         AMMO(ITEM_STICK) = CAPACITY(UPG_STICKS, 3);
         return ITEM_NONE;
-    }
-    else if (item == ITEM_NUT_UPGRADE_30)
-    {
-        if (gSaveContext.items[slot] == ITEM_NONE)
+    } else if (item == ITEM_NUT_UPGRADE_30) {
+        if (gSaveContext.items[slot] == ITEM_NONE) {
             INV_CONTENT(ITEM_NUT) = ITEM_NUT;
+        }
         Inventory_ChangeUpgrade(UPG_NUTS, 2);
         AMMO(ITEM_NUT) = CAPACITY(UPG_NUTS, 2);
         return ITEM_NONE;
-    }
-    else if (item == ITEM_NUT_UPGRADE_40)
-    {
-        if (gSaveContext.items[slot] == ITEM_NONE)
+    } else if (item == ITEM_NUT_UPGRADE_40) {
+        if (gSaveContext.items[slot] == ITEM_NONE) {
             INV_CONTENT(ITEM_NUT) = ITEM_NUT;
+        }
         Inventory_ChangeUpgrade(UPG_NUTS, 3);
         AMMO(ITEM_NUT) = CAPACITY(UPG_NUTS, 3);
         return ITEM_NONE;
-    }
-    else if (item == ITEM_LONGSHOT)
-    {
+    } else if (item == ITEM_LONGSHOT) {
         INV_CONTENT(item) = item;
-        for (i = 1; i < 4; i++)
-        {
-            if (gSaveContext.equips.button_items[i] == ITEM_HOOKSHOT)
-            {
+        for (i = 1; i < 4; i++) {
+            if (gSaveContext.equips.button_items[i] == ITEM_HOOKSHOT) {
                 gSaveContext.equips.button_items[i] = ITEM_LONGSHOT;
                 Interface_LoadItemIcon1(globalCtx, i);
             }
         }
         return ITEM_NONE;
-    }
-    else if (item == ITEM_STICK)
-    {
-        if (gSaveContext.items[slot] == ITEM_NONE)
-        {
+    } else if (item == ITEM_STICK) {
+        if (gSaveContext.items[slot] == ITEM_NONE) {
             Inventory_ChangeUpgrade(UPG_STICKS, 1);
             AMMO(ITEM_STICK) = 1;
-        }
-        else
-        {
+        } else {
             AMMO(ITEM_STICK)++;
-            if (AMMO(ITEM_STICK) > CUR_CAPACITY(UPG_STICKS))
+            if (AMMO(ITEM_STICK) > CUR_CAPACITY(UPG_STICKS)) {
                 AMMO(ITEM_STICK) = CUR_CAPACITY(UPG_STICKS);
+            }
         }
-    }
-    else if ((item == ITEM_STICKS_5) || (item == ITEM_STICKS_10))
-    {
-        if (gSaveContext.items[slot] == ITEM_NONE)
-        {
+    } else if ((item == ITEM_STICKS_5) || (item == ITEM_STICKS_10)) {
+        if (gSaveContext.items[slot] == ITEM_NONE) {
             Inventory_ChangeUpgrade(UPG_STICKS, 1);
             AMMO(ITEM_STICK) = sAmmoRefillCounts[item - ITEM_STICKS_5];
-        }
-        else
-        {
+        } else {
             AMMO(ITEM_STICK) += sAmmoRefillCounts[item - ITEM_STICKS_5];
-            if (AMMO(ITEM_STICK) > CUR_CAPACITY(UPG_STICKS))
+            if (AMMO(ITEM_STICK) > CUR_CAPACITY(UPG_STICKS)) {
                 AMMO(ITEM_STICK) = CUR_CAPACITY(UPG_STICKS);
+            }
         }
         item = ITEM_STICK;
-    }
-    else if (item == ITEM_NUT)
-    {
-        if (gSaveContext.items[slot] == ITEM_NONE)
-        {
+    } else if (item == ITEM_NUT) {
+        if (gSaveContext.items[slot] == ITEM_NONE) {
             Inventory_ChangeUpgrade(UPG_NUTS, 1);
             AMMO(ITEM_NUT) = ITEM_NUT;
-        }
-        else
-        {
+        } else {
             AMMO(ITEM_NUT)++;
-            if (AMMO(ITEM_NUT) > CUR_CAPACITY(UPG_NUTS))
+            if (AMMO(ITEM_NUT) > CUR_CAPACITY(UPG_NUTS)) {
                 AMMO(ITEM_NUT) = CUR_CAPACITY(UPG_NUTS);
+            }
         }
-    }
-    else if ((item == ITEM_NUTS_5) || (item == ITEM_NUTS_10))
-    {
-        if (gSaveContext.items[slot] == ITEM_NONE)
-        {
+    } else if ((item == ITEM_NUTS_5) || (item == ITEM_NUTS_10)) {
+        if (gSaveContext.items[slot] == ITEM_NONE) {
             Inventory_ChangeUpgrade(UPG_NUTS, 1);
             AMMO(ITEM_NUT) += sAmmoRefillCounts[item - ITEM_NUTS_5];
             // Translates to: "Deku Nuts %d(%d)=%d BS_count=%d"
-            osSyncPrintf("デクの実 %d(%d)=%d  BS_count=%d\n",
-                         item, ITEM_NUTS_5, item - ITEM_NUTS_5, sAmmoRefillCounts[item - ITEM_NUTS_5]);
-        }
-        else
-        {
+            osSyncPrintf("デクの実 %d(%d)=%d  BS_count=%d\n", item, ITEM_NUTS_5, item - ITEM_NUTS_5,
+                         sAmmoRefillCounts[item - ITEM_NUTS_5]);
+        } else {
             AMMO(ITEM_NUT) += sAmmoRefillCounts[item - ITEM_NUTS_5];
-            if (AMMO(ITEM_NUT) > CUR_CAPACITY(UPG_NUTS))
+            if (AMMO(ITEM_NUT) > CUR_CAPACITY(UPG_NUTS)) {
                 AMMO(ITEM_NUT) = CUR_CAPACITY(UPG_NUTS);
+            }
         }
         item = ITEM_NUT;
-    }
-    else if (item == ITEM_BOMB)
-    {
+    } else if (item == ITEM_BOMB) {
         // Translates to: "Bomb  Bomb  Bomb  Bomb Bomb   Bomb Bomb"
         osSyncPrintf(" 爆弾  爆弾  爆弾  爆弾 爆弾   爆弾 爆弾 \n");
         bombCount = AMMO(ITEM_BOMB) + 1;
         AMMO(ITEM_BOMB) = bombCount;
-        if (bombCount > CUR_CAPACITY(UPG_BOMB_BAG))
+        if (bombCount > CUR_CAPACITY(UPG_BOMB_BAG)) {
             AMMO(ITEM_BOMB) = CUR_CAPACITY(UPG_BOMB_BAG);
+        }
         return ITEM_NONE;
-    }
-    else if ((item >= ITEM_BOMBS_5) && (item <= ITEM_BOMBS_30))
-    {
+    } else if ((item >= ITEM_BOMBS_5) && (item <= ITEM_BOMBS_30)) {
         bombCount = AMMO(ITEM_BOMB) + sAmmoRefillCounts[item - ITEM_BOMBS_5];
         AMMO(ITEM_BOMB) = bombCount;
-        if (bombCount > CUR_CAPACITY(UPG_BOMB_BAG))
+        if (bombCount > CUR_CAPACITY(UPG_BOMB_BAG)) {
             AMMO(ITEM_BOMB) = CUR_CAPACITY(UPG_BOMB_BAG);
+        }
         return ITEM_NONE;
-    }
-    else if (item == ITEM_BOMBCHU)
-    {
-        if (gSaveContext.items[slot] == ITEM_NONE)
-        {
+    } else if (item == ITEM_BOMBCHU) {
+        if (gSaveContext.items[slot] == ITEM_NONE) {
             INV_CONTENT(ITEM_BOMBCHU) = ITEM_BOMBCHU;
             AMMO(ITEM_BOMBCHU) = 10;
             return ITEM_NONE;
-        }
-        else
-        {
+        } else {
             AMMO(ITEM_BOMBCHU) += 10;
-            if (AMMO(ITEM_BOMBCHU) > 50)
+            if (AMMO(ITEM_BOMBCHU) > 50) {
                 AMMO(ITEM_BOMBCHU) = 50;
+            }
             return ITEM_NONE;
         }
-    }
-    else if ((item == ITEM_BOMBCHUS_5) || (item == ITEM_BOMBCHUS_20))
-    {
-        if (gSaveContext.items[slot] == ITEM_NONE)
-        {
+    } else if ((item == ITEM_BOMBCHUS_5) || (item == ITEM_BOMBCHUS_20)) {
+        if (gSaveContext.items[slot] == ITEM_NONE) {
             INV_CONTENT(ITEM_BOMBCHU) = ITEM_BOMBCHU;
             AMMO(ITEM_BOMBCHU) += sAmmoRefillCounts[item - ITEM_BOMBCHUS_5 + 8];
             return ITEM_NONE;
-        }
-        else
-        {
+        } else {
             AMMO(ITEM_BOMBCHU) += sAmmoRefillCounts[item - ITEM_BOMBCHUS_5 + 8];
-            if (AMMO(ITEM_BOMBCHU) > 50)
+            if (AMMO(ITEM_BOMBCHU) > 50) {
                 AMMO(ITEM_BOMBCHU) = 50;
+            }
             return ITEM_NONE;
         }
-    }
-    else if ((item >= ITEM_ARROWS_SMALL) && (item <= ITEM_ARROWS_LARGE))
-    {
+    } else if ((item >= ITEM_ARROWS_SMALL) && (item <= ITEM_ARROWS_LARGE)) {
         AMMO(ITEM_BOW) += sAmmoRefillCounts[item - ITEM_ARROWS_SMALL + 4];
 
-        if ((AMMO(ITEM_BOW) >= CUR_CAPACITY(UPG_QUIVER)) || (AMMO(ITEM_BOW) < 0))
+        if ((AMMO(ITEM_BOW) >= CUR_CAPACITY(UPG_QUIVER)) || (AMMO(ITEM_BOW) < 0)) {
             AMMO(ITEM_BOW) = CUR_CAPACITY(UPG_QUIVER);
+        }
 
         osSyncPrintf("%d本  Item_MaxGet=%d\n", AMMO(ITEM_BOW), CUR_CAPACITY(UPG_QUIVER));
 
         return ITEM_BOW;
-    }
-    else if (item == ITEM_SLINGSHOT)
-    {
+    } else if (item == ITEM_SLINGSHOT) {
         Inventory_ChangeUpgrade(UPG_BULLET_BAG, 1);
         INV_CONTENT(ITEM_SLINGSHOT) = ITEM_SLINGSHOT;
         AMMO(ITEM_SLINGSHOT) = 30;
         return ITEM_NONE;
-    }
-    else if (item == ITEM_SEEDS)
-    {
+    } else if (item == ITEM_SEEDS) {
         AMMO(ITEM_SLINGSHOT) += 5;
 
-        if (AMMO(ITEM_SLINGSHOT) >= CUR_CAPACITY(UPG_BULLET_BAG))
+        if (AMMO(ITEM_SLINGSHOT) >= CUR_CAPACITY(UPG_BULLET_BAG)) {
             AMMO(ITEM_SLINGSHOT) = CUR_CAPACITY(UPG_BULLET_BAG);
+        }
 
-        if (!(gSaveContext.item_get_inf[1] & 8))
-        {
+        if (!(gSaveContext.item_get_inf[1] & 8)) {
             gSaveContext.item_get_inf[1] |= 8;
             return ITEM_NONE;
         }
 
         return ITEM_SEEDS;
-    }
-    else if (item == ITEM_SEEDS_30)
-    {
+    } else if (item == ITEM_SEEDS_30) {
         AMMO(ITEM_SLINGSHOT) += 30;
 
-        if (AMMO(ITEM_SLINGSHOT) >= CUR_CAPACITY(UPG_BULLET_BAG))
+        if (AMMO(ITEM_SLINGSHOT) >= CUR_CAPACITY(UPG_BULLET_BAG)) {
             AMMO(ITEM_SLINGSHOT) = CUR_CAPACITY(UPG_BULLET_BAG);
+        }
 
-        if (!(gSaveContext.item_get_inf[1] & 8))
-        {
+        if (!(gSaveContext.item_get_inf[1] & 8)) {
             gSaveContext.item_get_inf[1] |= 8;
             return ITEM_NONE;
         }
 
         return ITEM_SEEDS;
-    }
-    else if (item == ITEM_OCARINA_FAIRY)
-    {
+    } else if (item == ITEM_OCARINA_FAIRY) {
         INV_CONTENT(ITEM_OCARINA_FAIRY) = ITEM_OCARINA_FAIRY;
         return ITEM_NONE;
-    }
-    else if (item == ITEM_OCARINA_TIME)
-    {
+    } else if (item == ITEM_OCARINA_TIME) {
         INV_CONTENT(ITEM_OCARINA_TIME) = ITEM_OCARINA_TIME;
-        for (i = 1; i < 4; i++)
-        {
-            if (gSaveContext.equips.button_items[i] == ITEM_OCARINA_FAIRY)
-            {
+        for (i = 1; i < 4; i++) {
+            if (gSaveContext.equips.button_items[i] == ITEM_OCARINA_FAIRY) {
                 gSaveContext.equips.button_items[i] = ITEM_OCARINA_TIME;
                 Interface_LoadItemIcon1(globalCtx, i);
             }
         }
         return ITEM_NONE;
-    }
-    else if (item == ITEM_BEAN)
-    {
-        if (gSaveContext.items[slot] == ITEM_NONE)
-        {
+    } else if (item == ITEM_BEAN) {
+        if (gSaveContext.items[slot] == ITEM_NONE) {
             INV_CONTENT(item) = item;
             AMMO(ITEM_BEAN) = 1;
             BEANS_BOUGHT = 1;
-        }
-        else
-        {
+        } else {
             AMMO(ITEM_BEAN)++;
             BEANS_BOUGHT++;
         }
         return ITEM_NONE;
-    }
-    else if ((item == ITEM_HEART_PIECE_2) || (item == ITEM_HEART_PIECE))
-    {
+    } else if ((item == ITEM_HEART_PIECE_2) || (item == ITEM_HEART_PIECE)) {
         gSaveContext.quest_items += 0x10000000;
         return ITEM_NONE;
-    }
-    else if (item == ITEM_HEART_CONTAINER)
-    {
+    } else if (item == ITEM_HEART_CONTAINER) {
         gSaveContext.health_capacity += 0x10;
         gSaveContext.health += 0x10;
         return ITEM_NONE;
-    }
-    else if (item == ITEM_HEART)
-    {
+    } else if (item == ITEM_HEART) {
         // Translates to: "Recovery Heart"
         osSyncPrintf("回復ハート回復ハート回復ハート\n");
         Health_ChangeBy(globalCtx, 0x10);
         return item;
-    }
-    else if (item == ITEM_MAGIC_SMALL)
-    {
-        if (gSaveContext.unk_13F0 != 10)
+    } else if (item == ITEM_MAGIC_SMALL) {
+        if (gSaveContext.unk_13F0 != 10) {
             func_80087680(globalCtx);
+        }
 
         func_80087708(globalCtx, 12, 5);
 
-        if (!(gSaveContext.inf_table[25] & 0x100))
-        {
+        if (!(gSaveContext.inf_table[25] & 0x100)) {
             gSaveContext.inf_table[25] |= 0x100;
             return ITEM_NONE;
         }
 
         return item;
-    }
-    else if (item == ITEM_MAGIC_LARGE)
-    {
-        if (gSaveContext.unk_13F0 != 10)
+    } else if (item == ITEM_MAGIC_LARGE) {
+        if (gSaveContext.unk_13F0 != 10) {
             func_80087680(globalCtx);
+        }
 
         func_80087708(globalCtx, 24, 5);
 
-        if (!(gSaveContext.inf_table[25] & 0x100))
-        {
+        if (!(gSaveContext.inf_table[25] & 0x100)) {
             gSaveContext.inf_table[25] |= 0x100;
             return ITEM_NONE;
         }
 
         return item;
-    }
-    else if ((item >= ITEM_RUPEE_GREEN) && (item <= ITEM_INVALID_8))
-    {
+    } else if ((item >= ITEM_RUPEE_GREEN) && (item <= ITEM_INVALID_8)) {
         Rupees_ChangeBy(sAmmoRefillCounts[item - ITEM_RUPEE_GREEN + 10]);
         return ITEM_NONE;
-    }
-    else if (item == ITEM_BOTTLE)
-    {
-        for (i = 0; i < 4; i++)
-        {
-            if (gSaveContext.items[SLOT(item) + i] == ITEM_NONE)
-            {
+    } else if (item == ITEM_BOTTLE) {
+        for (i = 0; i < 4; i++) {
+            if (gSaveContext.items[SLOT(item) + i] == ITEM_NONE) {
                 gSaveContext.items[SLOT(item) + i] = item;
                 return ITEM_NONE;
             }
         }
-    }
-    else if (((item >= ITEM_POTION_RED) && (item <= ITEM_POE)) || (item == ITEM_MILK))
-    {
+    } else if (((item >= ITEM_POTION_RED) && (item <= ITEM_POE)) || (item == ITEM_MILK)) {
         bottleSlot = SLOT(item);
 
-        if ((item != ITEM_MILK_BOTTLE) && (item != ITEM_LETTER_RUTO))
-        {
-            if (item == ITEM_MILK)
-            {
+        if ((item != ITEM_MILK_BOTTLE) && (item != ITEM_LETTER_RUTO)) {
+            if (item == ITEM_MILK) {
                 item = ITEM_MILK_BOTTLE;
                 bottleSlot = SLOT(item);
             }
 
-            for (i = 0; i < 4; i++)
-            {
-                if (gSaveContext.items[bottleSlot + i] == ITEM_BOTTLE)
-                {
+            for (i = 0; i < 4; i++) {
+                if (gSaveContext.items[bottleSlot + i] == ITEM_BOTTLE) {
                     // Translates to: "Item_Pt(1)=%d Item_Pt(2)=%d Item_Pt(3)=%d   Empty Bottle=%d   Content=%d"
                     osSyncPrintf("Item_Pt(1)=%d Item_Pt(2)=%d Item_Pt(3)=%d   空瓶=%d   中味=%d\n",
-                                gSaveContext.equips.c_button_slots[0],
-                                gSaveContext.equips.c_button_slots[1],
-                                gSaveContext.equips.c_button_slots[2],
-                                bottleSlot + i, item);
+                                 gSaveContext.equips.c_button_slots[0], gSaveContext.equips.c_button_slots[1],
+                                 gSaveContext.equips.c_button_slots[2], bottleSlot + i, item);
 
-                    if ((bottleSlot + i) == gSaveContext.equips.c_button_slots[0])
-                    {
+                    if ((bottleSlot + i) == gSaveContext.equips.c_button_slots[0]) {
                         gSaveContext.equips.button_items[1] = item;
                         Interface_LoadItemIcon2(globalCtx, 1);
                         gSaveContext.button_status[1] = BTN_ENABLED;
-                    }
-                    else if ((bottleSlot + i) == gSaveContext.equips.c_button_slots[1])
-                    {
+                    } else if ((bottleSlot + i) == gSaveContext.equips.c_button_slots[1]) {
                         gSaveContext.equips.button_items[2] = item;
                         Interface_LoadItemIcon2(globalCtx, 2);
                         gSaveContext.button_status[2] = BTN_ENABLED;
-                    }
-                    else if ((bottleSlot + i) == gSaveContext.equips.c_button_slots[2])
-                    {
+                    } else if ((bottleSlot + i) == gSaveContext.equips.c_button_slots[2]) {
                         gSaveContext.equips.button_items[3] = item;
                         Interface_LoadItemIcon1(globalCtx, 3);
                         gSaveContext.button_status[3] = BTN_ENABLED;
@@ -1986,40 +1759,29 @@ u8 Item_Give(GlobalContext* globalCtx, u8 item)
                     return ITEM_NONE;
                 }
             }
-        }
-        else
-        {
-            for (i = 0; i < 4; i++)
-            {
-                if (gSaveContext.items[bottleSlot + i] == ITEM_NONE)
-                {
+        } else {
+            for (i = 0; i < 4; i++) {
+                if (gSaveContext.items[bottleSlot + i] == ITEM_NONE) {
                     gSaveContext.items[bottleSlot + i] = item;
                     return ITEM_NONE;
                 }
             }
         }
-    }
-    else if ((item >= ITEM_WEIRD_EGG) && (item <= ITEM_CLAIM_CHECK))
-    {
-        if (item == ITEM_SAW)
+    } else if ((item >= ITEM_WEIRD_EGG) && (item <= ITEM_CLAIM_CHECK)) {
+        if (item == ITEM_SAW) {
             gSaveContext.item_get_inf[1] |= 0x8000;
+        }
 
         prevTradeItem = INV_CONTENT(item);
         INV_CONTENT(item) = item;
 
-        if (prevTradeItem != ITEM_NONE)
-        {
-            for (i = 1; i < 4; i++)
-            {
-                if (prevTradeItem == gSaveContext.equips.button_items[i])
-                {
-                    if (item != ITEM_SOLD_OUT)
-                    {
+        if (prevTradeItem != ITEM_NONE) {
+            for (i = 1; i < 4; i++) {
+                if (prevTradeItem == gSaveContext.equips.button_items[i]) {
+                    if (item != ITEM_SOLD_OUT) {
                         gSaveContext.equips.button_items[i] = item;
                         Interface_LoadItemIcon1(globalCtx, i);
-                    }
-                    else
-                    {
+                    } else {
                         gSaveContext.equips.button_items[i] = ITEM_NONE;
                     }
                     return ITEM_NONE;
@@ -2040,222 +1802,166 @@ u8 Item_Give(GlobalContext* globalCtx, u8 item)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_parameter/Item_Give.s")
 #endif
 
-u8 Item_CheckObtainability(u8 item)
-{
+u8 Item_CheckObtainability(u8 item) {
     s16 i;
     s16 slot;
     s32 bottleSlot;
 
     slot = SLOT(item);
-    if (item >= ITEM_STICKS_5)
+    if (item >= ITEM_STICKS_5) {
         slot = SLOT(sExtraItemBases[item - ITEM_STICKS_5]);
+    }
 
     osSyncPrintf(VT_FGCOL(GREEN));
     osSyncPrintf("item_get_non_setting=%d  pt=%d  z=%x\n", item, slot, gSaveContext.items[slot]);
     osSyncPrintf(VT_RST);
 
-    if ((item >= ITEM_MEDALLION_FOREST) && (item <= ITEM_MEDALLION_LIGHT))
-    {
+    if ((item >= ITEM_MEDALLION_FOREST) && (item <= ITEM_MEDALLION_LIGHT)) {
         return ITEM_NONE;
-    }
-    else if ((item >= ITEM_KOKIRI_EMERALD) && (item <= ITEM_SKULL_TOKEN))
-    {
+    } else if ((item >= ITEM_KOKIRI_EMERALD) && (item <= ITEM_SKULL_TOKEN)) {
         return ITEM_NONE;
-    }
-    else if ((item >= ITEM_SWORD_KOKIRI) && (item <= ITEM_SWORD_BGS))
-    {
-        if (item == ITEM_SWORD_BGS)
+    } else if ((item >= ITEM_SWORD_KOKIRI) && (item <= ITEM_SWORD_BGS)) {
+        if (item == ITEM_SWORD_BGS) {
             return ITEM_NONE;
-        else if ((gBitFlags[item - ITEM_SWORD_KOKIRI] << gEquipShifts[EQUIP_SWORD]) & gSaveContext.equipment)
+        } else if ((gBitFlags[item - ITEM_SWORD_KOKIRI] << gEquipShifts[EQUIP_SWORD]) & gSaveContext.equipment) {
             return item;
-        else
+        } else {
             return ITEM_NONE;
-    }
-    else if ((item >= ITEM_SHIELD_DEKU) && (item <= ITEM_SHIELD_MIRROR))
-    {
-        if ((gBitFlags[item - ITEM_SHIELD_DEKU] << gEquipShifts[EQUIP_SHIELD]) & gSaveContext.equipment)
+        }
+    } else if ((item >= ITEM_SHIELD_DEKU) && (item <= ITEM_SHIELD_MIRROR)) {
+        if ((gBitFlags[item - ITEM_SHIELD_DEKU] << gEquipShifts[EQUIP_SHIELD]) & gSaveContext.equipment) {
             return item;
-        else
+        } else {
             return ITEM_NONE;
-    }
-    else if ((item >= ITEM_TUNIC_KOKIRI) && (item <= ITEM_TUNIC_ZORA))
-    {
-        if ((gBitFlags[item - ITEM_TUNIC_KOKIRI] << gEquipShifts[EQUIP_TUNIC]) & gSaveContext.equipment)
+        }
+    } else if ((item >= ITEM_TUNIC_KOKIRI) && (item <= ITEM_TUNIC_ZORA)) {
+        if ((gBitFlags[item - ITEM_TUNIC_KOKIRI] << gEquipShifts[EQUIP_TUNIC]) & gSaveContext.equipment) {
             return item;
-        else
+        } else {
             return ITEM_NONE;
-    }
-    else if ((item >= ITEM_BOOTS_KOKIRI) && (item <= ITEM_BOOTS_HOVER))
-    {
-        if ((gBitFlags[item - ITEM_BOOTS_KOKIRI] << gEquipShifts[EQUIP_BOOTS]) & gSaveContext.equipment)
+        }
+    } else if ((item >= ITEM_BOOTS_KOKIRI) && (item <= ITEM_BOOTS_HOVER)) {
+        if ((gBitFlags[item - ITEM_BOOTS_KOKIRI] << gEquipShifts[EQUIP_BOOTS]) & gSaveContext.equipment) {
             return item;
-        else
+        } else {
             return ITEM_NONE;
-    }
-    else if ((item == ITEM_KEY_BOSS) || (item == ITEM_COMPASS) || (item == ITEM_DUNGEON_MAP))
-    {
+        }
+    } else if ((item == ITEM_KEY_BOSS) || (item == ITEM_COMPASS) || (item == ITEM_DUNGEON_MAP)) {
         return ITEM_NONE;
-    }
-    else if (item == ITEM_KEY_SMALL)
-    {
+    } else if (item == ITEM_KEY_SMALL) {
         return ITEM_NONE;
-    }
-    else if ((item >= ITEM_SLINGSHOT) && (item <= ITEM_BOMBCHU))
-    {
+    } else if ((item >= ITEM_SLINGSHOT) && (item <= ITEM_BOMBCHU)) {
         return ITEM_NONE;
-    }
-    else if ((item == ITEM_BOMBCHUS_5) || (item == ITEM_BOMBCHUS_20))
-    {
+    } else if ((item == ITEM_BOMBCHUS_5) || (item == ITEM_BOMBCHUS_20)) {
         return ITEM_NONE;
-    }
-    else if ((item == ITEM_QUIVER_30) || (item == ITEM_BOW))
-    {
-        if (CUR_UPG_VALUE(UPG_QUIVER) == 0)
+    } else if ((item == ITEM_QUIVER_30) || (item == ITEM_BOW)) {
+        if (CUR_UPG_VALUE(UPG_QUIVER) == 0) {
             return ITEM_NONE;
-        else
+        } else {
             return 0;
-    }
-    else if ((item == ITEM_QUIVER_40) || (item == ITEM_QUIVER_50))
-    {
+        }
+    } else if ((item == ITEM_QUIVER_40) || (item == ITEM_QUIVER_50)) {
         return ITEM_NONE;
-    }
-    else if ((item == ITEM_BULLET_BAG_40) || (item == ITEM_BULLET_BAG_50))
-    {
+    } else if ((item == ITEM_BULLET_BAG_40) || (item == ITEM_BULLET_BAG_50)) {
         return ITEM_NONE;
-    }
-    else if ((item == ITEM_BOMB_BAG_20) || (item == ITEM_BOMB))
-    {
-        if (CUR_UPG_VALUE(UPG_BOMB_BAG) == 0)
+    } else if ((item == ITEM_BOMB_BAG_20) || (item == ITEM_BOMB)) {
+        if (CUR_UPG_VALUE(UPG_BOMB_BAG) == 0) {
             return ITEM_NONE;
-        else
+        } else {
             return 0;
-    }
-    else if ((item >= ITEM_STICK_UPGRADE_20) && (item <= ITEM_NUT_UPGRADE_40))
-    {
+        }
+    } else if ((item >= ITEM_STICK_UPGRADE_20) && (item <= ITEM_NUT_UPGRADE_40)) {
         return ITEM_NONE;
-    }
-    else if ((item >= ITEM_BOMB_BAG_30) && (item <= ITEM_WALLET_GIANT))
-    {
+    } else if ((item >= ITEM_BOMB_BAG_30) && (item <= ITEM_WALLET_GIANT)) {
         return ITEM_NONE;
-    }
-    else if (item == ITEM_LONGSHOT)
-    {
+    } else if (item == ITEM_LONGSHOT) {
         return ITEM_NONE;
-    }
-    else if ((item == ITEM_SEEDS) || (item == ITEM_SEEDS_30))
-    {
-        if (!(gSaveContext.item_get_inf[1] & 0x8))
+    } else if ((item == ITEM_SEEDS) || (item == ITEM_SEEDS_30)) {
+        if (!(gSaveContext.item_get_inf[1] & 0x8)) {
             return ITEM_NONE;
-        else
+        } else {
             return ITEM_SEEDS;
-    }
-    else if (item == ITEM_BEAN)
-    {
+        }
+    } else if (item == ITEM_BEAN) {
         return ITEM_NONE;
-    }
-    else if ((item == ITEM_HEART_PIECE_2) || (item == ITEM_HEART_PIECE))
-    {
+    } else if ((item == ITEM_HEART_PIECE_2) || (item == ITEM_HEART_PIECE)) {
         return ITEM_NONE;
-    }
-    else if (item == ITEM_HEART_CONTAINER)
-    {
+    } else if (item == ITEM_HEART_CONTAINER) {
         return ITEM_NONE;
-    }
-    else if (item == ITEM_HEART)
-    {
+    } else if (item == ITEM_HEART) {
         return ITEM_HEART;
-    }
-    else if ((item == ITEM_MAGIC_SMALL) || (item == ITEM_MAGIC_LARGE))
-    {
+    } else if ((item == ITEM_MAGIC_SMALL) || (item == ITEM_MAGIC_LARGE)) {
         // Translates to: "Magic Pot Get_Inf_Table( 25, 0x0100)=%d"
         osSyncPrintf("魔法の壷 Get_Inf_Table( 25, 0x0100)=%d\n", gSaveContext.inf_table[25] & 0x100);
-        if (!(gSaveContext.inf_table[25] & 0x100))
+        if (!(gSaveContext.inf_table[25] & 0x100)) {
             return ITEM_NONE;
-        else
+        } else {
             return item;
-    }
-    else if ((item >= ITEM_RUPEE_GREEN) && (item <= ITEM_INVALID_8))
-    {
+        }
+    } else if ((item >= ITEM_RUPEE_GREEN) && (item <= ITEM_INVALID_8)) {
         return ITEM_NONE;
-    }
-    else if (item == ITEM_BOTTLE)
-    {
+    } else if (item == ITEM_BOTTLE) {
         return ITEM_NONE;
-    }
-    else if (((item >= ITEM_POTION_RED) && (item <= ITEM_POE)) || (item == ITEM_MILK))
-    {
+    } else if (((item >= ITEM_POTION_RED) && (item <= ITEM_POE)) || (item == ITEM_MILK)) {
         bottleSlot = SLOT(item);
 
-        if ((item != ITEM_MILK_BOTTLE) && (item != ITEM_LETTER_RUTO))
-        {
-            if (item == ITEM_MILK)
-            {
+        if ((item != ITEM_MILK_BOTTLE) && (item != ITEM_LETTER_RUTO)) {
+            if (item == ITEM_MILK) {
                 item = ITEM_MILK_BOTTLE;
                 bottleSlot = SLOT(item);
             }
 
-            for (i = 0; i < 4; i++)
-            {
-                if (gSaveContext.items[bottleSlot + i] == ITEM_BOTTLE)
+            for (i = 0; i < 4; i++) {
+                if (gSaveContext.items[bottleSlot + i] == ITEM_BOTTLE) {
                     return ITEM_NONE;
+                }
             }
-        }
-        else
-        {
-            for (i = 0; i < 4; i++)
-            {
-                if (gSaveContext.items[bottleSlot + i] == ITEM_NONE)
+        } else {
+            for (i = 0; i < 4; i++) {
+                if (gSaveContext.items[bottleSlot + i] == ITEM_NONE) {
                     return ITEM_NONE;
+                }
             }
         }
-    }
-    else if ((item >= ITEM_WEIRD_EGG) && (item <= ITEM_CLAIM_CHECK))
-    {
+    } else if ((item >= ITEM_WEIRD_EGG) && (item <= ITEM_CLAIM_CHECK)) {
         return ITEM_NONE;
     }
 
     return gSaveContext.items[slot];
 }
 
-void Inventory_DeleteItem(u16 item, u16 invSlot)
-{
+void Inventory_DeleteItem(u16 item, u16 invSlot) {
     s16 i;
 
-    if (item == ITEM_BEAN)
+    if (item == ITEM_BEAN) {
         BEANS_BOUGHT = 0; // Beans bought
+    }
 
     gSaveContext.items[invSlot] = ITEM_NONE;
 
     osSyncPrintf("\nItem_Register(%d)\n", invSlot, gSaveContext.items[invSlot]);
 
-    for (i = 1; i < 4; i++)
-    {
-        if (gSaveContext.equips.button_items[i] == item)
-        {
+    for (i = 1; i < 4; i++) {
+        if (gSaveContext.equips.button_items[i] == item) {
             gSaveContext.equips.button_items[i] = ITEM_NONE;
-            gSaveContext.equips.c_button_slots[i-1] = SLOT_NONE;
+            gSaveContext.equips.c_button_slots[i - 1] = SLOT_NONE;
         }
     }
 }
 
 #ifdef NON_MATCHING
 // regalloc differences
-s32 Inventory_ReplaceItem(GlobalContext* globalCtx, u16 oldItem, u16 newItem)
-{
+s32 Inventory_ReplaceItem(GlobalContext* globalCtx, u16 oldItem, u16 newItem) {
     s16 i;
     s16 j;
 
-    for (i = 0; i < ARRAY_COUNT(gSaveContext.items); i++)
-    {
-        if (gSaveContext.items[i] == oldItem)
-        {
+    for (i = 0; i < ARRAY_COUNT(gSaveContext.items); i++) {
+        if (gSaveContext.items[i] == oldItem) {
             gSaveContext.items[i] = newItem;
             // Translates to: "Item Purge (%d)"
             osSyncPrintf("アイテム消去(%d)", i);
-            for (j = 1; j < 4; j++)
-            {
-                if (gSaveContext.equips.button_items[j] == oldItem)
-                {
+            for (j = 1; j < 4; j++) {
+                if (gSaveContext.equips.button_items[j] == oldItem) {
                     gSaveContext.equips.button_items[j] = newItem;
                     Interface_LoadItemIcon1(globalCtx, j);
                     break;
@@ -2271,54 +1977,55 @@ s32 Inventory_ReplaceItem(GlobalContext* globalCtx, u16 oldItem, u16 newItem)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_parameter/Inventory_ReplaceItem.s")
 #endif
 
-s32 Inventory_HasEmptyBottle(void)
-{
+s32 Inventory_HasEmptyBottle(void) {
     u8* items = gSaveContext.items;
 
-    if (items[SLOT_BOTTLE_1] == ITEM_BOTTLE)
+    if (items[SLOT_BOTTLE_1] == ITEM_BOTTLE) {
         return 1;
-    else if (items[SLOT_BOTTLE_2] == ITEM_BOTTLE)
+    } else if (items[SLOT_BOTTLE_2] == ITEM_BOTTLE) {
         return 1;
-    else if (items[SLOT_BOTTLE_3] == ITEM_BOTTLE)
+    } else if (items[SLOT_BOTTLE_3] == ITEM_BOTTLE) {
         return 1;
-    else if (items[SLOT_BOTTLE_4] == ITEM_BOTTLE)
+    } else if (items[SLOT_BOTTLE_4] == ITEM_BOTTLE) {
         return 1;
-    else
+    } else {
         return 0;
+    }
 }
 
-s32 Inventory_HasSpecificBottle(u8 bottleItem)
-{
+s32 Inventory_HasSpecificBottle(u8 bottleItem) {
     u8* items = gSaveContext.items;
 
-    if (items[SLOT_BOTTLE_1] == bottleItem)
+    if (items[SLOT_BOTTLE_1] == bottleItem) {
         return 1;
-    else if (items[SLOT_BOTTLE_2] == bottleItem)
+    } else if (items[SLOT_BOTTLE_2] == bottleItem) {
         return 1;
-    else if (items[SLOT_BOTTLE_3] == bottleItem)
+    } else if (items[SLOT_BOTTLE_3] == bottleItem) {
         return 1;
-    else if (items[SLOT_BOTTLE_4] == bottleItem)
+    } else if (items[SLOT_BOTTLE_4] == bottleItem) {
         return 1;
-    else
+    } else {
         return 0;
+    }
 }
 
 #ifdef NON_MATCHING
 // save context pointer isn't reused after Interface_LoadItemIcon1 when it should be
-void Inventory_UpdateBottleItem(GlobalContext* globalCtx, u8 item, u8 cButton)
-{
-    osSyncPrintf("item_no=%x,  c_no=%x,  Pt=%x  Item_Register=%x\n",
-                 item, cButton, gSaveContext.equips.c_button_slots[cButton-1],
-                 gSaveContext.items[gSaveContext.equips.c_button_slots[cButton-1]]);
+void Inventory_UpdateBottleItem(GlobalContext* globalCtx, u8 item, u8 cButton) {
+    osSyncPrintf("item_no=%x,  c_no=%x,  Pt=%x  Item_Register=%x\n", item, cButton,
+                 gSaveContext.equips.c_button_slots[cButton - 1],
+                 gSaveContext.items[gSaveContext.equips.c_button_slots[cButton - 1]]);
 
     // Special case to only empty half of a Lon Lon Milk Bottle
-    if ((gSaveContext.items[gSaveContext.equips.c_button_slots[cButton-1]] == ITEM_MILK_BOTTLE) && (item == ITEM_BOTTLE))
+    if ((gSaveContext.items[gSaveContext.equips.c_button_slots[cButton - 1]] == ITEM_MILK_BOTTLE) &&
+        (item == ITEM_BOTTLE)) {
         item = ITEM_MILK_HALF;
+    }
 
-    gSaveContext.items[gSaveContext.equips.c_button_slots[cButton-1]] = item;
+    gSaveContext.items[gSaveContext.equips.c_button_slots[cButton - 1]] = item;
     gSaveContext.equips.button_items[cButton] = item;
 
-    if (1) ; // Improves codegen but may not be necessary
+    if (1) {} // Improves codegen but may not be necessary
 
     Interface_LoadItemIcon1(globalCtx, cButton);
 
@@ -2331,25 +2038,20 @@ void Inventory_UpdateBottleItem(GlobalContext* globalCtx, u8 item, u8 cButton)
 
 #ifdef NON_MATCHING
 // mostly regalloc, minor ordering, and stack usage differences
-s32 Inventory_ConsumeFairy(GlobalContext* globalCtx)
-{
+s32 Inventory_ConsumeFairy(GlobalContext* globalCtx) {
     s32 bottleSlot;
     s16 i;
     s16 j;
 
     bottleSlot = SLOT(ITEM_FAIRY);
 
-    for (i = 0; i < 4; i++)
-    {
-        if (gSaveContext.items[bottleSlot + i] == ITEM_FAIRY)
-        {
-            for (j = 1; j < 4; j++)
-            {
-                if (gSaveContext.equips.button_items[j] == ITEM_FAIRY)
-                {
+    for (i = 0; i < 4; i++) {
+        if (gSaveContext.items[bottleSlot + i] == ITEM_FAIRY) {
+            for (j = 1; j < 4; j++) {
+                if (gSaveContext.equips.button_items[j] == ITEM_FAIRY) {
                     gSaveContext.equips.button_items[j] = ITEM_BOTTLE;
                     Interface_LoadItemIcon1(globalCtx, j);
-                    bottleSlot = gSaveContext.equips.c_button_slots[j-1];
+                    bottleSlot = gSaveContext.equips.c_button_slots[j - 1];
                     break;
                 }
             }
@@ -2366,12 +2068,10 @@ s32 Inventory_ConsumeFairy(GlobalContext* globalCtx)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_parameter/Inventory_ConsumeFairy.s")
 #endif
 
-void func_80086D5C(s32* buf, u16 size)
-{
+void func_80086D5C(s32* buf, u16 size) {
     u16 i;
 
-    for (i = 0; i < size; i++)
-    {
+    for (i = 0; i < size; i++) {
         buf[i] = 0;
     }
 }
@@ -2380,27 +2080,26 @@ u32 sDoActionTextures[] = { 0x07000000, 0x07000180 };
 
 #ifdef NON_MATCHING
 // 0x80000000 is reused in the 2 *_TO_VIRTUAL macros when it shouldn't
-void Interface_LoadActionLabel(InterfaceContext* interfaceCtx, u16 action, s16 arg2)
-{
-    if (action >= 0x1D)
+void Interface_LoadActionLabel(InterfaceContext* interfaceCtx, u16 action, s16 arg2) {
+    if (action >= 0x1D) {
         action = 0x0A;
+    }
 
-    if (gSaveContext.language != 0)
+    if (gSaveContext.language != 0) {
         action += 0x1D;
+    }
 
-    if (gSaveContext.language == 2)
+    if (gSaveContext.language == 2) {
         action += 0x1D;
+    }
 
-    if ((action != 0x0A) && (action != 0x27) && (action != 0x44))
-    {
+    if ((action != 0x0A) && (action != 0x27) && (action != 0x44)) {
         osCreateMesgQueue(&interfaceCtx->loadQueue, &interfaceCtx->loadMsg, OS_MESG_BLOCK);
         DmaMgr_SendRequest2(&interfaceCtx->dmaRequest_160, (u32)interfaceCtx->do_actionSegment + (arg2 * 0x180),
-                            (u32)_do_action_staticSegmentRomStart + (action * 0x180),
-                            0x180, 0, &interfaceCtx->loadQueue, NULL, "../z_parameter.c", 2145);
+                            (u32)_do_action_staticSegmentRomStart + (action * 0x180), 0x180, 0,
+                            &interfaceCtx->loadQueue, NULL, "../z_parameter.c", 2145);
         osRecvMesg(&interfaceCtx->loadQueue, NULL, OS_MESG_BLOCK);
-    }
-    else
-    {
+    } else {
         gSegments[7] = PHYSICAL_TO_VIRTUAL(interfaceCtx->do_actionSegment);
         func_80086D5C(SEGMENTED_TO_VIRTUAL(sDoActionTextures[arg2]), 0x180 / 4);
     }
@@ -2410,186 +2109,176 @@ void Interface_LoadActionLabel(InterfaceContext* interfaceCtx, u16 action, s16 a
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_parameter/Interface_LoadActionLabel.s")
 #endif
 
-void Interface_SetDoAction(GlobalContext* globalCtx, u16 action)
-{
+void Interface_SetDoAction(GlobalContext* globalCtx, u16 action) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
     PauseContext* pauseCtx = &globalCtx->pauseCtx;
 
-    if (interfaceCtx->unk_1F0 != action)
-    {
+    if (interfaceCtx->unk_1F0 != action) {
         interfaceCtx->unk_1F0 = action;
         interfaceCtx->unk_1EC = 1;
         interfaceCtx->unk_1F4 = 0.0f;
         Interface_LoadActionLabel(interfaceCtx, action, 1);
-        if (pauseCtx->state != 0)
+        if (pauseCtx->state != 0) {
             interfaceCtx->unk_1EC = 3;
+        }
     }
 }
 
-void Interface_SetNaviCall(GlobalContext* globalCtx, u16 naviCallState)
-{
+void Interface_SetNaviCall(GlobalContext* globalCtx, u16 naviCallState) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
 
-    if (((naviCallState == 0x1D) || (naviCallState == 0x1E)) &&
-        !interfaceCtx->naviCalling &&
-        (globalCtx->csCtx.state == 0))
-    {
-        // Whitespace matters for codegen here
-        if (naviCallState == 0x1E) Audio_PlaySoundGeneral(NA_SE_VO_NAVY_CALL, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
-        if (naviCallState == 0x1D) func_800F4524(&D_801333D4, NA_SE_VO_NA_HELLO_2, 32);
+    if (((naviCallState == 0x1D) || (naviCallState == 0x1E)) && !interfaceCtx->naviCalling &&
+        (globalCtx->csCtx.state == 0)) {
+        // clang-format off
+        // NOLINTNEXTLINE
+        if (naviCallState == 0x1E) Audio_PlaySoundGeneral(NA_SE_VO_NAVY_CALL, &D_801333D4, 4,
+                                                          &D_801333E0, &D_801333E0, &D_801333E8);
+        // clang-format on
+
+        if (naviCallState == 0x1D) {
+            func_800F4524(&D_801333D4, NA_SE_VO_NA_HELLO_2, 32);
+        }
 
         interfaceCtx->naviCalling = 1;
         sCUpInvisible = 0;
         sCUpTimer = 10;
-    }
-    else if ((naviCallState == 0x1F) &&
-             interfaceCtx->naviCalling)
-    {
+    } else if ((naviCallState == 0x1F) && interfaceCtx->naviCalling) {
         interfaceCtx->naviCalling = 0;
     }
 }
 
-void Interface_LoadActionLabelB(GlobalContext* globalCtx, u16 action)
-{
+void Interface_LoadActionLabelB(GlobalContext* globalCtx, u16 action) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
 
-    if (gSaveContext.language != 0)
+    if (gSaveContext.language != 0) {
         action += 0x1D;
+    }
 
-    if (gSaveContext.language == 2)
+    if (gSaveContext.language == 2) {
         action += 0x1D;
+    }
 
     interfaceCtx->unk_1FC = action;
 
     osCreateMesgQueue(&interfaceCtx->loadQueue, &interfaceCtx->loadMsg, OS_MESG_BLOCK);
     DmaMgr_SendRequest2(&interfaceCtx->dmaRequest_160, (u32)interfaceCtx->do_actionSegment + 0x180,
-                        (u32)_do_action_staticSegmentRomStart + (action * 0x180),
-                        0x180, 0, &interfaceCtx->loadQueue, NULL, "../z_parameter.c", 2228);
+                        (u32)_do_action_staticSegmentRomStart + (action * 0x180), 0x180, 0, &interfaceCtx->loadQueue,
+                        NULL, "../z_parameter.c", 2228);
     osRecvMesg(&interfaceCtx->loadQueue, NULL, OS_MESG_BLOCK);
 
     interfaceCtx->unk_1FA = 1;
 }
 
-s32 Health_ChangeBy(GlobalContext* globalCtx, s16 healthChange)
-{
+s32 Health_ChangeBy(GlobalContext* globalCtx, s16 healthChange) {
     u16 heartCount;
     u16 healthLevel;
 
     // Translates to: "＊＊＊＊＊ Fluctuation=%d (now=%d, max=%d) ＊＊＊"
-    osSyncPrintf("＊＊＊＊＊  増減=%d (now=%d, max=%d)  ＊＊＊", healthChange, gSaveContext.health, gSaveContext.health_capacity);
-
-    // Whitespace matters for codegen here
-    if (healthChange > 0) Audio_PlaySoundGeneral(NA_SE_SY_HP_RECOVER, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
-    else if ((gSaveContext.double_defense != 0) && (healthChange < 0))
-    {
+    osSyncPrintf("＊＊＊＊＊  増減=%d (now=%d, max=%d)  ＊＊＊", healthChange, gSaveContext.health,
+                 gSaveContext.health_capacity);
+
+    // clang-format off
+    // NOLINTNEXTLINE
+    if (healthChange > 0) Audio_PlaySoundGeneral(NA_SE_SY_HP_RECOVER, &D_801333D4, 4,
+                                                 &D_801333E0, &D_801333E0, &D_801333E8);
+    else if ((gSaveContext.double_defense != 0) && (healthChange < 0)) {
         healthChange >>= 1;
         // Translates to: "Heart decrease halved!!＝%d"
         osSyncPrintf("ハート減少半分！！＝%d\n", healthChange);
     }
+    // clang-format on
 
     gSaveContext.health += healthChange;
 
-    if (gSaveContext.health > gSaveContext.health_capacity)
+    if (gSaveContext.health > gSaveContext.health_capacity) {
         gSaveContext.health = gSaveContext.health_capacity;
+    }
 
     heartCount = gSaveContext.health % 0x10;
 
     healthLevel = heartCount;
-    if (heartCount != 0)
-    {
-        if (heartCount > 10)
+    if (heartCount != 0) {
+        if (heartCount > 10) {
             healthLevel = 3;
-        else if (heartCount > 5)
+        } else if (heartCount > 5) {
             healthLevel = 2;
-        else
+        } else {
             healthLevel = 1;
+        }
     }
 
     // Translates to: "Life=%d ＊＊＊  %d ＊＊＊＊＊＊"
     osSyncPrintf("  ライフ=%d  ＊＊＊  %d  ＊＊＊＊＊＊\n", gSaveContext.health, healthLevel);
 
-    if (gSaveContext.health <= 0)
-    {
+    if (gSaveContext.health <= 0) {
         gSaveContext.health = 0;
         return 0;
-    }
-    else
-    {
+    } else {
         return 1;
     }
 }
 
-void Health_GiveHearts(s16 hearts)
-{
+void Health_GiveHearts(s16 hearts) {
     gSaveContext.health_capacity += hearts * 0x10;
 }
 
-void Rupees_ChangeBy(s16 rupeeChange)
-{
+void Rupees_ChangeBy(s16 rupeeChange) {
     gSaveContext.rupee_accumulator += rupeeChange;
 }
 
-void Inventory_ChangeAmmo(s16 item, s16 ammoChange)
-{
+void Inventory_ChangeAmmo(s16 item, s16 ammoChange) {
     // Translates to: "Item = (%d)    Amount = (%d + %d)"
     osSyncPrintf("アイテム = (%d)    数 = (%d + %d)  ", item, AMMO(item), ammoChange);
 
-    if (item == ITEM_STICK)
-    {
+    if (item == ITEM_STICK) {
         AMMO(ITEM_STICK) += ammoChange;
 
-        if (AMMO(ITEM_STICK) >= CUR_CAPACITY(UPG_STICKS))
+        if (AMMO(ITEM_STICK) >= CUR_CAPACITY(UPG_STICKS)) {
             AMMO(ITEM_STICK) = CUR_CAPACITY(UPG_STICKS);
-        else if (AMMO(ITEM_STICK) < 0)
+        } else if (AMMO(ITEM_STICK) < 0) {
             AMMO(ITEM_STICK) = 0;
-    }
-    else if (item == ITEM_NUT)
-    {
+        }
+    } else if (item == ITEM_NUT) {
         AMMO(ITEM_NUT) += ammoChange;
 
-        if (AMMO(ITEM_NUT) >= CUR_CAPACITY(UPG_NUTS))
+        if (AMMO(ITEM_NUT) >= CUR_CAPACITY(UPG_NUTS)) {
             AMMO(ITEM_NUT) = CUR_CAPACITY(UPG_NUTS);
-        else if (AMMO(ITEM_NUT) < 0)
+        } else if (AMMO(ITEM_NUT) < 0) {
             AMMO(ITEM_NUT) = 0;
-    }
-    else if (item == ITEM_BOMBCHU)
-    {
+        }
+    } else if (item == ITEM_BOMBCHU) {
         AMMO(ITEM_BOMBCHU) += ammoChange;
 
-        if (AMMO(ITEM_BOMBCHU) >= 50)
+        if (AMMO(ITEM_BOMBCHU) >= 50) {
             AMMO(ITEM_BOMBCHU) = 50;
-        else if (AMMO(ITEM_BOMBCHU) < 0)
+        } else if (AMMO(ITEM_BOMBCHU) < 0) {
             AMMO(ITEM_BOMBCHU) = 0;
-    }
-    else if (item == ITEM_BOW)
-    {
+        }
+    } else if (item == ITEM_BOW) {
         AMMO(ITEM_BOW) += ammoChange;
 
-        if (AMMO(ITEM_BOW) >= CUR_CAPACITY(UPG_QUIVER))
+        if (AMMO(ITEM_BOW) >= CUR_CAPACITY(UPG_QUIVER)) {
             AMMO(ITEM_BOW) = CUR_CAPACITY(UPG_QUIVER);
-        else if (AMMO(ITEM_BOW) < 0)
+        } else if (AMMO(ITEM_BOW) < 0) {
             AMMO(ITEM_BOW) = 0;
-    }
-    else if ((item == ITEM_SLINGSHOT) || (item == ITEM_SEEDS))
-    {
+        }
+    } else if ((item == ITEM_SLINGSHOT) || (item == ITEM_SEEDS)) {
         AMMO(ITEM_SLINGSHOT) += ammoChange;
 
-        if (AMMO(ITEM_SLINGSHOT) >= CUR_CAPACITY(UPG_BULLET_BAG))
+        if (AMMO(ITEM_SLINGSHOT) >= CUR_CAPACITY(UPG_BULLET_BAG)) {
             AMMO(ITEM_SLINGSHOT) = CUR_CAPACITY(UPG_BULLET_BAG);
-        else if (AMMO(ITEM_SLINGSHOT) < 0)
+        } else if (AMMO(ITEM_SLINGSHOT) < 0) {
             AMMO(ITEM_SLINGSHOT) = 0;
-    }
-    else if (item == ITEM_BOMB)
-    {
+        }
+    } else if (item == ITEM_BOMB) {
         AMMO(ITEM_BOMB) += ammoChange;
 
-        if (AMMO(ITEM_BOMB) >= CUR_CAPACITY(UPG_BOMB_BAG))
+        if (AMMO(ITEM_BOMB) >= CUR_CAPACITY(UPG_BOMB_BAG)) {
             AMMO(ITEM_BOMB) = CUR_CAPACITY(UPG_BOMB_BAG);
-        else if (AMMO(ITEM_BOMB) < 0)
+        } else if (AMMO(ITEM_BOMB) < 0) {
             AMMO(ITEM_BOMB) = 0;
-    }
-    else if (item == ITEM_BEAN)
-    {
+        }
+    } else if (item == ITEM_BEAN) {
         AMMO(ITEM_BEAN) += ammoChange;
     }
 
@@ -2597,109 +2286,96 @@ void Inventory_ChangeAmmo(s16 item, s16 ammoChange)
     osSyncPrintf("合計 = (%d)\n", AMMO(item));
 }
 
-void func_80087680(GlobalContext* globalCtx)
-{
-    if (gSaveContext.magic_acquired)
-    {
+void func_80087680(GlobalContext* globalCtx) {
+    if (gSaveContext.magic_acquired) {
         gSaveContext.unk_13F2 = gSaveContext.unk_13F0;
         gSaveContext.unk_13F6 = (gSaveContext.double_magic * 0x30) + 0x30;
         gSaveContext.unk_13F0 = 9;
     }
 }
 
-void func_800876C8(GlobalContext* globalCtx)
-{
-    if ((gSaveContext.unk_13F0 != 8) && (gSaveContext.unk_13F0 != 9))
-    {
-        if (gSaveContext.unk_13F0 == 10)
+void func_800876C8(GlobalContext* globalCtx) {
+    if ((gSaveContext.unk_13F0 != 8) && (gSaveContext.unk_13F0 != 9)) {
+        if (gSaveContext.unk_13F0 == 10) {
             gSaveContext.unk_13F2 = gSaveContext.unk_13F0;
+        }
         gSaveContext.unk_13F0 = 5;
     }
 }
 
-s32 func_80087708(GlobalContext* globalCtx, s16 arg1, s16 arg2)
-{
-    if (!gSaveContext.magic_acquired)
+s32 func_80087708(GlobalContext* globalCtx, s16 arg1, s16 arg2) {
+    if (!gSaveContext.magic_acquired) {
         return 0;
+    }
 
-    if ((arg2 != 5) && (gSaveContext.magic - arg1) < 0)
-    {
-        if (gSaveContext.unk_13F4 != 0)
+    if ((arg2 != 5) && (gSaveContext.magic - arg1) < 0) {
+        if (gSaveContext.unk_13F4 != 0) {
             Audio_PlaySoundGeneral(NA_SE_SY_ERROR, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
+        }
         return 0;
     }
 
-    switch (arg2)
-    {
+    switch (arg2) {
         case 0:
         case 2:
-            if ((gSaveContext.unk_13F0 == 0) || (gSaveContext.unk_13F0 == 7))
-            {
-                if (gSaveContext.unk_13F0 == 7)
+            if ((gSaveContext.unk_13F0 == 0) || (gSaveContext.unk_13F0 == 7)) {
+                if (gSaveContext.unk_13F0 == 7) {
                     globalCtx->actorCtx.unk_03 = 0;
+                }
                 gSaveContext.unk_13F8 = gSaveContext.magic - arg1;
                 gSaveContext.unk_13F0 = 1;
                 return 1;
-            }
-            else
-            {
+            } else {
                 Audio_PlaySoundGeneral(NA_SE_SY_ERROR, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
                 return 0;
             }
         case 1:
-            if ((gSaveContext.unk_13F0 == 0) || (gSaveContext.unk_13F0 == 7))
-            {
-                if (gSaveContext.unk_13F0 == 7)
+            if ((gSaveContext.unk_13F0 == 0) || (gSaveContext.unk_13F0 == 7)) {
+                if (gSaveContext.unk_13F0 == 7) {
                     globalCtx->actorCtx.unk_03 = 0;
+                }
                 gSaveContext.unk_13F8 = gSaveContext.magic - arg1;
                 gSaveContext.unk_13F0 = 6;
                 return 1;
-            }
-            else
-            {
+            } else {
                 Audio_PlaySoundGeneral(NA_SE_SY_ERROR, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
                 return 0;
             }
         case 3:
-            if (gSaveContext.unk_13F0 == 0)
-            {
-                if (gSaveContext.magic != 0)
-                {
+            if (gSaveContext.unk_13F0 == 0) {
+                if (gSaveContext.magic != 0) {
                     globalCtx->interfaceCtx.unk_230 = 80;
                     gSaveContext.unk_13F0 = 7;
                     return 1;
-                }
-                else
+                } else {
                     return 0;
-            }
-            else
-            {
-                if (gSaveContext.unk_13F0 == 7)
+                }
+            } else {
+                if (gSaveContext.unk_13F0 == 7) {
                     return 1;
-                else
+                } else {
                     return 0;
+                }
             }
         case 4:
-            if ((gSaveContext.unk_13F0 == 0) || (gSaveContext.unk_13F0 == 7))
-            {
-                if (gSaveContext.unk_13F0 == 7)
+            if ((gSaveContext.unk_13F0 == 0) || (gSaveContext.unk_13F0 == 7)) {
+                if (gSaveContext.unk_13F0 == 7) {
                     globalCtx->actorCtx.unk_03 = 0;
+                }
                 gSaveContext.unk_13F8 = gSaveContext.magic - arg1;
                 gSaveContext.unk_13F0 = 4;
                 return 1;
-            }
-            else
-            {
+            } else {
                 Audio_PlaySoundGeneral(NA_SE_SY_ERROR, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
                 return 0;
             }
         case 5:
-            if (gSaveContext.unk_13F4 >= gSaveContext.magic)
-            {
+            if (gSaveContext.unk_13F4 >= gSaveContext.magic) {
                 gSaveContext.unk_13F8 = gSaveContext.magic + arg1;
 
-                if (gSaveContext.unk_13F8 >= gSaveContext.unk_13F4)
+                if (gSaveContext.unk_13F8 >= gSaveContext.unk_13F4) {
                     gSaveContext.unk_13F8 = gSaveContext.unk_13F4;
+                }
 
                 gSaveContext.unk_13F0 = 10;
                 return 1;
@@ -2712,10 +2388,8 @@ s32 func_80087708(GlobalContext* globalCtx, s16 arg1, s16 arg2)
 
 #ifdef NON_MATCHING
 // this function still needs some work
-void Interface_UpdateMagicBar(GlobalContext* globalCtx)
-{
-    static s16 sMagicBorderColors[][3] =
-    {
+void Interface_UpdateMagicBar(GlobalContext* globalCtx) {
+    static s16 sMagicBorderColors[][3] = {
         { 0xFF, 0xFF, 0xFF },
         { 0x96, 0x96, 0x96 },
         { 0xFF, 0xFF, 0x96 },
@@ -2727,40 +2401,35 @@ void Interface_UpdateMagicBar(GlobalContext* globalCtx)
     s16* color;
     s16 maxMagic;
 
-    switch (gSaveContext.unk_13F0)
-    {
+    switch (gSaveContext.unk_13F0) {
         case 8:
             maxMagic = gSaveContext.magic_level * 0x30;
-            if (gSaveContext.unk_13F4 != maxMagic)
-            {
-                if (gSaveContext.unk_13F4 < maxMagic)
-                {
+            if (gSaveContext.unk_13F4 != maxMagic) {
+                if (gSaveContext.unk_13F4 < maxMagic) {
                     gSaveContext.unk_13F4 += 8;
-                    if (gSaveContext.unk_13F4 > maxMagic)
+                    if (gSaveContext.unk_13F4 > maxMagic) {
                         gSaveContext.unk_13F4 = maxMagic;
-                }
-                else
-                {
+                    }
+                } else {
                     gSaveContext.unk_13F4 -= 8;
-                    if (gSaveContext.unk_13F4 <= maxMagic)
+                    if (gSaveContext.unk_13F4 <= maxMagic) {
                         gSaveContext.unk_13F4 = maxMagic;
+                    }
                 }
-            }
-            else
-            {
+            } else {
                 gSaveContext.unk_13F0 = 9;
             }
             break;
         case 9:
             gSaveContext.magic += 4;
 
-            if (gSaveContext.game_mode == 0 && gSaveContext.scene_setup_index < 4)
+            if (gSaveContext.game_mode == 0 && gSaveContext.scene_setup_index < 4) {
                 Audio_PlaySoundGeneral(0x401F, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
+            }
 
             // Translates to: "Storage MAGIC_NOW=%d (%d)"
             osSyncPrintf("蓄電 MAGIC_NOW=%d (%d)\n", gSaveContext.magic, gSaveContext.unk_13F6);
-            if (gSaveContext.magic >= gSaveContext.unk_13F6)
-            {
+            if (gSaveContext.magic >= gSaveContext.unk_13F6) {
                 gSaveContext.magic = gSaveContext.unk_13F6;
                 gSaveContext.unk_13F0 = gSaveContext.unk_13F2;
                 gSaveContext.unk_13F2 = 0;
@@ -2772,16 +2441,13 @@ void Interface_UpdateMagicBar(GlobalContext* globalCtx)
             break;
         case 2:
             gSaveContext.magic -= 2;
-            if (gSaveContext.magic <= 0)
-            {
+            if (gSaveContext.magic <= 0) {
                 gSaveContext.magic = 0;
                 gSaveContext.unk_13F0 = 3;
                 sMagicBorderB = 0xFF;
                 sMagicBorderG = 0xFF;
                 sMagicBorderR = 0xFF;
-            }
-            else if (gSaveContext.magic == gSaveContext.unk_13F8)
-            {
+            } else if (gSaveContext.magic == gSaveContext.unk_13F8) {
                 gSaveContext.unk_13F0 = 3;
                 sMagicBorderB = 0xFF;
                 sMagicBorderG = 0xFF;
@@ -2792,31 +2458,34 @@ void Interface_UpdateMagicBar(GlobalContext* globalCtx)
         case 6:
             color = sMagicBorderColors[sMagicBorderIndexes[sMagicBorderStep]];
 
-            if (sMagicBorderR >= color[0])
+            if (sMagicBorderR >= color[0]) {
                 sMagicBorderR -= ABS(sMagicBorderR - color[0]) / sMagicBorderRatio;
-            else
+            } else {
                 sMagicBorderR += ABS(sMagicBorderR - color[0]) / sMagicBorderRatio;
+            }
 
-            if (sMagicBorderG >= color[1])
+            if (sMagicBorderG >= color[1]) {
                 sMagicBorderG -= ABS(sMagicBorderG - color[1]) / sMagicBorderRatio;
-            else
+            } else {
                 sMagicBorderG += ABS(sMagicBorderG - color[1]) / sMagicBorderRatio;
+            }
 
-            if (sMagicBorderB >= color[2])
+            if (sMagicBorderB >= color[2]) {
                 sMagicBorderB -= ABS(sMagicBorderB - color[2]) / sMagicBorderRatio;
-            else
+            } else {
                 sMagicBorderB += ABS(sMagicBorderB - color[2]) / sMagicBorderRatio;
+            }
 
             sMagicBorderRatio--;
-            if (sMagicBorderRatio == 0)
-            {
+            if (sMagicBorderRatio == 0) {
                 sMagicBorderR = color[0];
                 sMagicBorderG = color[1];
                 sMagicBorderB = color[2];
                 sMagicBorderRatio = YREG(40 + sMagicBorderStep);
                 sMagicBorderStep++;
-                if (sMagicBorderStep >= 4)
+                if (sMagicBorderStep >= 4) {
                     sMagicBorderStep = 0;
+                }
             }
             break;
         case 5:
@@ -2826,32 +2495,24 @@ void Interface_UpdateMagicBar(GlobalContext* globalCtx)
             gSaveContext.unk_13F0 = 0;
             break;
         case 7:
-            if ((globalCtx->pauseCtx.state == 0) &&
-                (globalCtx->pauseCtx.flag == 0) &&
-                (globalCtx->msgCtx.msgMode == 0) &&
-                (globalCtx->unk_10A20 == 0) &&
-                (globalCtx->sceneLoadFlag == 0) &&
-                (globalCtx->unk_1241B == 0) &&
-                (func_800BFC84(globalCtx) == 0))
-            {
-                if ((gSaveContext.magic == 0) ||
-                    ((func_8008F2F8(globalCtx) >= 2) &&
-                     (func_8008F2F8(globalCtx) < 5)) ||
+            if ((globalCtx->pauseCtx.state == 0) && (globalCtx->pauseCtx.flag == 0) &&
+                (globalCtx->msgCtx.msgMode == 0) && (globalCtx->unk_10A20 == 0) && (globalCtx->sceneLoadFlag == 0) &&
+                (globalCtx->unk_1241B == 0) && (func_800BFC84(globalCtx) == 0)) {
+                if ((gSaveContext.magic == 0) || ((func_8008F2F8(globalCtx) >= 2) && (func_8008F2F8(globalCtx) < 5)) ||
                     ((gSaveContext.equips.button_items[1] != ITEM_LENS) &&
                      (gSaveContext.equips.button_items[2] != ITEM_LENS) &&
                      (gSaveContext.equips.button_items[3] != ITEM_LENS)) ||
-                    (globalCtx->actorCtx.unk_03 == 0))
-                {
+                    (globalCtx->actorCtx.unk_03 == 0)) {
                     globalCtx->actorCtx.unk_03 = 0;
-                    Audio_PlaySoundGeneral(NA_SE_SY_GLASSMODE_OFF, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
+                    Audio_PlaySoundGeneral(NA_SE_SY_GLASSMODE_OFF, &D_801333D4, 4, &D_801333E0, &D_801333E0,
+                                           &D_801333E8);
                     gSaveContext.unk_13F0 = 0;
                     sMagicBorderR = sMagicBorderG = sMagicBorderB = 0xFF;
                     break;
                 }
 
                 globalCtx->interfaceCtx.unk_230--;
-                if (globalCtx->interfaceCtx.unk_230 == 0)
-                {
+                if (globalCtx->interfaceCtx.unk_230 == 0) {
                     gSaveContext.magic--;
                     globalCtx->interfaceCtx.unk_230 = 80;
                 }
@@ -2859,38 +2520,40 @@ void Interface_UpdateMagicBar(GlobalContext* globalCtx)
 
             color = sMagicBorderColors[sMagicBorderIndexes[sMagicBorderStep]];
 
-            if (sMagicBorderR >= color[0])
+            if (sMagicBorderR >= color[0]) {
                 sMagicBorderR -= ABS(sMagicBorderR - color[0]) / sMagicBorderRatio;
-            else
+            } else {
                 sMagicBorderR += ABS(sMagicBorderR - color[0]) / sMagicBorderRatio;
+            }
 
-            if (sMagicBorderG >= color[1])
+            if (sMagicBorderG >= color[1]) {
                 sMagicBorderG -= ABS(sMagicBorderG - color[1]) / sMagicBorderRatio;
-            else
+            } else {
                 sMagicBorderG += ABS(sMagicBorderG - color[1]) / sMagicBorderRatio;
+            }
 
-            if (sMagicBorderB >= color[2])
+            if (sMagicBorderB >= color[2]) {
                 sMagicBorderB -= ABS(sMagicBorderB - color[2]) / sMagicBorderRatio;
-            else
+            } else {
                 sMagicBorderB += ABS(sMagicBorderB - color[2]) / sMagicBorderRatio;
+            }
 
             sMagicBorderRatio--;
-            if (sMagicBorderRatio == 0)
-            {
+            if (sMagicBorderRatio == 0) {
                 sMagicBorderR = color[0];
                 sMagicBorderG = color[1];
                 sMagicBorderB = color[2];
                 sMagicBorderRatio = YREG(40 + sMagicBorderStep);
                 sMagicBorderStep++;
-                if (sMagicBorderStep >= 4)
+                if (sMagicBorderStep >= 4) {
                     sMagicBorderStep = 0;
+                }
             }
             break;
         case 10:
             gSaveContext.magic += 4;
             Audio_PlaySoundGeneral(0x401F, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
-            if (gSaveContext.magic >= gSaveContext.unk_13F8)
-            {
+            if (gSaveContext.magic >= gSaveContext.unk_13F8) {
                 gSaveContext.magic = gSaveContext.unk_13F8;
                 gSaveContext.unk_13F0 = gSaveContext.unk_13F2;
                 gSaveContext.unk_13F2 = 0;
@@ -2902,8 +2565,7 @@ void Interface_UpdateMagicBar(GlobalContext* globalCtx)
     }
 }
 #else
-s16 sMagicBorderColors[][3] =
-{
+s16 sMagicBorderColors[][3] = {
     { 0xFF, 0xFF, 0xFF },
     { 0x96, 0x96, 0x96 },
     { 0xFF, 0xFF, 0x96 },
@@ -2916,195 +2578,145 @@ void Interface_UpdateMagicBar(GlobalContext* globalCtx);
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_parameter/Interface_UpdateMagicBar.s")
 #endif
 
-void Interface_DrawMagicBar(GlobalContext* globalCtx)
-{
+void Interface_DrawMagicBar(GlobalContext* globalCtx) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
     s16 magicBarY;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 2650);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 2650);
 
-    if (gSaveContext.magic_level != 0)
-    {
-        if (gSaveContext.health_capacity > 0xA0)
+    if (gSaveContext.magic_level != 0) {
+        if (gSaveContext.health_capacity > 0xA0) {
             magicBarY = R_MAGIC_BAR_LARGE_Y;
-        else
+        } else {
             magicBarY = R_MAGIC_BAR_SMALL_Y;
+        }
 
         func_80094520(globalCtx->state.gfxCtx);
 
-        gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, sMagicBorderR, sMagicBorderG, sMagicBorderB, interfaceCtx->magicAlpha);
+        gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, sMagicBorderR, sMagicBorderG, sMagicBorderB,
+                        interfaceCtx->magicAlpha);
         gDPSetEnvColor(gfxCtx->overlay.p++, 0x64, 0x32, 0x32, 0xFF);
 
-        gfxCtx->overlay.p = Draw_TextureIA8(gfxCtx->overlay.p,
-                                            D_020038C0,
-                                            8, 16,
-                                            R_MAGIC_BAR_X, magicBarY,
-                                            8, 16,
-                                            1024, 1024);
+        gfxCtx->overlay.p =
+            Gfx_TextureIA8(gfxCtx->overlay.p, D_020038C0, 8, 16, R_MAGIC_BAR_X, magicBarY, 8, 16, 1024, 1024);
 
-        gfxCtx->overlay.p = Draw_TextureIA8(gfxCtx->overlay.p,
-                                            D_02003940,
-                                            24, 16,
-                                            R_MAGIC_BAR_X + 8, magicBarY,
-                                            gSaveContext.unk_13F4, 16,
-                                            1024, 1024);
+        gfxCtx->overlay.p = Gfx_TextureIA8(gfxCtx->overlay.p, D_02003940, 24, 16, R_MAGIC_BAR_X + 8, magicBarY,
+                                           gSaveContext.unk_13F4, 16, 1024, 1024);
 
         gDPSetTextureImage(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 1, D_020038C0);
-        gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b,
-                    0, 0, G_TX_LOADTILE, 0,
-                    G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-                    G_TX_MIRROR | G_TX_WRAP, 3, G_TX_NOLOD);
+        gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 0, 0, G_TX_LOADTILE, 0, G_TX_NOMIRROR | G_TX_WRAP,
+                   G_TX_NOMASK, G_TX_NOLOD, G_TX_MIRROR | G_TX_WRAP, 3, G_TX_NOLOD);
         gDPLoadSync(gfxCtx->overlay.p++);
         gDPLoadBlock(gfxCtx->overlay.p++, G_TX_LOADTILE, 0, 0, 63, 2048);
         gDPPipeSync(gfxCtx->overlay.p++);
-        gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_8b,
-                   1, 0, G_TX_RENDERTILE, 0,
-                   G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-                   G_TX_MIRROR | G_TX_WRAP, 3, G_TX_NOLOD);
+        gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_8b, 1, 0, G_TX_RENDERTILE, 0, G_TX_NOMIRROR | G_TX_WRAP,
+                   G_TX_NOMASK, G_TX_NOLOD, G_TX_MIRROR | G_TX_WRAP, 3, G_TX_NOLOD);
         gDPSetTileSize(gfxCtx->overlay.p++, G_TX_RENDERTILE, 0, 0, 28, 60);
 
-        gSPTextureRectangle(gfxCtx->overlay.p++,
-                            ((R_MAGIC_BAR_X + gSaveContext.unk_13F4) + 8) << 2, magicBarY << 2,
-                            ((R_MAGIC_BAR_X + gSaveContext.unk_13F4) + 16) << 2, (magicBarY + 16) << 2,
-                            G_TX_RENDERTILE,
-                            256, 0,
-                            1024, 1024);
+        gSPTextureRectangle(gfxCtx->overlay.p++, ((R_MAGIC_BAR_X + gSaveContext.unk_13F4) + 8) << 2, magicBarY << 2,
+                            ((R_MAGIC_BAR_X + gSaveContext.unk_13F4) + 16) << 2, (magicBarY + 16) << 2, G_TX_RENDERTILE,
+                            256, 0, 1024, 1024);
 
         gDPPipeSync(gfxCtx->overlay.p++);
-        gDPSetCombineLERP(gfxCtx->overlay.p++,
-                          PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, 0, 0, 0, PRIMITIVE,
+        gDPSetCombineLERP(gfxCtx->overlay.p++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, 0, 0, 0, PRIMITIVE,
                           PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, 0, 0, 0, PRIMITIVE);
         gDPSetEnvColor(gfxCtx->overlay.p++, 0x00, 0x00, 0x00, 0xFF);
 
-        if (gSaveContext.unk_13F0 == 4)
-        {
+        if (gSaveContext.unk_13F0 == 4) {
             // Yellow part of the bar being used when casting a spell
             gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFA, 0xFA, 0x00, interfaceCtx->magicAlpha);
 
-            gDPLoadMultiBlock_4b(gfxCtx->overlay.p++,
-                                 D_02003AC0,
-                                 0,
-                                 G_TX_RENDERTILE,
-                                 G_IM_FMT_I,
-                                 16, 16,
-                                 0,
-                                 G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP,
-                                 G_TX_NOMASK, G_TX_NOMASK,
+            gDPLoadMultiBlock_4b(gfxCtx->overlay.p++, D_02003AC0, 0, G_TX_RENDERTILE, G_IM_FMT_I, 16, 16, 0,
+                                 G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
                                  G_TX_NOLOD, G_TX_NOLOD);
 
-            gSPTextureRectangle(gfxCtx->overlay.p++,
-                                R_MAGIC_FILL_X << 2, (magicBarY + 3) << 2,
-                                (R_MAGIC_FILL_X + gSaveContext.magic) << 2, (magicBarY + 10) << 2,
-                                G_TX_RENDERTILE,
-                                0, 0,
-                                1024, 1024);
+            gSPTextureRectangle(gfxCtx->overlay.p++, R_MAGIC_FILL_X << 2, (magicBarY + 3) << 2,
+                                (R_MAGIC_FILL_X + gSaveContext.magic) << 2, (magicBarY + 10) << 2, G_TX_RENDERTILE, 0,
+                                0, 1024, 1024);
 
             // Fill the rest of the bar with the normal magic color
             gDPPipeSync(gfxCtx->overlay.p++);
-            gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                            R_MAGIC_FILL_COLOR(0), R_MAGIC_FILL_COLOR(1),
+            gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, R_MAGIC_FILL_COLOR(0), R_MAGIC_FILL_COLOR(1),
                             R_MAGIC_FILL_COLOR(2), interfaceCtx->magicAlpha);
 
-            gSPTextureRectangle(gfxCtx->overlay.p++,
-                                R_MAGIC_FILL_X << 2, (magicBarY + 3) << 2,
-                                (R_MAGIC_FILL_X + gSaveContext.unk_13F8) << 2, (magicBarY + 10) << 2,
-                                G_TX_RENDERTILE,
-                                0, 0,
-                                1024, 1024);
-        }
-        else
-        {
+            gSPTextureRectangle(gfxCtx->overlay.p++, R_MAGIC_FILL_X << 2, (magicBarY + 3) << 2,
+                                (R_MAGIC_FILL_X + gSaveContext.unk_13F8) << 2, (magicBarY + 10) << 2, G_TX_RENDERTILE,
+                                0, 0, 1024, 1024);
+        } else {
             // Fill the whole bar with the normal magic color
-            gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                            R_MAGIC_FILL_COLOR(0), R_MAGIC_FILL_COLOR(1),
+            gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, R_MAGIC_FILL_COLOR(0), R_MAGIC_FILL_COLOR(1),
                             R_MAGIC_FILL_COLOR(2), interfaceCtx->magicAlpha);
 
-            gDPLoadMultiBlock_4b(gfxCtx->overlay.p++,
-                                 D_02003AC0,
-                                 0,
-                                 G_TX_RENDERTILE,
-                                 G_IM_FMT_I,
-                                 16, 16,
-                                 0,
-                                 G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP,
-                                 G_TX_NOMASK, G_TX_NOMASK,
+            gDPLoadMultiBlock_4b(gfxCtx->overlay.p++, D_02003AC0, 0, G_TX_RENDERTILE, G_IM_FMT_I, 16, 16, 0,
+                                 G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
                                  G_TX_NOLOD, G_TX_NOLOD);
 
-            gSPTextureRectangle(gfxCtx->overlay.p++,
-                                R_MAGIC_FILL_X << 2, (magicBarY + 3) << 2,
-                                (R_MAGIC_FILL_X + gSaveContext.magic) << 2, (magicBarY + 10) << 2,
-                                G_TX_RENDERTILE,
-                                0, 0,
-                                1024, 1024);
+            gSPTextureRectangle(gfxCtx->overlay.p++, R_MAGIC_FILL_X << 2, (magicBarY + 3) << 2,
+                                (R_MAGIC_FILL_X + gSaveContext.magic) << 2, (magicBarY + 10) << 2, G_TX_RENDERTILE, 0,
+                                0, 1024, 1024);
         }
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 2731);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 2731);
 }
 
-void func_80088AA0(s16 arg0)
-{
+void func_80088AA0(s16 arg0) {
     gSaveContext.timer_x[1] = 140;
     gSaveContext.timer_y[1] = 80;
     D_80125A5C = 0;
     gSaveContext.timer_2_value = arg0;
 
-    if (arg0 != 0)
+    if (arg0 != 0) {
         gSaveContext.timer_2_state = 1;
-    else
+    } else {
         gSaveContext.timer_2_state = 7;
+    }
 }
 
-void func_80088AF0(GlobalContext* globalCtx)
-{
-    if (gSaveContext.timer_2_state != 0)
-    {
-        if (gSaveContext.event_inf[1] & 1)
+void func_80088AF0(GlobalContext* globalCtx) {
+    if (gSaveContext.timer_2_state != 0) {
+        if (gSaveContext.event_inf[1] & 1) {
             gSaveContext.timer_2_value = 239;
-        else
+        } else {
             gSaveContext.timer_2_value = 1;
+        }
     }
 }
 
-void func_80088B34(s16 arg0)
-{
+void func_80088B34(s16 arg0) {
     gSaveContext.timer_x[0] = 140;
     gSaveContext.timer_y[0] = 80;
     D_80125A5C = 0;
     gSaveContext.timer_1_value = arg0;
 
-    if (arg0 != 0)
+    if (arg0 != 0) {
         gSaveContext.timer_1_state = 5;
-    else
+    } else {
         gSaveContext.timer_1_state = 11;
+    }
 }
 
-void Interface_DrawActionLabel(GraphicsContext* gfxCtx, void* texture)
-{
-    Gfx* gfxArr[5];
+void Interface_DrawActionLabel(GraphicsContext* gfxCtx, void* texture) {
+    Gfx* dispRefs[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_parameter.c", 2820);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_parameter.c", 2820);
 
     gDPSetTextureImage(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 1, texture);
-    gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b,
-               0, 0, G_TX_LOADTILE, 0,
-               G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-               G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+    gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 0, 0, G_TX_LOADTILE, 0, G_TX_NOMIRROR | G_TX_WRAP,
+               G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
     gDPLoadSync(gfxCtx->overlay.p++);
     gDPLoadBlock(gfxCtx->overlay.p++, G_TX_LOADTILE, 0, 0, 191, 683);
     gDPPipeSync(gfxCtx->overlay.p++);
-    gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_4b,
-               3, 0, G_TX_RENDERTILE, 0,
-               G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-               G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+    gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_4b, 3, 0, G_TX_RENDERTILE, 0, G_TX_NOMIRROR | G_TX_WRAP,
+               G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
     gDPSetTileSize(gfxCtx->overlay.p++, G_TX_RENDERTILE, 0, 0, 188, 60);
 
     gSP1Quadrangle(gfxCtx->overlay.p++, 0, 2, 3, 1, 0);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_parameter.c", 2829);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_parameter.c", 2829);
 }
 
 u8* sCUpLabelTextures[] = { D_02002FC0, D_02002FC0, D_02002FC0 };
@@ -3113,8 +2725,7 @@ s16 sStartButtonLeftPos[] = { 132, 130, 130 };
 
 #ifdef NON_MATCHING
 // regalloc and ordering differences
-void Interface_DrawItemButtons(GlobalContext* globalCtx)
-{
+void Interface_DrawItemButtons(GlobalContext* globalCtx) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
     Player* player = PLAYER;
     f32 temp;
@@ -3122,178 +2733,125 @@ void Interface_DrawItemButtons(GlobalContext* globalCtx)
     s16 cUpAlpha;
     s32 pad;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 2900);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 2900);
 
     // B Button Color & Texture
     // Also loads the Item Button Texture reused by other buttons afterwards
     gDPPipeSync(gfxCtx->overlay.p++);
-    gDPSetCombineLERP(gfxCtx->overlay.p++,
-                      TEXEL0, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0,
-                      TEXEL0, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0);
-    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                    R_B_BTN_COLOR(0), R_B_BTN_COLOR(1),
-                    R_B_BTN_COLOR(2), interfaceCtx->bAlpha);
+    gDPSetCombineMode(gfxCtx->overlay.p++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
+    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, R_B_BTN_COLOR(0), R_B_BTN_COLOR(1), R_B_BTN_COLOR(2),
+                    interfaceCtx->bAlpha);
     gDPSetEnvColor(gfxCtx->overlay.p++, 0x00, 0x00, 0x00, 0xFF);
-    gfxCtx->overlay.p = Draw_TextureIA8(gfxCtx->overlay.p,
-                                        &D_02000A00[0],
-                                        32, 32,
-                                        R_ITEM_BTN_X(0), R_ITEM_BTN_Y(0),
-                                        R_ITEM_BTN_WIDTH(0), R_ITEM_BTN_WIDTH(0),
-                                        R_ITEM_BTN_DD(0) * 2, R_ITEM_BTN_DD(0) * 2);
+    gfxCtx->overlay.p =
+        Gfx_TextureIA8(gfxCtx->overlay.p, &D_02000A00[0], 32, 32, R_ITEM_BTN_X(0), R_ITEM_BTN_Y(0), R_ITEM_BTN_WIDTH(0),
+                       R_ITEM_BTN_WIDTH(0), R_ITEM_BTN_DD(0) * 2, R_ITEM_BTN_DD(0) * 2);
 
     // C-Left Button Color & Texture
     gDPPipeSync(gfxCtx->overlay.p++);
-    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                    R_C_BTN_COLOR(0), R_C_BTN_COLOR(1),
-                    R_C_BTN_COLOR(2), interfaceCtx->cLeftAlpha);
-    gSPTextureRectangle(gfxCtx->overlay.p++,
-                        R_ITEM_BTN_X(1) << 2,
-                        R_ITEM_BTN_Y(1) << 2,
-                        (R_ITEM_BTN_X(1) + R_ITEM_BTN_WIDTH(1)) << 2,
-                        (R_ITEM_BTN_Y(1) + R_ITEM_BTN_WIDTH(1)) << 2,
-                        G_TX_RENDERTILE,
-                        0, 0,
-                        R_ITEM_BTN_DD(1) * 2,
-                        R_ITEM_BTN_DD(1) * 2);
+    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, R_C_BTN_COLOR(0), R_C_BTN_COLOR(1), R_C_BTN_COLOR(2),
+                    interfaceCtx->cLeftAlpha);
+    gSPTextureRectangle(gfxCtx->overlay.p++, R_ITEM_BTN_X(1) << 2, R_ITEM_BTN_Y(1) << 2,
+                        (R_ITEM_BTN_X(1) + R_ITEM_BTN_WIDTH(1)) << 2, (R_ITEM_BTN_Y(1) + R_ITEM_BTN_WIDTH(1)) << 2,
+                        G_TX_RENDERTILE, 0, 0, R_ITEM_BTN_DD(1) * 2, R_ITEM_BTN_DD(1) * 2);
 
     // C-Down Button Color & Texture
-    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                    R_C_BTN_COLOR(0), R_C_BTN_COLOR(1),
-                    R_C_BTN_COLOR(2), interfaceCtx->cDownAlpha);
-    gSPTextureRectangle(gfxCtx->overlay.p++,
-                        R_ITEM_BTN_X(2) << 2,
-                        R_ITEM_BTN_Y(2) << 2,
-                        (R_ITEM_BTN_X(2) + R_ITEM_BTN_WIDTH(2)) << 2,
-                        (R_ITEM_BTN_Y(2) + R_ITEM_BTN_WIDTH(2)) << 2,
-                        G_TX_RENDERTILE,
-                        0, 0,
-                        R_ITEM_BTN_DD(2) * 2,
-                        R_ITEM_BTN_DD(2) * 2);
+    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, R_C_BTN_COLOR(0), R_C_BTN_COLOR(1), R_C_BTN_COLOR(2),
+                    interfaceCtx->cDownAlpha);
+    gSPTextureRectangle(gfxCtx->overlay.p++, R_ITEM_BTN_X(2) << 2, R_ITEM_BTN_Y(2) << 2,
+                        (R_ITEM_BTN_X(2) + R_ITEM_BTN_WIDTH(2)) << 2, (R_ITEM_BTN_Y(2) + R_ITEM_BTN_WIDTH(2)) << 2,
+                        G_TX_RENDERTILE, 0, 0, R_ITEM_BTN_DD(2) * 2, R_ITEM_BTN_DD(2) * 2);
 
     // C-Right Button Color & Texture
-    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                    R_C_BTN_COLOR(0), R_C_BTN_COLOR(1),
-                    R_C_BTN_COLOR(2), interfaceCtx->cRightAlpha);
-    gSPTextureRectangle(gfxCtx->overlay.p++,
-                        R_ITEM_BTN_X(3) << 2,
-                        R_ITEM_BTN_Y(3) << 2,
-                        (R_ITEM_BTN_X(3) + R_ITEM_BTN_WIDTH(3)) << 2,
-                        (R_ITEM_BTN_Y(3) + R_ITEM_BTN_WIDTH(3)) << 2,
-                        G_TX_RENDERTILE,
-                        0, 0,
-                        R_ITEM_BTN_DD(3) * 2,
-                        R_ITEM_BTN_DD(3) * 2);
-
-    if ((globalCtx->pauseCtx.state < 8) || (globalCtx->pauseCtx.state >= 18))
-    {
-        if ((globalCtx->pauseCtx.state != 0) || (globalCtx->pauseCtx.flag != 0))
-        {
+    gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, R_C_BTN_COLOR(0), R_C_BTN_COLOR(1), R_C_BTN_COLOR(2),
+                    interfaceCtx->cRightAlpha);
+    gSPTextureRectangle(gfxCtx->overlay.p++, R_ITEM_BTN_X(3) << 2, R_ITEM_BTN_Y(3) << 2,
+                        (R_ITEM_BTN_X(3) + R_ITEM_BTN_WIDTH(3)) << 2, (R_ITEM_BTN_Y(3) + R_ITEM_BTN_WIDTH(3)) << 2,
+                        G_TX_RENDERTILE, 0, 0, R_ITEM_BTN_DD(3) * 2, R_ITEM_BTN_DD(3) * 2);
+
+    if ((globalCtx->pauseCtx.state < 8) || (globalCtx->pauseCtx.state >= 18)) {
+        if ((globalCtx->pauseCtx.state != 0) || (globalCtx->pauseCtx.flag != 0)) {
             // Start Button Texture, Color & Label
             gDPPipeSync(gfxCtx->overlay.p++);
             gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0x78, 0x78, 0x78, interfaceCtx->startAlpha);
-            gSPTextureRectangle(gfxCtx->overlay.p++,
-                                sStartButtonLeftPos[gSaveContext.language] << 2, 156,
-                                (sStartButtonLeftPos[gSaveContext.language] + 22) << 2, 68,
-                                G_TX_RENDERTILE,
-                                0, 0,
-                                1462, 1462);
+            gSPTextureRectangle(gfxCtx->overlay.p++, sStartButtonLeftPos[gSaveContext.language] << 2, 156,
+                                (sStartButtonLeftPos[gSaveContext.language] + 22) << 2, 68, G_TX_RENDERTILE, 0, 0, 1462,
+                                1462);
             gDPPipeSync(gfxCtx->overlay.p++);
             gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFF, 0xFF, 0xFF, interfaceCtx->startAlpha);
             gDPSetEnvColor(gfxCtx->overlay.p++, 0x00, 0x00, 0x00, 0x00);
-            gDPSetCombineLERP(gfxCtx->overlay.p++,
-                            PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
-                            PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
-
-            gDPSetTextureImage(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 1, (u32)interfaceCtx->do_actionSegment + 0x300);
-            gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b,
-                        0, 0, G_TX_LOADTILE, 0,
-                        G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-                        G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+            gDPSetCombineLERP(gfxCtx->overlay.p++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
+                              PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
+
+            gDPSetTextureImage(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 1,
+                               (u32)interfaceCtx->do_actionSegment + 0x300);
+            gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 0, 0, G_TX_LOADTILE, 0,
+                       G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK,
+                       G_TX_NOLOD);
             gDPLoadSync(gfxCtx->overlay.p++);
             gDPLoadBlock(gfxCtx->overlay.p++, G_TX_LOADTILE, 0, 0, 191, 683);
             gDPPipeSync(gfxCtx->overlay.p++);
-            gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_4b,
-                        3, 0, G_TX_RENDERTILE, 0,
-                        G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-                        G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+            gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_4b, 3, 0, G_TX_RENDERTILE, 0,
+                       G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK,
+                       G_TX_NOLOD);
             gDPSetTileSize(gfxCtx->overlay.p++, G_TX_RENDERTILE, 0, 0, 48, 16);
 
             temp = R_START_LABEL_DD(gSaveContext.language) / 100.0f;
-            gSPTextureRectangle(gfxCtx->overlay.p++,
-                                R_START_LABEL_X(gSaveContext.language) << 2,
+            gSPTextureRectangle(gfxCtx->overlay.p++, R_START_LABEL_X(gSaveContext.language) << 2,
                                 R_START_LABEL_Y(gSaveContext.language) << 2,
                                 (R_START_LABEL_X(gSaveContext.language) + (s16)(16 / temp)) << 2,
-                                (R_START_LABEL_Y(gSaveContext.language) + (s16)(48 / temp)) << 2,
-                                G_TX_RENDERTILE,
-                                0, 0,
-                                (s16)(1024 / temp),
-                                (s16)(1024 / temp));
+                                (R_START_LABEL_Y(gSaveContext.language) + (s16)(48 / temp)) << 2, G_TX_RENDERTILE, 0, 0,
+                                (s16)(1024 / temp), (s16)(1024 / temp));
         }
     }
 
-    if (interfaceCtx->naviCalling && (globalCtx->pauseCtx.state == 0) &&
-        (globalCtx->pauseCtx.flag == 0) && (globalCtx->csCtx.state == 0))
-    {
-        if (!sCUpInvisible)
-        {
+    if (interfaceCtx->naviCalling && (globalCtx->pauseCtx.state == 0) && (globalCtx->pauseCtx.flag == 0) &&
+        (globalCtx->csCtx.state == 0)) {
+        if (!sCUpInvisible) {
             // C-Up Button Texture, Color & Label (Navi Text)
             gDPPipeSync(gfxCtx->overlay.p++);
 
-            if ((gSaveContext.unk_13EA == 1) || (gSaveContext.unk_13EA == 2) || (gSaveContext.unk_13EA == 5))
+            if ((gSaveContext.unk_13EA == 1) || (gSaveContext.unk_13EA == 2) || (gSaveContext.unk_13EA == 5)) {
                 cUpAlpha = 0;
-            else if ((player->stateFlags2 & 0x00200000) || (func_8008F2F8(globalCtx) == 4) || (player->stateFlags2 & 0x00040000))
+            } else if ((player->stateFlags2 & 0x00200000) || (func_8008F2F8(globalCtx) == 4) ||
+                       (player->stateFlags2 & 0x00040000)) {
                 cUpAlpha = 0x46;
-            else
+            } else {
                 cUpAlpha = interfaceCtx->healthAlpha;
+            }
 
-            gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                            R_C_BTN_COLOR(0), R_C_BTN_COLOR(1),
-                            R_C_BTN_COLOR(2), cUpAlpha);
-            gDPSetCombineLERP(gfxCtx->overlay.p++,
-                              TEXEL0, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0,
-                              TEXEL0, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0);
-            gSPTextureRectangle(gfxCtx->overlay.p++,
-                                R_C_UP_BTN_X << 2, R_C_UP_BTN_Y << 2,
-                                (R_C_UP_BTN_X + 16) << 2, (R_C_UP_BTN_Y + 16) << 2,
-                                G_TX_RENDERTILE,
-                                0, 0,
-                                2048, 2048);
+            gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, R_C_BTN_COLOR(0), R_C_BTN_COLOR(1), R_C_BTN_COLOR(2), cUpAlpha);
+            gDPSetCombineMode(gfxCtx->overlay.p++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
+            gSPTextureRectangle(gfxCtx->overlay.p++, R_C_UP_BTN_X << 2, R_C_UP_BTN_Y << 2, (R_C_UP_BTN_X + 16) << 2,
+                                (R_C_UP_BTN_Y + 16) << 2, G_TX_RENDERTILE, 0, 0, 2048, 2048);
             gDPPipeSync(gfxCtx->overlay.p++);
             gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFF, 0xFF, 0xFF, cUpAlpha);
             gDPSetEnvColor(gfxCtx->overlay.p++, 0x00, 0x00, 0x00, 0x00);
-            gDPSetCombineLERP(gfxCtx->overlay.p++,
-                              PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
+            gDPSetCombineLERP(gfxCtx->overlay.p++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
                               PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
 
-            gDPSetTextureImage(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 1, sCUpLabelTextures[gSaveContext.language]);
-            gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b,
-                       0, 0, G_TX_LOADTILE, 0,
-                       G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-                       G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+            gDPSetTextureImage(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 1,
+                               sCUpLabelTextures[gSaveContext.language]);
+            gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 0, 0, G_TX_LOADTILE, 0,
+                       G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK,
+                       G_TX_NOLOD);
             gDPLoadSync(gfxCtx->overlay.p++);
             gDPLoadBlock(gfxCtx->overlay.p++, G_TX_LOADTILE, 0, 0, 63, 1024);
             gDPPipeSync(gfxCtx->overlay.p++);
-            gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_4b,
-                       2, 0, G_TX_RENDERTILE, 0,
-                       G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-                       G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+            gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_4b, 2, 0, G_TX_RENDERTILE, 0,
+                       G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK,
+                       G_TX_NOLOD);
             gDPSetTileSize(gfxCtx->overlay.p++, G_TX_RENDERTILE, 0, 0, 124, 28);
 
-            gSPTextureRectangle(gfxCtx->overlay.p++,
-                                R_C_UP_ICON_X << 2, R_C_UP_ICON_Y << 2,
-                                (R_C_UP_ICON_X + 8) << 2, (R_C_UP_ICON_Y + 32) << 2,
-                                G_TX_RENDERTILE,
-                                0, 0,
-                                1024, 1024);
+            gSPTextureRectangle(gfxCtx->overlay.p++, R_C_UP_ICON_X << 2, R_C_UP_ICON_Y << 2, (R_C_UP_ICON_X + 8) << 2,
+                                (R_C_UP_ICON_Y + 32) << 2, G_TX_RENDERTILE, 0, 0, 1024, 1024);
         }
 
         sCUpTimer--;
-        if (sCUpTimer == 0)
-        {
+        if (sCUpTimer == 0) {
             sCUpTimer = 10;
             sCUpInvisible ^= 1;
         }
@@ -3302,185 +2860,145 @@ void Interface_DrawItemButtons(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->overlay.p++);
 
     // Empty C Button Arrows
-    for (i = 1; i < 4; i++)
-    {
-        if (gSaveContext.equips.button_items[i] > 0xF0)
-        {
-            if (i == 1)
-                gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                                R_C_BTN_COLOR(0), R_C_BTN_COLOR(1),
-                                R_C_BTN_COLOR(2), interfaceCtx->cLeftAlpha);
-            else if (i == 2)
-                gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                                R_C_BTN_COLOR(0), R_C_BTN_COLOR(1),
-                                R_C_BTN_COLOR(2), interfaceCtx->cDownAlpha);
-            else
-                gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                                R_C_BTN_COLOR(0), R_C_BTN_COLOR(1),
-                                R_C_BTN_COLOR(2), interfaceCtx->cRightAlpha);
-
-            gfxCtx->overlay.p = Draw_TextureIA8(gfxCtx->overlay.p,
-                                                &D_02000A00[i + 1],
-                                                0x20, 0x20,
-                                                R_ITEM_BTN_X(i), R_ITEM_BTN_Y(i),
-                                                R_ITEM_BTN_WIDTH(i), R_ITEM_BTN_WIDTH(i),
-                                                R_ITEM_BTN_DD(i) * 2, R_ITEM_BTN_DD(i) * 2);
+    for (i = 1; i < 4; i++) {
+        if (gSaveContext.equips.button_items[i] > 0xF0) {
+            if (i == 1) {
+                gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, R_C_BTN_COLOR(0), R_C_BTN_COLOR(1), R_C_BTN_COLOR(2),
+                                interfaceCtx->cLeftAlpha);
+            } else if (i == 2) {
+                gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, R_C_BTN_COLOR(0), R_C_BTN_COLOR(1), R_C_BTN_COLOR(2),
+                                interfaceCtx->cDownAlpha);
+            } else {
+                gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, R_C_BTN_COLOR(0), R_C_BTN_COLOR(1), R_C_BTN_COLOR(2),
+                                interfaceCtx->cRightAlpha);
+            }
+
+            gfxCtx->overlay.p =
+                Gfx_TextureIA8(gfxCtx->overlay.p, &D_02000A00[i + 1], 0x20, 0x20, R_ITEM_BTN_X(i), R_ITEM_BTN_Y(i),
+                               R_ITEM_BTN_WIDTH(i), R_ITEM_BTN_WIDTH(i), R_ITEM_BTN_DD(i) * 2, R_ITEM_BTN_DD(i) * 2);
         }
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3071);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 3071);
 }
 #else
 void Interface_DrawItemButtons(GlobalContext* globalCtx);
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_parameter/Interface_DrawItemButtons.s")
 #endif
 
-void Interface_DrawItemIconTexture(GlobalContext* globalCtx, void* texture, s16 button)
-{
+void Interface_DrawItemIconTexture(GlobalContext* globalCtx, void* texture, s16 button) {
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3079);
-
-    gDPLoadTextureBlock(gfxCtx->overlay.p++,
-                        texture,
-                        G_IM_FMT_RGBA,
-                        G_IM_SIZ_32b,
-                        32, 32,
-                        0,
-                        G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP,
-                        G_TX_NOMASK, G_TX_NOMASK,
-                        G_TX_NOLOD, G_TX_NOLOD);
-
-    gSPTextureRectangle(gfxCtx->overlay.p++,
-                        R_ITEM_ICON_X(button) << 2,
-                        R_ITEM_ICON_Y(button) << 2,
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 3079);
+
+    gDPLoadTextureBlock(gfxCtx->overlay.p++, texture, G_IM_FMT_RGBA, G_IM_SIZ_32b, 32, 32, 0, G_TX_NOMIRROR | G_TX_WRAP,
+                        G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
+
+    gSPTextureRectangle(gfxCtx->overlay.p++, R_ITEM_ICON_X(button) << 2, R_ITEM_ICON_Y(button) << 2,
                         (R_ITEM_ICON_X(button) + R_ITEM_ICON_WIDTH(button)) << 2,
-                        (R_ITEM_ICON_Y(button) + R_ITEM_ICON_WIDTH(button)) << 2,
-                        G_TX_RENDERTILE,
-                        0, 0,
-                        R_ITEM_ICON_DD(button) * 2,
-                        R_ITEM_ICON_DD(button) * 2);
+                        (R_ITEM_ICON_Y(button) + R_ITEM_ICON_WIDTH(button)) << 2, G_TX_RENDERTILE, 0, 0,
+                        R_ITEM_ICON_DD(button) * 2, R_ITEM_ICON_DD(button) * 2);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3094);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 3094);
 }
 
-void Interface_DrawAmmoCount(GlobalContext* globalCtx, s16 button, s16 alpha)
-{
+void Interface_DrawAmmoCount(GlobalContext* globalCtx, s16 button, s16 alpha) {
     s16 item;
     s16 ammo;
     GraphicsContext* gfxCtx;
     s16 i;
-    Gfx* gfxArr[3];
+    Gfx* dispRefs[3];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3105);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 3105);
 
     item = gSaveContext.equips.button_items[button];
 
-    if ((item == ITEM_STICK) || (item == ITEM_NUT) ||
-        (item == ITEM_BOMB) || (item == ITEM_BOW) ||
-        ((item >= ITEM_BOW_ARROW_FIRE) && (item <= ITEM_BOW_ARROW_LIGHT)) ||
-        (item == ITEM_SLINGSHOT) || (item == ITEM_BOMBCHU) || (item == ITEM_BEAN))
-    {
-        if ((item >= ITEM_BOW_ARROW_FIRE) && (item <= ITEM_BOW_ARROW_LIGHT))
+    if ((item == ITEM_STICK) || (item == ITEM_NUT) || (item == ITEM_BOMB) || (item == ITEM_BOW) ||
+        ((item >= ITEM_BOW_ARROW_FIRE) && (item <= ITEM_BOW_ARROW_LIGHT)) || (item == ITEM_SLINGSHOT) ||
+        (item == ITEM_BOMBCHU) || (item == ITEM_BEAN)) {
+        if ((item >= ITEM_BOW_ARROW_FIRE) && (item <= ITEM_BOW_ARROW_LIGHT)) {
             item = ITEM_BOW;
+        }
 
         ammo = AMMO(item);
 
         gDPPipeSync(gfxCtx->overlay.p++);
 
-        if ((button == 0) && (gSaveContext.minigame_state == 1))
-        {
+        if ((button == 0) && (gSaveContext.minigame_state == 1)) {
             ammo = globalCtx->interfaceCtx.hbaAmmo;
-        }
-        else if ((button == 0) && (globalCtx->unk_11E5C >= 2))
-        {
+        } else if ((button == 0) && (globalCtx->unk_11E5C >= 2)) {
             ammo = globalCtx->unk_11E5C - 1;
-        }
-        else if ((button == 0) && (globalCtx->sceneNum == SCENE_BOWLING) && Flags_GetSwitch(globalCtx, 0x38))
-        {
+        } else if ((button == 0) && (globalCtx->sceneNum == SCENE_BOWLING) && Flags_GetSwitch(globalCtx, 0x38)) {
             ammo = globalCtx->bombchuBowlingAmmo;
-            if (ammo < 0)
+            if (ammo < 0) {
                 ammo = 0;
-        }
-        else if (((item == ITEM_BOW)       && (AMMO(item) == CUR_CAPACITY(UPG_QUIVER))) ||
-                 ((item == ITEM_BOMB)      && (AMMO(item) == CUR_CAPACITY(UPG_BOMB_BAG))) ||
-                 ((item == ITEM_SLINGSHOT) && (AMMO(item) == CUR_CAPACITY(UPG_BULLET_BAG))) ||
-                 ((item == ITEM_STICK)     && (AMMO(item) == CUR_CAPACITY(UPG_STICKS))) ||
-                 ((item == ITEM_NUT)       && (AMMO(item) == CUR_CAPACITY(UPG_NUTS))) ||
-                 ((item == ITEM_BOMBCHU)   && (ammo == 50)) ||
-                 ((item == ITEM_BEAN)      && (ammo == 15)))
-        {
+            }
+        } else if (((item == ITEM_BOW) && (AMMO(item) == CUR_CAPACITY(UPG_QUIVER))) ||
+                   ((item == ITEM_BOMB) && (AMMO(item) == CUR_CAPACITY(UPG_BOMB_BAG))) ||
+                   ((item == ITEM_SLINGSHOT) && (AMMO(item) == CUR_CAPACITY(UPG_BULLET_BAG))) ||
+                   ((item == ITEM_STICK) && (AMMO(item) == CUR_CAPACITY(UPG_STICKS))) ||
+                   ((item == ITEM_NUT) && (AMMO(item) == CUR_CAPACITY(UPG_NUTS))) ||
+                   ((item == ITEM_BOMBCHU) && (ammo == 50)) || ((item == ITEM_BEAN) && (ammo == 15))) {
             gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0x78, 0xFF, 0x00, alpha);
         }
 
-        if (ammo == 0)
+        if (ammo == 0) {
             gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0x64, 0x64, 0x64, alpha);
+        }
 
-        for (i = 0; ammo >= 10; i++)
+        for (i = 0; ammo >= 10; i++) {
             ammo -= 10;
+        }
 
-        if (i != 0)
-            gfxCtx->overlay.p = Draw_TextureIA8(gfxCtx->overlay.p,
-                                                &D_020035C0[i],
-                                                8, 8,
-                                                R_ITEM_AMMO_X(button), R_ITEM_AMMO_Y(button),
-                                                8, 8,
-                                                1024, 1024);
-
-        gfxCtx->overlay.p = Draw_TextureIA8(gfxCtx->overlay.p,
-                                            &D_020035C0[ammo],
-                                            8, 8,
-                                            R_ITEM_AMMO_X(button) + 6, R_ITEM_AMMO_Y(button),
-                                            8, 8,
-                                            1024, 1024);
+        if (i != 0) {
+            gfxCtx->overlay.p = Gfx_TextureIA8(gfxCtx->overlay.p, &D_020035C0[i], 8, 8, R_ITEM_AMMO_X(button),
+                                               R_ITEM_AMMO_Y(button), 8, 8, 1024, 1024);
+        }
+
+        gfxCtx->overlay.p = Gfx_TextureIA8(gfxCtx->overlay.p, &D_020035C0[ammo], 8, 8, R_ITEM_AMMO_X(button) + 6,
+                                           R_ITEM_AMMO_Y(button), 8, 8, 1024, 1024);
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3158);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 3158);
 }
 
-void Interface_DrawActionButton(GlobalContext* globalCtx)
-{
+void Interface_DrawActionButton(GlobalContext* globalCtx) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3172);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 3172);
 
     Matrix_Translate(0.0f, 0.0f, XREG(18) / 10.0f, MTXMODE_NEW);
     Matrix_Scale(1.0f, 1.0f, 1.0f, MTXMODE_APPLY);
     Matrix_RotateX(interfaceCtx->unk_1F4 / 10000.0f, MTXMODE_APPLY);
 
-    if (1) ; // Necessary to match
+    if (1) {} // Necessary to match
 
-    gSPMatrix(gfxCtx->overlay.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_parameter.c", 3177), G_MTX_MODELVIEW | G_MTX_LOAD);
+    gSPMatrix(gfxCtx->overlay.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_parameter.c", 3177),
+              G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPVertex(gfxCtx->overlay.p++, interfaceCtx->vtx_128, 4, 0);
 
-    gDPLoadTextureBlock(gfxCtx->overlay.p++,
-                        &D_02000A00[0],
-                        G_IM_FMT_IA,
-                        G_IM_SIZ_8b,
-                        32, 32,
-                        0,
-                        G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP,
-                        G_TX_NOMASK, G_TX_NOMASK,
-                        G_TX_NOLOD, G_TX_NOLOD);
+    gDPLoadTextureBlock(gfxCtx->overlay.p++, &D_02000A00[0], G_IM_FMT_IA, G_IM_SIZ_8b, 32, 32, 0,
+                        G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
+                        G_TX_NOLOD);
 
     gSP1Quadrangle(gfxCtx->overlay.p++, 0, 2, 3, 1, 0);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3187);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 3187);
 }
 
-void Interface_InitVertices(GlobalContext* globalCtx)
-{
+void Interface_InitVertices(GlobalContext* globalCtx) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
     s16 i;
 
     interfaceCtx->vtx_128 = Graph_Alloc(globalCtx->state.gfxCtx, 8 * sizeof(Vtx));
 
+    // clang-format off
     interfaceCtx->vtx_128[0].v.ob[0] =
     interfaceCtx->vtx_128[2].v.ob[0] = -14;
     interfaceCtx->vtx_128[1].v.ob[0] =
@@ -3501,8 +3019,7 @@ void Interface_InitVertices(GlobalContext* globalCtx)
     interfaceCtx->vtx_128[6].v.ob[1] =
     interfaceCtx->vtx_128[7].v.ob[1] = interfaceCtx->vtx_128[4].v.ob[1] - XREG(28);
 
-    for (i = 0; i < 8; i += 4)
-    {
+    for (i = 0; i < 8; i += 4) {
         interfaceCtx->vtx_128[i].v.ob[2] = interfaceCtx->vtx_128[i+1].v.ob[2] =
         interfaceCtx->vtx_128[i+2].v.ob[2] = interfaceCtx->vtx_128[i+3].v.ob[2] = 0;
 
@@ -3554,10 +3071,10 @@ void Interface_InitVertices(GlobalContext* globalCtx)
     interfaceCtx->vtx_12C[2].v.cn[2] = interfaceCtx->vtx_12C[3].v.cn[2] =
     interfaceCtx->vtx_12C[0].v.cn[3] = interfaceCtx->vtx_12C[1].v.cn[3] =
     interfaceCtx->vtx_12C[2].v.cn[3] = interfaceCtx->vtx_12C[3].v.cn[3] = 0xFF;
+    // clang-format on
 }
 
-void func_8008A8B8(GlobalContext* globalCtx, s32 arg1, s32 arg2, s32 arg3, s32 arg4)
-{
+void func_8008A8B8(GlobalContext* globalCtx, s32 arg1, s32 arg2, s32 arg3, s32 arg4) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
     Vec3f sp40;
     Vec3f sp34;
@@ -3578,13 +3095,13 @@ void func_8008A8B8(GlobalContext* globalCtx, s32 arg1, s32 arg2, s32 arg3, s32 a
     func_800AB560(&interfaceCtx->view);
 }
 
-void func_8008A994(InterfaceContext* interfaceCtx)
-{
+void func_8008A994(InterfaceContext* interfaceCtx) {
     s32 sp18[4];
 
-    // Whitespace matters for codegen here
-    sp18[1] = 240; sp18[3] = 320;
+    // clang-format off
+    sp18[1] = SCREEN_HEIGHT; sp18[3] = SCREEN_WIDTH;
     sp18[0] = 0; sp18[2] = 0;
+    // clang-format on
 
     func_800AA4FC(&interfaceCtx->view, sp18);
     func_800AB2C4(&interfaceCtx->view);
@@ -3598,13 +3115,8 @@ s16 sTimerDigitLeftPos[] = { 16, 25, 34, 42, 51 };
 s16 sDigitWidth[] = { 9, 9, 8, 9, 9 };
 
 // unused, most likely colors
-s16 D_80125B1C[][3] =
-{
-    { 0x00, 0x96, 0x00 },
-    { 0x64, 0xFF, 0x00 },
-    { 0xFF, 0xFF, 0xFF },
-    { 0x00, 0x00, 0x00 },
-    { 0xFF, 0xFF, 0xFF },
+s16 D_80125B1C[][3] = {
+    { 0x00, 0x96, 0x00 }, { 0x64, 0xFF, 0x00 }, { 0xFF, 0xFF, 0xFF }, { 0x00, 0x00, 0x00 }, { 0xFF, 0xFF, 0xFF },
 };
 
 s16 sRupeeDigitsFirst[] = { 1, 0, 0 };
@@ -3612,14 +3124,13 @@ s16 sRupeeDigitsCount[] = { 2, 3, 3 };
 
 s16 sSpoilingItemEntrances[] = { 0x01AD, 0x0153, 0x0153 };
 
-u16 D_80125B54 = 0xC220; // unused
-u16 D_80125B58 = 0xC20C; // unused
+u16 D_80125B54 = 0xC220;       // unused
+u16 D_80125B58 = 0xC20C;       // unused
 s16 D_80125B5C[] = { 91, 91 }; // unused
 
 #ifdef NON_MATCHING
 // mostly regalloc, minor ordering and stack usage differences
-void Interface_Draw(GlobalContext* globalCtx)
-{
+void Interface_Draw(GlobalContext* globalCtx) {
     static s16 D_8015FFE0;
     static s16 D_8015FFE2;
     static s16 D_8015FFE4;
@@ -3636,19 +3147,18 @@ void Interface_Draw(GlobalContext* globalCtx)
     s16 phi_s0;
     s16 sp274;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
     s32 pad;
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3405);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 3405);
 
     gSPSegment(gfxCtx->overlay.p++, 0x02, interfaceCtx->parameterSegment);
     gSPSegment(gfxCtx->overlay.p++, 0x07, interfaceCtx->do_actionSegment);
     gSPSegment(gfxCtx->overlay.p++, 0x08, interfaceCtx->icon_itemSegment);
     gSPSegment(gfxCtx->overlay.p++, 0x0B, interfaceCtx->mapSegment);
 
-    if (pauseCtx->flag == 0)
-    {
+    if (pauseCtx->flag == 0) {
         Interface_InitVertices(globalCtx);
         func_8008A994(interfaceCtx);
         Interface_DrawHealth(globalCtx);
@@ -3658,15 +3168,9 @@ void Interface_Draw(GlobalContext* globalCtx)
         // Rupee Icon
         gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xC8, 0xFF, 0x64, interfaceCtx->magicAlpha);
         gDPSetEnvColor(gfxCtx->overlay.p++, 0x00, 0x50, 0x00, 0xFF);
-        gfxCtx->overlay.p = Draw_TextureIA8(gfxCtx->overlay.p,
-                                            D_02001F00,
-                                            16, 16,
-                                            26, 206,
-                                            16, 16,
-                                            1024, 1024);
-
-        switch (globalCtx->sceneNum)
-        {
+        gfxCtx->overlay.p = Gfx_TextureIA8(gfxCtx->overlay.p, D_02001F00, 16, 16, 26, 206, 16, 16, 1024, 1024);
+
+        switch (globalCtx->sceneNum) {
             case SCENE_BMORI1:
             case SCENE_HIDAN:
             case SCENE_MIZUSIN:
@@ -3681,53 +3185,38 @@ void Interface_Draw(GlobalContext* globalCtx)
             case SCENE_GANON_SONOGO:
             case SCENE_GANONTIKA_SONOGO:
             case SCENE_TAKARAYA:
-                if (gSaveContext.dungeon_keys[gSaveContext.dungeon_index] >= 0)
-                {
+                if (gSaveContext.dungeon_keys[gSaveContext.dungeon_index] >= 0) {
                     // Small Key Icon
                     gDPPipeSync(gfxCtx->overlay.p++);
                     gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xC8, 0xE6, 0xFF, interfaceCtx->magicAlpha);
                     gDPSetEnvColor(gfxCtx->overlay.p++, 0x00, 0x00, 0x14, 0xFF);
-                    gfxCtx->overlay.p = Draw_TextureIA8(gfxCtx->overlay.p,
-                                                        D_02001E00,
-                                                        16, 16,
-                                                        26, 190,
-                                                        16, 16,
-                                                        1024, 1024);
+                    gfxCtx->overlay.p =
+                        Gfx_TextureIA8(gfxCtx->overlay.p, D_02001E00, 16, 16, 26, 190, 16, 16, 1024, 1024);
 
                     // Small Key Counter
                     gDPPipeSync(gfxCtx->overlay.p++);
                     gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFF, 0xFF, 0xFF, interfaceCtx->magicAlpha);
-                    gDPSetCombineLERP(gfxCtx->overlay.p++,
-                                      0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0,
-                                      0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0);
+                    gDPSetCombineLERP(gfxCtx->overlay.p++, 0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0, 0, 0, 0,
+                                      PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0);
 
                     interfaceCtx->counterDigits[2] = 0;
                     interfaceCtx->counterDigits[3] = gSaveContext.dungeon_keys[gSaveContext.dungeon_index];
 
-                    while (interfaceCtx->counterDigits[3] >= 10)
-                    {
+                    while (interfaceCtx->counterDigits[3] >= 10) {
                         interfaceCtx->counterDigits[2]++;
                         interfaceCtx->counterDigits[3] -= 10;
                     }
 
                     phi_s2 = 42;
-                    if (interfaceCtx->counterDigits[2] != 0)
-                    {
-                        gfxCtx->overlay.p = Draw_TextureI8(gfxCtx->overlay.p,
-                                                           &D_02003040[interfaceCtx->counterDigits[2]],
-                                                           8, 16,
-                                                           phi_s2, 190,
-                                                           8, 16,
-                                                           1024, 1024);
+                    if (interfaceCtx->counterDigits[2] != 0) {
+                        gfxCtx->overlay.p =
+                            Gfx_TextureI8(gfxCtx->overlay.p, &D_02003040[interfaceCtx->counterDigits[2]], 8, 16, phi_s2,
+                                          190, 8, 16, 1024, 1024);
                         phi_s2 = 50;
                     }
 
-                    gfxCtx->overlay.p = Draw_TextureI8(gfxCtx->overlay.p,
-                                                       &D_02003040[interfaceCtx->counterDigits[3]],
-                                                       8, 16,
-                                                       phi_s2, 190,
-                                                       8, 16,
-                                                       1024, 1024);
+                    gfxCtx->overlay.p = Gfx_TextureI8(gfxCtx->overlay.p, &D_02003040[interfaceCtx->counterDigits[3]], 8,
+                                                      16, phi_s2, 190, 8, 16, 1024, 1024);
                 }
 
                 phi_s2 = 42;
@@ -3742,31 +3231,30 @@ void Interface_Draw(GlobalContext* globalCtx)
         // Rupee Counter
         gDPPipeSync(gfxCtx->overlay.p++);
 
-        if (gSaveContext.rupees == CUR_CAPACITY(UPG_WALLET))
+        if (gSaveContext.rupees == CUR_CAPACITY(UPG_WALLET)) {
             gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0x78, 0xFF, 0x00, interfaceCtx->magicAlpha);
-        else if (gSaveContext.rupees != 0)
+        } else if (gSaveContext.rupees != 0) {
             gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFF, 0xFF, 0xFF, interfaceCtx->magicAlpha);
-        else
+        } else {
             gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0x64, 0x64, 0x64, interfaceCtx->magicAlpha);
+        }
 
-        gDPSetCombineLERP(gfxCtx->overlay.p++,
-                          0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0,
-                          0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0);
+        gDPSetCombineLERP(gfxCtx->overlay.p++, 0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0, 0, 0, 0, PRIMITIVE, TEXEL0,
+                          0, PRIMITIVE, 0);
 
         interfaceCtx->counterDigits[0] = interfaceCtx->counterDigits[1] = 0;
         interfaceCtx->counterDigits[2] = gSaveContext.rupees;
 
-        if ((interfaceCtx->counterDigits[2] >= 10000) || (interfaceCtx->counterDigits[2] < 0))
+        if ((interfaceCtx->counterDigits[2] >= 10000) || (interfaceCtx->counterDigits[2] < 0)) {
             interfaceCtx->counterDigits[2] &= 0xDDD;
+        }
 
-        while (interfaceCtx->counterDigits[2] >= 100)
-        {
+        while (interfaceCtx->counterDigits[2] >= 100) {
             interfaceCtx->counterDigits[2] -= 100;
             interfaceCtx->counterDigits[0]++;
         }
 
-        while (interfaceCtx->counterDigits[2] >= 10)
-        {
+        while (interfaceCtx->counterDigits[2] >= 10) {
             interfaceCtx->counterDigits[2] -= 10;
             interfaceCtx->counterDigits[1]++;
         }
@@ -3774,21 +3262,17 @@ void Interface_Draw(GlobalContext* globalCtx)
         phi_s0 = sRupeeDigitsFirst[CUR_UPG_VALUE(UPG_WALLET)];
         phi_s1 = sRupeeDigitsCount[CUR_UPG_VALUE(UPG_WALLET)];
 
-        for (phi_s3 = 0; phi_s3 < phi_s1; phi_s3++, phi_s0++, phi_s2 += 8)
-        {
-            gfxCtx->overlay.p = Draw_TextureI8(gfxCtx->overlay.p,
-                                               &D_02003040[interfaceCtx->counterDigits[phi_s0]],
-                                               8, 16,
-                                               phi_s2, 206,
-                                               8, 16,
-                                               1024, 1024);
+        for (phi_s3 = 0; phi_s3 < phi_s1; phi_s3++, phi_s0++, phi_s2 += 8) {
+            gfxCtx->overlay.p = Gfx_TextureI8(gfxCtx->overlay.p, &D_02003040[interfaceCtx->counterDigits[phi_s0]], 8,
+                                              16, phi_s2, 206, 8, 16, 1024, 1024);
         }
 
         Interface_DrawMagicBar(globalCtx);
         Interface_DrawMinimap(globalCtx);
 
-        if ((R_PAUSE_MENU_MODE != 2) && (R_PAUSE_MENU_MODE != 3))
+        if ((R_PAUSE_MENU_MODE != 2) && (R_PAUSE_MENU_MODE != 3)) {
             func_8002C124(&globalCtx->actorCtx.targetCtx, globalCtx); // Draw Z-Target
+        }
 
         func_80094520(globalCtx->state.gfxCtx);
 
@@ -3796,214 +3280,179 @@ void Interface_Draw(GlobalContext* globalCtx)
 
         gDPPipeSync(gfxCtx->overlay.p++);
         gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFF, 0xFF, 0xFF, interfaceCtx->bAlpha);
-        gDPSetCombineLERP(gfxCtx->overlay.p++,
-                         TEXEL0, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0,
-                         TEXEL0, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0);
+        gDPSetCombineMode(gfxCtx->overlay.p++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
 
-        if (interfaceCtx->unk_1FA == 0)
-        {
+        if (interfaceCtx->unk_1FA == 0) {
             // B Button Icon & possibly Ammo Count
-            if (gSaveContext.equips.button_items[0] != ITEM_NONE)
-            {
+            if (gSaveContext.equips.button_items[0] != ITEM_NONE) {
                 Interface_DrawItemIconTexture(globalCtx, (void*)(u32)interfaceCtx->icon_itemSegment, 0);
 
                 if ((player->stateFlags1 & 0x00800000) || (globalCtx->unk_11E5C >= 2) ||
-                    ((globalCtx->sceneNum == SCENE_BOWLING) && Flags_GetSwitch(globalCtx, 0x38)))
-                {
+                    ((globalCtx->sceneNum == SCENE_BOWLING) && Flags_GetSwitch(globalCtx, 0x38))) {
                     gDPPipeSync(gfxCtx->overlay.p++);
-                    gDPSetCombineLERP(gfxCtx->overlay.p++,
-                                      PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
-                                      PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
+                    gDPSetCombineLERP(gfxCtx->overlay.p++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0,
+                                      PRIMITIVE, 0, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE,
+                                      0);
                     Interface_DrawAmmoCount(globalCtx, 0, interfaceCtx->bAlpha);
                 }
             }
-        }
-        else
-        {
+        } else {
             // B Button Do Action Label
             gDPPipeSync(gfxCtx->overlay.p++);
-            gDPSetCombineLERP(gfxCtx->overlay.p++,
-                              PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
+            gDPSetCombineLERP(gfxCtx->overlay.p++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
                               PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
             gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFF, 0xFF, 0xFF, interfaceCtx->bAlpha);
 
-            gDPSetTextureImage(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 1, (u32)interfaceCtx->do_actionSegment + 0x180);
-            gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b,
-                       0, 0x0000, G_TX_LOADTILE, 0,
-                       G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-                       G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+            gDPSetTextureImage(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 1,
+                               (u32)interfaceCtx->do_actionSegment + 0x180);
+            gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 0, 0x0000, G_TX_LOADTILE, 0,
+                       G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK,
+                       G_TX_NOLOD);
             gDPLoadSync(gfxCtx->overlay.p++);
             gDPLoadBlock(gfxCtx->overlay.p++, G_TX_LOADTILE, 0, 0, 191, 683);
             gDPPipeSync(gfxCtx->overlay.p++);
-            gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_4b,
-                       3, 0x0000, G_TX_RENDERTILE, 0,
-                       G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-                       G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+            gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_4b, 3, 0x0000, G_TX_RENDERTILE, 0,
+                       G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK,
+                       G_TX_NOLOD);
             gDPSetTileSize(gfxCtx->overlay.p++, G_TX_RENDERTILE, 0, 0, 188, 60);
 
             R_B_LABEL_DD = 1024.0f / (WREG(37 + gSaveContext.language) / 100.0f);
-            gSPTextureRectangle(gfxCtx->overlay.p++,
-                                R_B_LABEL_X(gSaveContext.language) << 2, R_B_LABEL_Y(gSaveContext.language) << 2,
-                                (R_B_LABEL_X(gSaveContext.language) + 48) << 2, R_B_LABEL_Y(gSaveContext.language) << 2,
-                                G_TX_RENDERTILE,
-                                0, 0,
-                                R_B_LABEL_DD, R_B_LABEL_DD);
+            gSPTextureRectangle(gfxCtx->overlay.p++, R_B_LABEL_X(gSaveContext.language) << 2,
+                                R_B_LABEL_Y(gSaveContext.language) << 2, (R_B_LABEL_X(gSaveContext.language) + 48) << 2,
+                                R_B_LABEL_Y(gSaveContext.language) << 2, G_TX_RENDERTILE, 0, 0, R_B_LABEL_DD,
+                                R_B_LABEL_DD);
         }
 
         gDPPipeSync(gfxCtx->overlay.p++);
 
         // C-Left Button Icon & Ammo Count
-        if (gSaveContext.equips.button_items[1] < 0xF0)
-        {
+        if (gSaveContext.equips.button_items[1] < 0xF0) {
             gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFF, 0xFF, 0xFF, interfaceCtx->cLeftAlpha);
-            gDPSetCombineLERP(gfxCtx->overlay.p++,
-                              TEXEL0, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0,
-                              TEXEL0, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0);
+            gDPSetCombineMode(gfxCtx->overlay.p++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
             Interface_DrawItemIconTexture(globalCtx, (void*)((u32)interfaceCtx->icon_itemSegment + 0x1000), 1);
             gDPPipeSync(gfxCtx->overlay.p++);
-            gDPSetCombineLERP(gfxCtx->overlay.p++,
-                               PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
-                               PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
+            gDPSetCombineLERP(gfxCtx->overlay.p++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
+                              PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
             Interface_DrawAmmoCount(globalCtx, 1, interfaceCtx->cLeftAlpha);
         }
 
         gDPPipeSync(gfxCtx->overlay.p++);
 
         // C-Down Button Icon & Ammo Count
-        if (gSaveContext.equips.button_items[2] < 0xF0)
-        {
+        if (gSaveContext.equips.button_items[2] < 0xF0) {
             gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFF, 0xFF, 0xFF, interfaceCtx->cDownAlpha);
-            gDPSetCombineLERP(gfxCtx->overlay.p++,
-                              TEXEL0, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0,
-                              TEXEL0, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0);
+            gDPSetCombineMode(gfxCtx->overlay.p++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
             Interface_DrawItemIconTexture(globalCtx, (void*)((u32)interfaceCtx->icon_itemSegment + 0x2000), 2);
             gDPPipeSync(gfxCtx->overlay.p++);
-            gDPSetCombineLERP(gfxCtx->overlay.p++,
-                               PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
-                               PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
+            gDPSetCombineLERP(gfxCtx->overlay.p++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
+                              PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
             Interface_DrawAmmoCount(globalCtx, 2, interfaceCtx->cDownAlpha);
         }
 
         gDPPipeSync(gfxCtx->overlay.p++);
 
         // C-Right Button Icon & Ammo Count
-        if (gSaveContext.equips.button_items[3] < 0xF0)
-        {
+        if (gSaveContext.equips.button_items[3] < 0xF0) {
             gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFF, 0xFF, 0xFF, interfaceCtx->cRightAlpha);
-            gDPSetCombineLERP(gfxCtx->overlay.p++,
-                              TEXEL0, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0,
-                              TEXEL0, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0);
+            gDPSetCombineMode(gfxCtx->overlay.p++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
             Interface_DrawItemIconTexture(globalCtx, (void*)((u32)interfaceCtx->icon_itemSegment + 0x3000), 3);
             gDPPipeSync(gfxCtx->overlay.p++);
-            gDPSetCombineLERP(gfxCtx->overlay.p++,
-                               PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
-                               PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
+            gDPSetCombineLERP(gfxCtx->overlay.p++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
+                              PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
             Interface_DrawAmmoCount(globalCtx, 3, interfaceCtx->cRightAlpha);
         }
 
         // A Button
         func_80094A14(globalCtx->state.gfxCtx);
-        func_8008A8B8(globalCtx,
-                      R_A_BTN_Y, R_A_BTN_Y + 45,
-                      R_A_BTN_X, R_A_BTN_X + 45);
+        func_8008A8B8(globalCtx, R_A_BTN_Y, R_A_BTN_Y + 45, R_A_BTN_X, R_A_BTN_X + 45);
         gSPClearGeometryMode(gfxCtx->overlay.p++, G_CULL_BOTH);
-        gDPSetCombineLERP(gfxCtx->overlay.p++,
-                          TEXEL0, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0,
-                          TEXEL0, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0);
-        gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                        R_A_BTN_COLOR(0), R_A_BTN_COLOR(1),
-                        R_A_BTN_COLOR(2), interfaceCtx->aAlpha);
+        gDPSetCombineMode(gfxCtx->overlay.p++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
+        gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, R_A_BTN_COLOR(0), R_A_BTN_COLOR(1), R_A_BTN_COLOR(2),
+                        interfaceCtx->aAlpha);
         Interface_DrawActionButton(globalCtx);
         gDPPipeSync(gfxCtx->overlay.p++);
-        func_8008A8B8(globalCtx,
-                      R_A_ICON_Y, R_A_ICON_Y + 45,
-                      R_A_ICON_X, R_A_ICON_X + 45);
+        func_8008A8B8(globalCtx, R_A_ICON_Y, R_A_ICON_Y + 45, R_A_ICON_X, R_A_ICON_X + 45);
         gSPSetGeometryMode(gfxCtx->overlay.p++, G_CULL_BACK);
-        gDPSetCombineLERP(gfxCtx->overlay.p++,
-                          PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
+        gDPSetCombineLERP(gfxCtx->overlay.p++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
                           PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
         gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFF, 0xFF, 0xFF, interfaceCtx->aAlpha);
         gDPSetEnvColor(gfxCtx->overlay.p++, 0x00, 0x00, 0x00, 0x00);
         Matrix_Translate(0.0f, 0.0f, WREG(46 + gSaveContext.language) / 10.0f, MTXMODE_NEW);
         Matrix_Scale(1.0f, 1.0f, 1.0f, MTXMODE_APPLY);
         Matrix_RotateX(interfaceCtx->unk_1F4 / 10000.0f, MTXMODE_APPLY);
-        gSPMatrix(gfxCtx->overlay.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_parameter.c", 3701), G_MTX_MODELVIEW | G_MTX_LOAD);
+        gSPMatrix(gfxCtx->overlay.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_parameter.c", 3701),
+                  G_MTX_MODELVIEW | G_MTX_LOAD);
         gSPVertex(gfxCtx->overlay.p++, &interfaceCtx->vtx_128[4], 4, 0);
 
-        if ((interfaceCtx->unk_1EC < 2) || (interfaceCtx->unk_1EC == 3))
+        if ((interfaceCtx->unk_1EC < 2) || (interfaceCtx->unk_1EC == 3)) {
             Interface_DrawActionLabel(globalCtx->state.gfxCtx, (void*)(u32)interfaceCtx->do_actionSegment);
-        else
+        } else {
             Interface_DrawActionLabel(globalCtx->state.gfxCtx, (void*)((u32)interfaceCtx->do_actionSegment + 0x180));
+        }
 
         gDPPipeSync(gfxCtx->overlay.p++);
 
         func_8008A994(interfaceCtx);
 
-        if ((pauseCtx->state == 6) && (pauseCtx->unk_1E4 == 3))
-        {
+        if ((pauseCtx->state == 6) && (pauseCtx->unk_1E4 == 3)) {
             // Inventory Equip Effects
             gSPSegment(gfxCtx->overlay.p++, 0x08, pauseCtx->unk_128);
             func_80094A14(globalCtx->state.gfxCtx);
-            gDPSetCombineLERP(gfxCtx->overlay.p++,
-                              TEXEL0, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0,
-                              TEXEL0, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0);
+            gDPSetCombineMode(gfxCtx->overlay.p++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
             gSPMatrix(gfxCtx->overlay.p++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
 
             pauseCtx->vtx_168[16].v.ob[0] = pauseCtx->vtx_168[18].v.ob[0] = pauseCtx->unk_254 / 10;
-            pauseCtx->vtx_168[17].v.ob[0] = pauseCtx->vtx_168[19].v.ob[0] = pauseCtx->vtx_168[16].v.ob[0] + WREG(90) / 10;
+            pauseCtx->vtx_168[17].v.ob[0] = pauseCtx->vtx_168[19].v.ob[0] =
+                pauseCtx->vtx_168[16].v.ob[0] + WREG(90) / 10;
             pauseCtx->vtx_168[16].v.ob[1] = pauseCtx->vtx_168[17].v.ob[1] = pauseCtx->unk_256 / 10;
-            pauseCtx->vtx_168[18].v.ob[1] = pauseCtx->vtx_168[19].v.ob[1] = pauseCtx->vtx_168[16].v.ob[1] - WREG(90) / 10;
+            pauseCtx->vtx_168[18].v.ob[1] = pauseCtx->vtx_168[19].v.ob[1] =
+                pauseCtx->vtx_168[16].v.ob[1] - WREG(90) / 10;
 
-            if (pauseCtx->unk_24E < 0xBF)
-            {
+            if (pauseCtx->unk_24E < 0xBF) {
                 // Normal Equip (icon goes from the inventory slot to the C button when equipping it)
                 gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFF, 0xFF, 0xFF, pauseCtx->unk_258);
                 gSPVertex(gfxCtx->overlay.p++, &pauseCtx->vtx_168[16], 4, 0);
 
                 gDPSetTextureImage(gfxCtx->overlay.p++, G_IM_FMT_RGBA, G_IM_SIZ_32b, 1, gItemIcons[pauseCtx->unk_24E]);
-                gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_RGBA, G_IM_SIZ_32b,
-                           0, 0x0000, G_TX_LOADTILE, 0,
-                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+                gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_RGBA, G_IM_SIZ_32b, 0, 0x0000, G_TX_LOADTILE, 0,
+                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK,
+                           G_TX_NOLOD);
                 gDPLoadSync(gfxCtx->overlay.p++);
                 gDPLoadBlock(gfxCtx->overlay.p++, G_TX_LOADTILE, 0, 0, 1023, 128);
                 gDPPipeSync(gfxCtx->overlay.p++);
-                gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_RGBA, G_IM_SIZ_32b,
-                           8, 0x0000, G_TX_RENDERTILE, 0,
-                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+                gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_RGBA, G_IM_SIZ_32b, 8, 0x0000, G_TX_RENDERTILE, 0,
+                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK,
+                           G_TX_NOLOD);
                 gDPSetTileSize(gfxCtx->overlay.p++, G_TX_RENDERTILE, 0, 0, 124, 124);
-            }
-            else
-            {
+            } else {
                 // Magic Arrow Equip Effect
                 phi_s3_2 = pauseCtx->unk_24E - 0xBF;
-                gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0,
-                                sMagicArrowEffectsR[phi_s3_2], sMagicArrowEffectsG[phi_s3_2],
+                gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, sMagicArrowEffectsR[phi_s3_2], sMagicArrowEffectsG[phi_s3_2],
                                 sMagicArrowEffectsB[phi_s3_2], pauseCtx->unk_258);
 
-                if ((pauseCtx->unk_258 > 0) && (pauseCtx->unk_258 < 0xFF))
-                {
+                if ((pauseCtx->unk_258 > 0) && (pauseCtx->unk_258 < 0xFF)) {
                     phi_s3_2 = (pauseCtx->unk_258 / 8) / 2;
-                    pauseCtx->vtx_168[16].v.ob[0] = pauseCtx->vtx_168[18].v.ob[0] = pauseCtx->vtx_168[16].v.ob[0] - phi_s3_2;
-                    pauseCtx->vtx_168[17].v.ob[0] = pauseCtx->vtx_168[19].v.ob[0] = pauseCtx->vtx_168[16].v.ob[0] + phi_s3_2 * 2 + 32;
-                    pauseCtx->vtx_168[16].v.ob[1] = pauseCtx->vtx_168[17].v.ob[1] = pauseCtx->vtx_168[16].v.ob[1] + phi_s3_2;
-                    pauseCtx->vtx_168[18].v.ob[1] = pauseCtx->vtx_168[19].v.ob[1] = pauseCtx->vtx_168[16].v.ob[1] - phi_s3_2 * 2 - 32;
+                    pauseCtx->vtx_168[16].v.ob[0] = pauseCtx->vtx_168[18].v.ob[0] =
+                        pauseCtx->vtx_168[16].v.ob[0] - phi_s3_2;
+                    pauseCtx->vtx_168[17].v.ob[0] = pauseCtx->vtx_168[19].v.ob[0] =
+                        pauseCtx->vtx_168[16].v.ob[0] + phi_s3_2 * 2 + 32;
+                    pauseCtx->vtx_168[16].v.ob[1] = pauseCtx->vtx_168[17].v.ob[1] =
+                        pauseCtx->vtx_168[16].v.ob[1] + phi_s3_2;
+                    pauseCtx->vtx_168[18].v.ob[1] = pauseCtx->vtx_168[19].v.ob[1] =
+                        pauseCtx->vtx_168[16].v.ob[1] - phi_s3_2 * 2 - 32;
                 }
 
                 gSPVertex(gfxCtx->overlay.p++, &pauseCtx->vtx_168[16], 4, 0);
                 gDPSetTextureImage(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 1, D_080895C0);
-                gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b,
-                           0, 0x0000, G_TX_LOADTILE, 0,
-                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+                gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 0, 0x0000, G_TX_LOADTILE, 0,
+                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK,
+                           G_TX_NOLOD);
                 gDPLoadSync(gfxCtx->overlay.p++);
                 gDPLoadBlock(gfxCtx->overlay.p++, G_TX_LOADTILE, 0, 0, 511, 512);
                 gDPPipeSync(gfxCtx->overlay.p++);
-                gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_8b,
-                           4, 0x0000, G_TX_RENDERTILE, 0,
-                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+                gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_8b, 4, 0x0000, G_TX_RENDERTILE, 0,
+                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK,
+                           G_TX_NOLOD);
                 gDPSetTileSize(gfxCtx->overlay.p++, G_TX_RENDERTILE, 0, 0, 124, 124);
             }
 
@@ -4012,108 +3461,81 @@ void Interface_Draw(GlobalContext* globalCtx)
 
         func_80094520(globalCtx->state.gfxCtx);
 
-        if ((globalCtx->pauseCtx.state == 0) && (globalCtx->pauseCtx.flag == 0))
-        {
-            if (gSaveContext.minigame_state != 1)
-            {
+        if ((globalCtx->pauseCtx.state == 0) && (globalCtx->pauseCtx.flag == 0)) {
+            if (gSaveContext.minigame_state != 1) {
                 // Carrots rendering if the action corresponds to riding a horse
-                if (interfaceCtx->unk_1EE == 8)
-                {
+                if (interfaceCtx->unk_1EE == 8) {
                     // Load Carrot Icon
                     gDPSetTextureImage(gfxCtx->overlay.p++, G_IM_FMT_RGBA, G_IM_SIZ_32b, 1, &D_02002100);
-                    gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_RGBA, G_IM_SIZ_32b,
-                               0, 0x0000, G_TX_LOADTILE, 0,
-                               G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-                               G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+                    gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_RGBA, G_IM_SIZ_32b, 0, 0x0000, G_TX_LOADTILE, 0,
+                               G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP,
+                               G_TX_NOMASK, G_TX_NOLOD);
                     gDPLoadSync(gfxCtx->overlay.p++);
                     gDPLoadBlock(gfxCtx->overlay.p++, G_TX_LOADTILE, 0, 0, 255, 256);
                     gDPPipeSync(gfxCtx->overlay.p++);
-                    gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_RGBA, G_IM_SIZ_32b,
-                               4, 0x0000, G_TX_RENDERTILE, 0,
-                               G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-                               G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+                    gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_RGBA, G_IM_SIZ_32b, 4, 0x0000, G_TX_RENDERTILE, 0,
+                               G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP,
+                               G_TX_NOMASK, G_TX_NOLOD);
                     gDPSetTileSize(gfxCtx->overlay.p++, G_TX_RENDERTILE, 0, 0, 60, 60);
 
                     // Draw 6 carrots
                     phi_s1 = ZREG(14);
-                    for (phi_s3 = 1; phi_s3 < 7; phi_s3++)
-                    {
+                    for (phi_s3 = 1; phi_s3 < 7; phi_s3++) {
                         // Carrot Color (based on availability)
-                        if ((interfaceCtx->unk_23A == 0) || (interfaceCtx->unk_23A < phi_s3))
+                        if ((interfaceCtx->unk_23A == 0) || (interfaceCtx->unk_23A < phi_s3)) {
                             gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0x00, 0x96, 0xFF, interfaceCtx->aAlpha);
-                        else
+                        } else {
                             gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFF, 0xFF, 0xFF, interfaceCtx->aAlpha);
+                        }
 
-                        gSPTextureRectangle(gfxCtx->overlay.p++,
-                                            phi_s1 << 2, ZREG(15) << 2,
-                                            (phi_s1 + 16) << 2, (ZREG(15) + 16) << 2,
-                                            G_TX_RENDERTILE,
-                                            0, 0,
-                                            1024, 1024);
+                        gSPTextureRectangle(gfxCtx->overlay.p++, phi_s1 << 2, ZREG(15) << 2, (phi_s1 + 16) << 2,
+                                            (ZREG(15) + 16) << 2, G_TX_RENDERTILE, 0, 0, 1024, 1024);
 
                         phi_s1 += 16;
                     }
                 }
-            }
-            else
-            {
+            } else {
                 // Score for the Horseback Archery
                 gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFF, 0xFF, 0xFF, interfaceCtx->bAlpha);
 
                 // Target Icon
                 gDPSetTextureImage(gfxCtx->overlay.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, D_02002600);
-                gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b,
-                           0, 0x0000, G_TX_LOADTILE, 0,
-                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+                gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, 0, 0x0000, G_TX_LOADTILE, 0,
+                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK,
+                           G_TX_NOLOD);
                 gDPLoadSync(gfxCtx->overlay.p++);
                 gDPLoadBlock(gfxCtx->overlay.p++, G_TX_LOADTILE, 0, 0, 383, 342);
                 gDPPipeSync(gfxCtx->overlay.p++);
-                gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b,
-                           6, 0x0000, G_TX_RENDERTILE, 0,
-                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD,
-                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
+                gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, 6, 0x0000, G_TX_RENDERTILE, 0,
+                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK,
+                           G_TX_NOLOD);
                 gDPSetTileSize(gfxCtx->overlay.p++, G_TX_RENDERTILE, 0, 0, 92, 60);
 
-                gSPTextureRectangle(gfxCtx->overlay.p++,
-                                    (WREG(32) + 28) << 2, ZREG(15) << 2,
-                                    (WREG(32) + 52) << 2, (ZREG(15) + 16) << 2,
-                                    G_TX_RENDERTILE,
-                                    0, 0,
-                                    1024, 1024);
+                gSPTextureRectangle(gfxCtx->overlay.p++, (WREG(32) + 28) << 2, ZREG(15) << 2, (WREG(32) + 52) << 2,
+                                    (ZREG(15) + 16) << 2, G_TX_RENDERTILE, 0, 0, 1024, 1024);
 
                 // Score Counter
                 gDPPipeSync(gfxCtx->overlay.p++);
-                gDPSetCombineLERP(gfxCtx->overlay.p++,
-                                  0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0,
-                                  0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0);
+                gDPSetCombineMode(gfxCtx->overlay.p++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
 
                 phi_s0 = 0;
                 phi_s1 = WREG(32) + 6 * 9;
-                for (phi_s3 = 0; phi_s3 < 4; phi_s3++)
-                {
-                    if (sHBAScoreDigits[phi_s3] != 0 || (phi_s0 != 0) || (phi_s3 >= 3))
-                    {
-                        gfxCtx->overlay.p = Draw_TextureI8(gfxCtx->overlay.p,
-                                                           &D_02003040[sHBAScoreDigits[phi_s3]],
-                                                           8, 16,
-                                                           phi_s1, ZREG(15) - 2,
-                                                           sDigitWidth[0], VREG(42),
-                                                           VREG(43) * 2, VREG(43) * 2);
+                for (phi_s3 = 0; phi_s3 < 4; phi_s3++) {
+                    if (sHBAScoreDigits[phi_s3] != 0 || (phi_s0 != 0) || (phi_s3 >= 3)) {
+                        gfxCtx->overlay.p =
+                            Gfx_TextureI8(gfxCtx->overlay.p, &D_02003040[sHBAScoreDigits[phi_s3]], 8, 16, phi_s1,
+                                          ZREG(15) - 2, sDigitWidth[0], VREG(42), VREG(43) * 2, VREG(43) * 2);
                         phi_s1 += 9;
                         phi_s0++;
                     }
                 }
 
                 gDPPipeSync(gfxCtx->overlay.p++);
-                gDPSetCombineLERP(gfxCtx->overlay.p++,
-                                  TEXEL0, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0,
-                                  TEXEL0, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0);
+                gDPSetCombineMode(gfxCtx->overlay.p++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
             }
         }
 
-        if ((gSaveContext.timer_2_state == 5) && (func_8010BDBC(&globalCtx->msgCtx) == 5))
-        {
+        if ((gSaveContext.timer_2_state == 5) && (func_8010BDBC(&globalCtx->msgCtx) == 5)) {
             // Trade quest timer reached 0
             gSaveContext.cutscene_index = 0;
             globalCtx->sceneLoadFlag = 0x14;
@@ -4124,28 +3546,24 @@ void Interface_Draw(GlobalContext* globalCtx)
             if ((gSaveContext.equips.button_items[0] != ITEM_SWORD_KOKIRI) &&
                 (gSaveContext.equips.button_items[0] != ITEM_SWORD_MASTER) &&
                 (gSaveContext.equips.button_items[0] != ITEM_SWORD_BGS) &&
-                (gSaveContext.equips.button_items[0] != ITEM_SWORD_KNIFE))
-            {
-                if (gSaveContext.button_status[0] != BTN_ENABLED)
+                (gSaveContext.equips.button_items[0] != ITEM_SWORD_KNIFE)) {
+                if (gSaveContext.button_status[0] != BTN_ENABLED) {
                     gSaveContext.equips.button_items[0] = gSaveContext.button_status[0];
-                else
+                } else {
                     gSaveContext.equips.button_items[0] = ITEM_NONE;
+                }
             }
 
             // Revert any spoiling trade quest items
-            for (phi_s3 = 0; phi_s3 < ARRAY_COUNT(gSpoilingItems); phi_s3++)
-            {
-                if (INV_CONTENT(ITEM_POCKET_EGG) == gSpoilingItems[phi_s3])
-                {
+            for (phi_s3 = 0; phi_s3 < ARRAY_COUNT(gSpoilingItems); phi_s3++) {
+                if (INV_CONTENT(ITEM_POCKET_EGG) == gSpoilingItems[phi_s3]) {
                     gSaveContext.event_inf[0] &= 0x7F80;
                     osSyncPrintf("EVENT_INF=%x\n", gSaveContext.event_inf[0]);
                     globalCtx->nextEntranceIndex = sSpoilingItemEntrances[phi_s3];
                     INV_CONTENT(gSpoilingItemReverts[phi_s3]) = gSpoilingItemReverts[phi_s3];
 
-                    for (phi_s0 = 1; phi_s0 < 4; phi_s0++)
-                    {
-                        if (gSaveContext.equips.button_items[phi_s0] == gSpoilingItems[phi_s3])
-                        {
+                    for (phi_s0 = 1; phi_s0 < 4; phi_s0++) {
+                        if (gSaveContext.equips.button_items[phi_s0] == gSpoilingItems[phi_s3]) {
                             gSaveContext.equips.button_items[phi_s0] = gSpoilingItemReverts[phi_s3];
                             Interface_LoadItemIcon1(globalCtx, phi_s0);
                         }
@@ -4154,21 +3572,13 @@ void Interface_Draw(GlobalContext* globalCtx)
             }
         }
 
-        if ((globalCtx->pauseCtx.state == 0) &&
-            (globalCtx->pauseCtx.flag == 0) &&
-            (globalCtx->unk_10A20 == 0) &&
-            (msgCtx->msgMode == 0) &&
-            !(player->stateFlags2 & 0x01000000) &&
-            (globalCtx->sceneLoadFlag == 0) &&
-            (globalCtx->unk_1241B == 0) &&
-            (func_800BFC84(globalCtx) == 0) &&
-            (gSaveContext.minigame_state != 1) &&
+        if ((globalCtx->pauseCtx.state == 0) && (globalCtx->pauseCtx.flag == 0) && (globalCtx->unk_10A20 == 0) &&
+            (msgCtx->msgMode == 0) && !(player->stateFlags2 & 0x01000000) && (globalCtx->sceneLoadFlag == 0) &&
+            (globalCtx->unk_1241B == 0) && (func_800BFC84(globalCtx) == 0) && (gSaveContext.minigame_state != 1) &&
             (globalCtx->unk_11E5C < 2) &&
-            !((globalCtx->sceneNum == SCENE_BOWLING) && Flags_GetSwitch(globalCtx, 0x38)))
-        {
+            !((globalCtx->sceneNum == SCENE_BOWLING) && Flags_GetSwitch(globalCtx, 0x38))) {
             sp274 = 0;
-            switch (gSaveContext.timer_1_state)
-            {
+            switch (gSaveContext.timer_1_state) {
                 case 1:
                     gSaveContext.timer_1_state = 2;
                     gSaveContext.timer_1_value = gSaveContext.health >> 1;
@@ -4176,8 +3586,7 @@ void Interface_Draw(GlobalContext* globalCtx)
                     break;
                 case 2:
                     D_8015FFE2--;
-                    if (D_8015FFE2 == 0)
-                    {
+                    if (D_8015FFE2 == 0) {
                         gSaveContext.timer_1_state = 3;
                         D_8015FFE2 = 20;
                     }
@@ -4185,21 +3594,22 @@ void Interface_Draw(GlobalContext* globalCtx)
                 case 5:
                 case 11:
                     D_8015FFE0 = D_8015FFE2 = 20;
-                    if (gSaveContext.timer_1_state == 5)
+                    if (gSaveContext.timer_1_state == 5) {
                         gSaveContext.timer_1_state = 6;
-                    else
+                    } else {
                         gSaveContext.timer_1_state = 12;
+                    }
                     break;
                 case 6:
                 case 12:
                     D_8015FFE2--;
-                    if (D_8015FFE2 == 0)
-                    {
+                    if (D_8015FFE2 == 0) {
                         D_8015FFE2 = 20;
-                        if (gSaveContext.timer_1_state == 6)
+                        if (gSaveContext.timer_1_state == 6) {
                             gSaveContext.timer_1_state = 7;
-                        else
+                        } else {
                             gSaveContext.timer_1_state = 13;
+                        }
                     }
                     break;
                 case 3:
@@ -4207,71 +3617,69 @@ void Interface_Draw(GlobalContext* globalCtx)
                     phi_s3 = (gSaveContext.timer_x[0] - 26) / D_8015FFE2;
                     gSaveContext.timer_x[0] -= phi_s3;
 
-                    if (gSaveContext.health_capacity > 0xA0)
+                    if (gSaveContext.health_capacity > 0xA0) {
                         phi_s3 = (gSaveContext.timer_y[0] - 54) / D_8015FFE2;
-                    else
+                    } else {
                         phi_s3 = (gSaveContext.timer_y[0] - 46) / D_8015FFE2;
+                    }
                     gSaveContext.timer_y[0] -= phi_s3;
 
                     D_8015FFE2--;
-                    if (D_8015FFE2 == 0)
-                    {
+                    if (D_8015FFE2 == 0) {
                         gSaveContext.timer_x[0] = 26;
                         D_8015FFE2 = 20;
 
-                        if (gSaveContext.health_capacity > 0xA0)
+                        if (gSaveContext.health_capacity > 0xA0) {
                             gSaveContext.timer_y[0] = 54;
-                        else
+                        } else {
                             gSaveContext.timer_y[0] = 46;
+                        }
 
-                        if (gSaveContext.timer_1_state == 3)
+                        if (gSaveContext.timer_1_state == 3) {
                             gSaveContext.timer_1_state = 4;
-                        else
+                        } else {
                             gSaveContext.timer_1_state = 8;
+                        }
                     }
                 case 4:
                 case 8:
-                    if ((gSaveContext.timer_1_state == 4) || (gSaveContext.timer_1_state == 8))
-                    {
-                        if (gSaveContext.health_capacity > 0xA0)
+                    if ((gSaveContext.timer_1_state == 4) || (gSaveContext.timer_1_state == 8)) {
+                        if (gSaveContext.health_capacity > 0xA0) {
                             gSaveContext.timer_y[0] = 54;
-                        else
+                        } else {
                             gSaveContext.timer_y[0] = 46;
+                        }
                     }
 
-                    if ((gSaveContext.timer_1_state >= 3) && (msgCtx->unk_E300 == 0))
-                    {
+                    if ((gSaveContext.timer_1_state >= 3) && (msgCtx->unk_E300 == 0)) {
                         D_8015FFE0--;
-                        if (D_8015FFE0 == 0)
-                        {
-                            if (gSaveContext.timer_1_value != 0)
+                        if (D_8015FFE0 == 0) {
+                            if (gSaveContext.timer_1_value != 0) {
                                 gSaveContext.timer_1_value--;
+                            }
 
                             D_8015FFE0 = 20;
 
-                            if (gSaveContext.timer_1_value == 0)
-                            {
+                            if (gSaveContext.timer_1_value == 0) {
                                 gSaveContext.timer_1_state = 10;
-                                if (D_80125A5C != 0)
-                                {
+                                if (D_80125A5C != 0) {
                                     gSaveContext.health = 0;
                                     globalCtx->unk_11D58(globalCtx, -(gSaveContext.health + 2));
                                 }
                                 D_80125A5C = 0;
-                            }
-                            else if (gSaveContext.timer_1_value > 60)
-                            {
-                                if (sTimerDigits[4] == 1)
-                                    Audio_PlaySoundGeneral(NA_SE_SY_MESSAGE_WOMAN, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
-                            }
-                            else if (gSaveContext.timer_1_value >= 11)
-                            {
-                                if (sTimerDigits[4] & 1)
-                                    Audio_PlaySoundGeneral(NA_SE_SY_WARNING_COUNT_N, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
-                            }
-                            else
-                            {
-                                Audio_PlaySoundGeneral(NA_SE_SY_WARNING_COUNT_E, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
+                            } else if (gSaveContext.timer_1_value > 60) {
+                                if (sTimerDigits[4] == 1) {
+                                    Audio_PlaySoundGeneral(NA_SE_SY_MESSAGE_WOMAN, &D_801333D4, 4, &D_801333E0,
+                                                           &D_801333E0, &D_801333E8);
+                                }
+                            } else if (gSaveContext.timer_1_value >= 11) {
+                                if (sTimerDigits[4] & 1) {
+                                    Audio_PlaySoundGeneral(NA_SE_SY_WARNING_COUNT_N, &D_801333D4, 4, &D_801333E0,
+                                                           &D_801333E0, &D_801333E8);
+                                }
+                            } else {
+                                Audio_PlaySoundGeneral(NA_SE_SY_WARNING_COUNT_E, &D_801333D4, 4, &D_801333E0,
+                                                       &D_801333E0, &D_801333E8);
                             }
                         }
                     }
@@ -4280,70 +3688,65 @@ void Interface_Draw(GlobalContext* globalCtx)
                     phi_s3 = (gSaveContext.timer_x[0] - 26) / D_8015FFE2;
                     gSaveContext.timer_x[0] -= phi_s3;
 
-                    if (gSaveContext.health_capacity > 0xA0)
+                    if (gSaveContext.health_capacity > 0xA0) {
                         phi_s3 = (gSaveContext.timer_y[0] - 54) / D_8015FFE2;
-                    else
+                    } else {
                         phi_s3 = (gSaveContext.timer_y[0] - 46) / D_8015FFE2;
+                    }
                     gSaveContext.timer_y[0] -= phi_s3;
 
                     D_8015FFE2--;
-                    if (D_8015FFE2 == 0)
-                    {
+                    if (D_8015FFE2 == 0) {
                         gSaveContext.timer_x[0] = 26;
                         D_8015FFE2 = 20;
 
-                        if (gSaveContext.health_capacity > 0xA0)
+                        if (gSaveContext.health_capacity > 0xA0) {
                             gSaveContext.timer_y[0] = 54;
-                        else
+                        } else {
                             gSaveContext.timer_y[0] = 46;
+                        }
 
                         gSaveContext.timer_1_state = 14;
                     }
                 case 14:
-                    if (gSaveContext.timer_1_state == 14)
-                    {
-                        if (gSaveContext.health_capacity > 0xA0)
+                    if (gSaveContext.timer_1_state == 14) {
+                        if (gSaveContext.health_capacity > 0xA0) {
                             gSaveContext.timer_y[0] = 54;
-                        else
+                        } else {
                             gSaveContext.timer_y[0] = 46;
+                        }
                     }
 
-                    if (gSaveContext.timer_1_state >= 3)
-                    {
+                    if (gSaveContext.timer_1_state >= 3) {
                         D_8015FFE0--;
-                        if (D_8015FFE0 == 0)
-                        {
+                        if (D_8015FFE0 == 0) {
                             gSaveContext.timer_1_value++;
                             D_8015FFE0 = 20;
 
-                            if (gSaveContext.timer_1_value == 3599)
-                            {
+                            if (gSaveContext.timer_1_value == 3599) {
                                 gSaveContext.timer_1_state = 15;
                                 D_8015FFE2 = 40;
-                            }
-                            else
-                            {
-                                Audio_PlaySoundGeneral(NA_SE_SY_WARNING_COUNT_N, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
+                            } else {
+                                Audio_PlaySoundGeneral(NA_SE_SY_WARNING_COUNT_N, &D_801333D4, 4, &D_801333E0,
+                                                       &D_801333E0, &D_801333E8);
                             }
                         }
                     }
                     break;
                 case 10:
-                    if (gSaveContext.timer_2_state != 0)
-                    {
+                    if (gSaveContext.timer_2_state != 0) {
                         gSaveContext.timer_x[1] = 140;
                         gSaveContext.timer_y[1] = 80;
                         D_8015FFE4 = D_8015FFE6 = 20;
 
-                        if (gSaveContext.timer_2_state < 7)
+                        if (gSaveContext.timer_2_state < 7) {
                             gSaveContext.timer_2_state = 2;
-                        else
+                        } else {
                             gSaveContext.timer_2_state = 8;
+                        }
 
                         gSaveContext.timer_1_state = 0;
-                    }
-                    else
-                    {
+                    } else {
                         gSaveContext.timer_1_state = 0;
                     }
                     break;
@@ -4351,28 +3754,28 @@ void Interface_Draw(GlobalContext* globalCtx)
                     break;
                 default:
                     sp274 = 1;
-                    switch (gSaveContext.timer_2_state)
-                    {
+                    switch (gSaveContext.timer_2_state) {
                         case 1:
                         case 7:
                             gSaveContext.timer_x[1] = 140;
                             gSaveContext.timer_y[1] = 80;
                             D_8015FFE4 = D_8015FFE6 = 20;
-                            if (gSaveContext.timer_2_state == 1)
+                            if (gSaveContext.timer_2_state == 1) {
                                 gSaveContext.timer_2_state = 2;
-                            else
+                            } else {
                                 gSaveContext.timer_2_state = 8;
+                            }
                             break;
                         case 2:
                         case 8:
                             D_8015FFE6--;
-                            if (D_8015FFE6 == 0)
-                            {
+                            if (D_8015FFE6 == 0) {
                                 D_8015FFE6 = 20;
-                                if (gSaveContext.timer_2_state == 2)
+                                if (gSaveContext.timer_2_state == 2) {
                                     gSaveContext.timer_2_state = 3;
-                                else
+                                } else {
                                     gSaveContext.timer_2_state = 9;
+                                }
                             }
                             break;
                         case 3:
@@ -4383,94 +3786,83 @@ void Interface_Draw(GlobalContext* globalCtx)
                             phi_s3 = (gSaveContext.timer_x[1] - 26) / D_8015FFE2;
                             gSaveContext.timer_x[1] -= phi_s3;
 
-                            if (gSaveContext.health_capacity > 0xA0)
+                            if (gSaveContext.health_capacity > 0xA0) {
                                 phi_s3 = (gSaveContext.timer_y[1] - 54) / D_8015FFE6;
-                            else
+                            } else {
                                 phi_s3 = (gSaveContext.timer_y[1] - 46) / D_8015FFE6;
+                            }
                             gSaveContext.timer_y[1] -= phi_s3;
 
                             D_8015FFE6--;
-                            if (D_8015FFE6 == 0)
-                            {
+                            if (D_8015FFE6 == 0) {
                                 gSaveContext.timer_x[1] = 26;
                                 D_8015FFE6 = 20;
 
-                                if (gSaveContext.health_capacity > 0xA0)
+                                if (gSaveContext.health_capacity > 0xA0) {
                                     gSaveContext.timer_y[1] = 54;
-                                else
+                                } else {
                                     gSaveContext.timer_y[1] = 46;
+                                }
 
-                                if (gSaveContext.timer_2_state == 3)
+                                if (gSaveContext.timer_2_state == 3) {
                                     gSaveContext.timer_2_state = 4;
-                                else
+                                } else {
                                     gSaveContext.timer_2_state = 10;
+                                }
                             }
                         case 4:
                         case 10:
-                            if ((gSaveContext.timer_2_state == 4) || (gSaveContext.timer_2_state == 10))
-                            {
-                                if (gSaveContext.health_capacity > 0xA0)
+                            if ((gSaveContext.timer_2_state == 4) || (gSaveContext.timer_2_state == 10)) {
+                                if (gSaveContext.health_capacity > 0xA0) {
                                     gSaveContext.timer_y[1] = 54;
-                                else
+                                } else {
                                     gSaveContext.timer_y[1] = 46;
+                                }
                             }
 
-                            if (gSaveContext.timer_2_state >= 3)
-                            {
+                            if (gSaveContext.timer_2_state >= 3) {
                                 D_8015FFE4--;
-                                if (D_8015FFE4 == 0)
-                                {
+                                if (D_8015FFE4 == 0) {
                                     D_8015FFE4 = 20;
-                                    if (gSaveContext.timer_2_state == 4)
-                                    {
+                                    if (gSaveContext.timer_2_state == 4) {
                                         gSaveContext.timer_2_value--;
                                         osSyncPrintf("TOTAL_EVENT_TM=%d\n", gSaveContext.timer_2_value);
 
-                                        if (gSaveContext.timer_2_value <= 0)
-                                        {
+                                        if (gSaveContext.timer_2_value <= 0) {
                                             if (!Flags_GetSwitch(globalCtx, 0x37) ||
                                                 ((globalCtx->sceneNum != SCENE_GANON_DEMO) &&
                                                  (globalCtx->sceneNum != SCENE_GANON_FINAL) &&
                                                  (globalCtx->sceneNum != SCENE_GANON_SONOGO) &&
-                                                 (globalCtx->sceneNum != SCENE_GANONTIKA_SONOGO)))
-                                            {
+                                                 (globalCtx->sceneNum != SCENE_GANONTIKA_SONOGO))) {
                                                 gSaveContext.timer_2_state = 5;
                                                 gSaveContext.cutscene_index = 0;
                                                 D_8015FFE6 = 40;
                                                 func_8010B680(globalCtx, 0x71B0, 0);
                                                 func_8002DF54(globalCtx, 0, 8);
-                                            }
-                                            else
-                                            {
+                                            } else {
                                                 gSaveContext.timer_2_state = 6;
                                                 D_8015FFE6 = 40;
                                             }
-                                        }
-                                        else
-                                        {
-                                            if (gSaveContext.timer_2_value > 60)
-                                            {
-                                                if (sTimerDigits[4] == 1)
-                                                    Audio_PlaySoundGeneral(NA_SE_SY_MESSAGE_WOMAN, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
-                                            }
-                                            else if (gSaveContext.timer_2_value > 10)
-                                            {
-                                                if (sTimerDigits[4] & 1)
-                                                    Audio_PlaySoundGeneral(NA_SE_SY_WARNING_COUNT_N, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
-                                            }
-                                            else
-                                            {
-                                                Audio_PlaySoundGeneral(NA_SE_SY_WARNING_COUNT_E, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
+                                        } else {
+                                            if (gSaveContext.timer_2_value > 60) {
+                                                if (sTimerDigits[4] == 1) {
+                                                    Audio_PlaySoundGeneral(NA_SE_SY_MESSAGE_WOMAN, &D_801333D4, 4,
+                                                                           &D_801333E0, &D_801333E0, &D_801333E8);
+                                                }
+                                            } else if (gSaveContext.timer_2_value > 10) {
+                                                if (sTimerDigits[4] & 1) {
+                                                    Audio_PlaySoundGeneral(NA_SE_SY_WARNING_COUNT_N, &D_801333D4, 4,
+                                                                           &D_801333E0, &D_801333E0, &D_801333E8);
+                                                }
+                                            } else {
+                                                Audio_PlaySoundGeneral(NA_SE_SY_WARNING_COUNT_E, &D_801333D4, 4,
+                                                                       &D_801333E0, &D_801333E0, &D_801333E8);
                                             }
                                         }
-                                    }
-                                    else
-                                    {
+                                    } else {
                                         gSaveContext.timer_2_value++;
-                                        if (gSaveContext.event_inf[1] & 1)
-                                        {
-                                            if (gSaveContext.timer_2_value == 240)
-                                            {
+                                        if (gSaveContext.event_inf[1] & 1) {
+                                            if (gSaveContext.timer_2_value == 240) {
                                                 func_8010B680(globalCtx, 0x6083, 0);
                                                 gSaveContext.timer_2_state = 0;
                                                 gSaveContext.event_inf[1] &= ~1;
@@ -4478,45 +3870,43 @@ void Interface_Draw(GlobalContext* globalCtx)
                                         }
                                     }
 
-                                    if ((gSaveContext.timer_2_value % 60) == 0)
-                                    {
-                                        Audio_PlaySoundGeneral(NA_SE_SY_WARNING_COUNT_N, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
+                                    if ((gSaveContext.timer_2_value % 60) == 0) {
+                                        Audio_PlaySoundGeneral(NA_SE_SY_WARNING_COUNT_N, &D_801333D4, 4, &D_801333E0,
+                                                               &D_801333E0, &D_801333E8);
                                     }
                                 }
                             }
                             break;
                         case 6:
                             D_8015FFE6--;
-                            if (D_8015FFE6 == 0)
+                            if (D_8015FFE6 == 0) {
                                 gSaveContext.timer_2_state = 0;
+                            }
                             break;
-                }
+                    }
             }
 
             if (((gSaveContext.timer_1_state != 0) && (gSaveContext.timer_1_state != 10)) ||
-                (gSaveContext.timer_2_state != 0))
-            {
+                (gSaveContext.timer_2_state != 0)) {
                 sTimerDigits[0] = sTimerDigits[1] = sTimerDigits[3] = 0;
                 sTimerDigits[2] = 10; // digit 10 is used as ':' (colon)
 
-                if (gSaveContext.timer_1_state != 0)
+                if (gSaveContext.timer_1_state != 0) {
                     sTimerDigits[4] = gSaveContext.timer_1_value;
-                else
+                } else {
                     sTimerDigits[4] = gSaveContext.timer_2_value;
+                }
 
-                while (sTimerDigits[4] >= 60)
-                {
+                while (sTimerDigits[4] >= 60) {
                     sTimerDigits[1]++;
-                    if (sTimerDigits[1] >= 10)
-                    {
+                    if (sTimerDigits[1] >= 10) {
                         sTimerDigits[1] -= 10;
                         sTimerDigits[0]++;
                     }
                     sTimerDigits[4] -= 60;
                 }
 
-                while (sTimerDigits[4] >= 10)
-                {
+                while (sTimerDigits[4] >= 10) {
                     sTimerDigits[4] -= 10;
                     sTimerDigits[3]++;
                 }
@@ -4525,61 +3915,49 @@ void Interface_Draw(GlobalContext* globalCtx)
                 gDPPipeSync(gfxCtx->overlay.p++);
                 gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF);
                 gDPSetEnvColor(gfxCtx->overlay.p++, 0x00, 0x00, 0x00, 0x00);
-                gfxCtx->overlay.p = Draw_TextureIA8(gfxCtx->overlay.p,
-                                                    D_02002000,
-                                                    16, 16,
-                                                    gSaveContext.timer_x[sp274],
-                                                    gSaveContext.timer_y[sp274] + 2,
-                                                    16, 16,
-                                                    1024, 1024);
+                gfxCtx->overlay.p = Gfx_TextureIA8(gfxCtx->overlay.p, D_02002000, 16, 16, gSaveContext.timer_x[sp274],
+                                                   gSaveContext.timer_y[sp274] + 2, 16, 16, 1024, 1024);
 
                 // Timer Counter
                 gDPPipeSync(gfxCtx->overlay.p++);
-                gDPSetCombineLERP(gfxCtx->overlay.p++,
-                                    0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0,
-                                    0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0);
+                gDPSetCombineMode(gfxCtx->overlay.p++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
 
-                if (gSaveContext.timer_1_state != 0)
-                {
-                    if ((gSaveContext.timer_1_value < 10) && (gSaveContext.timer_1_state < 11))
+                if (gSaveContext.timer_1_state != 0) {
+                    if ((gSaveContext.timer_1_value < 10) && (gSaveContext.timer_1_state < 11)) {
                         gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFF, 0x32, 0x00, 0xFF);
-                    else
+                    } else {
                         gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF);
-                }
-                else
-                {
-                    if ((gSaveContext.timer_2_value < 10) && (gSaveContext.timer_2_state < 6))
+                    }
+                } else {
+                    if ((gSaveContext.timer_2_value < 10) && (gSaveContext.timer_2_state < 6)) {
                         gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFF, 0x32, 0x00, 0xFF);
-                    else
+                    } else {
                         gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0xFF, 0xFF, 0x00, 0xFF);
+                    }
                 }
 
-                for (phi_s3 = 0; phi_s3 < 5; phi_s3++)
-                {
-                    gfxCtx->overlay.p = Draw_TextureI8(gfxCtx->overlay.p,
-                                                       &D_02003040[sTimerDigits[phi_s3]],
-                                                       8, 16,
-                                                       gSaveContext.timer_x[sp274] + sTimerDigitLeftPos[phi_s3],
-                                                       gSaveContext.timer_y[sp274],
-                                                       sDigitWidth[phi_s3], VREG(42),
-                                                       VREG(43) * 2, VREG(43) * 2);
+                for (phi_s3 = 0; phi_s3 < 5; phi_s3++) {
+                    gfxCtx->overlay.p = Gfx_TextureI8(gfxCtx->overlay.p, &D_02003040[sTimerDigits[phi_s3]], 8, 16,
+                                                      gSaveContext.timer_x[sp274] + sTimerDigitLeftPos[phi_s3],
+                                                      gSaveContext.timer_y[sp274], sDigitWidth[phi_s3], VREG(42),
+                                                      VREG(43) * 2, VREG(43) * 2);
                 }
             }
         }
     }
 
-    if (pauseCtx->flag == 3)
+    if (pauseCtx->flag == 3) {
         func_8002AAB0(globalCtx);
+    }
 
-    if (interfaceCtx->unk_244 != 0)
-    {
+    if (interfaceCtx->unk_244 != 0) {
         gDPPipeSync(gfxCtx->overlay.p++);
         gSPDisplayList(gfxCtx->overlay.p++, sSetupDL_80125A60);
         gDPSetPrimColor(gfxCtx->overlay.p++, 0, 0, 0x00, 0x00, 0x00, interfaceCtx->unk_244);
         gDPFillRectangle(gfxCtx->overlay.p++, 0, 0, gScreenWidth - 1, gScreenHeight - 1);
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 4269);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 4269);
 }
 #else
 s16 D_8015FFE0;
@@ -4592,52 +3970,40 @@ s16 sTimerDigits[5];
 
 #ifdef NON_MATCHING
 // regalloc and minor ordering differences
-void Interface_Update(GlobalContext* globalCtx)
-{
+void Interface_Update(GlobalContext* globalCtx) {
     static u8 D_80125B60 = 0;
     static s16 D_80125B64 = 0;
     MessageContext* msgCtx = &globalCtx->msgCtx;
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
     Player* player = PLAYER;
-    s16 alpha; // sp+0x3A
+    s16 alpha;  // sp+0x3A
     s16 alpha1; // sp+0x38
     u16 action;
     Input* input = &globalCtx->state.input[2];
 
-    if (!~(input->padPressed | -0x201))
-    {
+    if (!~(input->padPressed | -0x201)) {
         gSaveContext.language = 0;
         osSyncPrintf("J_N=%x J_N=%x\n", gSaveContext.language, &gSaveContext.language);
-    }
-    else if (!~(input->padPressed | -0x801))
-    {
+    } else if (!~(input->padPressed | -0x801)) {
         gSaveContext.language = 1;
         osSyncPrintf("J_N=%x J_N=%x\n", gSaveContext.language, &gSaveContext.language);
-    }
-    else if (!~(input->padPressed | -0x101))
-    {
+    } else if (!~(input->padPressed | -0x101)) {
         gSaveContext.language = 2;
         osSyncPrintf("J_N=%x J_N=%x\n", gSaveContext.language, &gSaveContext.language);
     }
 
-    if ((globalCtx->pauseCtx.state == 0) && (globalCtx->pauseCtx.flag == 0))
-    {
+    if ((globalCtx->pauseCtx.state == 0) && (globalCtx->pauseCtx.flag == 0)) {
         if ((gSaveContext.minigame_state == 1) || (gSaveContext.scene_setup_index < 4) ||
-            ((globalCtx->sceneNum == SCENE_SPOT20) && (gSaveContext.scene_setup_index == 4)))
-        {
-            if ((msgCtx->msgMode == 0) ||
-                ((msgCtx->msgMode != 0) && (globalCtx->sceneNum == SCENE_BOWLING)))
-            {
-                if (globalCtx->unk_10A20 == 0)
-                {
+            ((globalCtx->sceneNum == SCENE_SPOT20) && (gSaveContext.scene_setup_index == 4))) {
+            if ((msgCtx->msgMode == 0) || ((msgCtx->msgMode != 0) && (globalCtx->sceneNum == SCENE_BOWLING))) {
+                if (globalCtx->unk_10A20 == 0) {
                     func_80083108(globalCtx);
                 }
             }
         }
     }
 
-    switch (gSaveContext.unk_13E8)
-    {
+    switch (gSaveContext.unk_13E8) {
         case 1:
         case 2:
         case 3:
@@ -4652,35 +4018,40 @@ void Interface_Update(GlobalContext* globalCtx)
         case 12:
         case 13:
             alpha = 0xFF - (gSaveContext.unk_13EC << 5);
-            if (alpha < 0)
+            if (alpha < 0) {
                 alpha = 0;
+            }
 
             func_80082850(globalCtx, alpha);
             gSaveContext.unk_13EC++;
 
-            if (alpha == 0)
+            if (alpha == 0) {
                 gSaveContext.unk_13E8 = 0;
+            }
             break;
         case 50:
             alpha = 0xFF - (gSaveContext.unk_13EC << 5);
-            if (alpha < 0)
+            if (alpha < 0) {
                 alpha = 0;
+            }
 
             alpha1 = 0xFF - alpha;
-            if (alpha1 >= 0xFF)
+            if (alpha1 >= 0xFF) {
                 alpha1 = 0xFF;
+            }
 
             osSyncPrintf("case 50 : alpha=%d  alpha1=%d\n", alpha, alpha1);
             func_80082644(globalCtx, alpha1);
 
-            if (interfaceCtx->healthAlpha != 0xFF)
+            if (interfaceCtx->healthAlpha != 0xFF) {
                 interfaceCtx->healthAlpha = alpha1;
+            }
 
-            if (interfaceCtx->magicAlpha != 0xFF)
+            if (interfaceCtx->magicAlpha != 0xFF) {
                 interfaceCtx->magicAlpha = alpha1;
+            }
 
-            switch (globalCtx->sceneNum)
-            {
+            switch (globalCtx->sceneNum) {
                 case SCENE_SPOT00:
                 case SCENE_SPOT01:
                 case SCENE_SPOT02:
@@ -4701,20 +4072,23 @@ void Interface_Update(GlobalContext* globalCtx)
                 case SCENE_SPOT18:
                 case SCENE_SPOT20:
                 case SCENE_GANON_TOU:
-                    if (interfaceCtx->minimapAlpha < 0xAA)
+                    if (interfaceCtx->minimapAlpha < 0xAA) {
                         interfaceCtx->minimapAlpha = alpha1;
-                    else
+                    } else {
                         interfaceCtx->minimapAlpha = 0xAA;
+                    }
                     break;
                 default:
-                    if (interfaceCtx->minimapAlpha != 0xFF)
+                    if (interfaceCtx->minimapAlpha != 0xFF) {
                         interfaceCtx->minimapAlpha = alpha1;
+                    }
                     break;
             }
 
             gSaveContext.unk_13EC++;
-            if (alpha1 == 0xFF)
+            if (alpha1 == 0xFF) {
                 gSaveContext.unk_13E8 = 0;
+            }
 
             break;
         case 52:
@@ -4727,20 +4101,20 @@ void Interface_Update(GlobalContext* globalCtx)
 
     func_8008226C(globalCtx);
 
-    if (gSaveContext.health_accumulator != 0)
-    {
+    if (gSaveContext.health_accumulator != 0) {
         gSaveContext.health_accumulator -= 4;
         gSaveContext.health += 4;
 
-        if ((gSaveContext.health & 0xF) < 4)
+        if ((gSaveContext.health & 0xF) < 4) {
             Audio_PlaySoundGeneral(NA_SE_SY_HP_RECOVER, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
+        }
 
         osSyncPrintf("now_life=%d  max_life=%d\n", gSaveContext.health, gSaveContext.health_capacity);
 
-        if (gSaveContext.health >= gSaveContext.health_capacity)
-        {
+        if (gSaveContext.health >= gSaveContext.health_capacity) {
             gSaveContext.health = gSaveContext.health_capacity;
-            osSyncPrintf("S_Private.now_life=%d  S_Private.max_life=%d\n", gSaveContext.health, gSaveContext.health_capacity);
+            osSyncPrintf("S_Private.now_life=%d  S_Private.max_life=%d\n", gSaveContext.health,
+                         gSaveContext.health_capacity);
             gSaveContext.health_accumulator = 0;
         }
     }
@@ -4748,119 +4122,92 @@ void Interface_Update(GlobalContext* globalCtx)
     Health_HandleCriticalAlarm(globalCtx);
     D_80125A58 = func_8008F2F8(globalCtx);
 
-    if (D_80125A58 == 1)
-    {
-        if (CUR_EQUIP_VALUE(EQUIP_TUNIC) == 2)
-        {
+    if (D_80125A58 == 1) {
+        if (CUR_EQUIP_VALUE(EQUIP_TUNIC) == 2) {
             D_80125A58 = 0;
         }
-    }
-    else if ((func_8008F2F8(globalCtx) >= 2) && (func_8008F2F8(globalCtx) < 5))
-    {
-        if (CUR_EQUIP_VALUE(EQUIP_TUNIC) == 3)
-        {
+    } else if ((func_8008F2F8(globalCtx) >= 2) && (func_8008F2F8(globalCtx) < 5)) {
+        if (CUR_EQUIP_VALUE(EQUIP_TUNIC) == 3) {
             D_80125A58 = 0;
         }
     }
 
     Health_UpdateData(globalCtx);
 
-    if ((gSaveContext.timer_1_state >= 3) &&
-        (globalCtx->pauseCtx.state == 0) &&
-        (globalCtx->pauseCtx.flag == 0) &&
-        (msgCtx->msgMode == 0) &&
-        !(player->stateFlags2 & 0x01000000) &&
-        (globalCtx->sceneLoadFlag == 0) &&
-        (globalCtx->unk_1241B == 0) &&
-        (func_800BFC84(globalCtx) == 0))
-    {
-
-    }
+    if ((gSaveContext.timer_1_state >= 3) && (globalCtx->pauseCtx.state == 0) && (globalCtx->pauseCtx.flag == 0) &&
+        (msgCtx->msgMode == 0) && !(player->stateFlags2 & 0x01000000) && (globalCtx->sceneLoadFlag == 0) &&
+        (globalCtx->unk_1241B == 0) && (func_800BFC84(globalCtx) == 0)) {}
 
-    if (gSaveContext.rupee_accumulator != 0)
-    {
-        if (gSaveContext.rupee_accumulator > 0)
-        {
-            if (gSaveContext.rupees < CUR_CAPACITY(UPG_WALLET))
-            {
+    if (gSaveContext.rupee_accumulator != 0) {
+        if (gSaveContext.rupee_accumulator > 0) {
+            if (gSaveContext.rupees < CUR_CAPACITY(UPG_WALLET)) {
                 gSaveContext.rupee_accumulator--;
                 gSaveContext.rupees++;
                 Audio_PlaySoundGeneral(NA_SE_SY_RUPY_COUNT, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
-            }
-            else
-            {
+            } else {
                 // Translates to: "Rupee Amount MAX = %d"
                 osSyncPrintf("ルピー数ＭＡＸ = %d\n", CUR_CAPACITY(UPG_WALLET));
                 gSaveContext.rupees = CUR_CAPACITY(UPG_WALLET);
                 gSaveContext.rupee_accumulator = 0;
             }
-        }
-        else if (gSaveContext.rupees != 0)
-        {
-            if (gSaveContext.rupee_accumulator <= -50)
-            {
+        } else if (gSaveContext.rupees != 0) {
+            if (gSaveContext.rupee_accumulator <= -50) {
                 gSaveContext.rupee_accumulator += 10;
                 gSaveContext.rupees -= 10;
 
-                if (gSaveContext.rupees < 0)
+                if (gSaveContext.rupees < 0) {
                     gSaveContext.rupees = 0;
+                }
 
                 Audio_PlaySoundGeneral(NA_SE_SY_RUPY_COUNT, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
-            }
-            else
-            {
+            } else {
                 gSaveContext.rupee_accumulator++;
                 gSaveContext.rupees--;
                 Audio_PlaySoundGeneral(NA_SE_SY_RUPY_COUNT, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
             }
-        }
-        else
-        {
+        } else {
             gSaveContext.rupee_accumulator = 0;
         }
     }
 
-    switch (interfaceCtx->unk_1EC)
-    {
+    switch (interfaceCtx->unk_1EC) {
         case 1:
             interfaceCtx->unk_1F4 = interfaceCtx->unk_1F4 + (31400.0f / WREG(5));
-            if (interfaceCtx->unk_1F4 >= 15700.0f)
-            {
+            if (interfaceCtx->unk_1F4 >= 15700.0f) {
                 interfaceCtx->unk_1F4 = -15700.0f;
                 interfaceCtx->unk_1EC = 2;
             }
             break;
         case 2:
             interfaceCtx->unk_1F4 = interfaceCtx->unk_1F4 + (31400.0f / WREG(5));
-            if (interfaceCtx->unk_1F4 >= 0.0f)
-            {
+            if (interfaceCtx->unk_1F4 >= 0.0f) {
                 interfaceCtx->unk_1F4 = 0.0f;
                 interfaceCtx->unk_1EC = 0;
                 interfaceCtx->unk_1EE = interfaceCtx->unk_1F0;
                 action = interfaceCtx->unk_1EE;
-                if ((action == 0x1D) || (action == 0x1E))
+                if ((action == 0x1D) || (action == 0x1E)) {
                     action = 0xA;
+                }
                 Interface_LoadActionLabel(interfaceCtx, action, 0);
             }
             break;
         case 3:
             interfaceCtx->unk_1F4 = interfaceCtx->unk_1F4 + (31400.0f / WREG(5));
-            if (interfaceCtx->unk_1F4 >= 15700.0f)
-            {
+            if (interfaceCtx->unk_1F4 >= 15700.0f) {
                 interfaceCtx->unk_1F4 = -15700.0f;
                 interfaceCtx->unk_1EC = 2;
             }
             break;
         case 4:
             interfaceCtx->unk_1F4 = interfaceCtx->unk_1F4 + (31400.0f / WREG(5));
-            if (interfaceCtx->unk_1F4 >= 0.0f)
-            {
+            if (interfaceCtx->unk_1F4 >= 0.0f) {
                 interfaceCtx->unk_1F4 = 0.0f;
                 interfaceCtx->unk_1EC = 0;
                 interfaceCtx->unk_1EE = interfaceCtx->unk_1F0;
                 action = interfaceCtx->unk_1EE;
-                if ((action == 0x1D) || (action == 0x1E))
+                if ((action == 0x1D) || (action == 0x1E)) {
                     action = 0xA;
+                }
                 Interface_LoadActionLabel(interfaceCtx, action, 0);
             }
             break;
@@ -4870,10 +4217,8 @@ void Interface_Update(GlobalContext* globalCtx)
 
     if ((globalCtx->pauseCtx.state == 0) && (globalCtx->pauseCtx.flag == 0) && (msgCtx->msgMode == 0) &&
         (globalCtx->sceneLoadFlag == 0) && (globalCtx->unk_10A20 == 0) && (globalCtx->unk_1241B == 0) &&
-        ((globalCtx->csCtx.state == 0) || (func_8008E988(globalCtx) == 0)))
-    {
-        if ((gSaveContext.magic_acquired != 0) && (gSaveContext.magic_level == 0))
-        {
+        ((globalCtx->csCtx.state == 0) || (func_8008E988(globalCtx) == 0))) {
+        if ((gSaveContext.magic_acquired != 0) && (gSaveContext.magic_level == 0)) {
             gSaveContext.magic_level = gSaveContext.double_magic + 1;
             gSaveContext.unk_13F0 = 8;
             osSyncPrintf(VT_FGCOL(YELLOW));
@@ -4889,40 +4234,31 @@ void Interface_Update(GlobalContext* globalCtx)
         Interface_UpdateMagicBar(globalCtx);
     }
 
-    if (gSaveContext.timer_1_state == 0)
-    {
-        if (((D_80125A58 == 1) || (D_80125A58 == 2) || (D_80125A58 == 4)) &&
-            ((gSaveContext.health >> 1) != 0))
-        {
+    if (gSaveContext.timer_1_state == 0) {
+        if (((D_80125A58 == 1) || (D_80125A58 == 2) || (D_80125A58 == 4)) && ((gSaveContext.health >> 1) != 0)) {
             gSaveContext.timer_1_state = 1;
             gSaveContext.timer_x[0] = 140;
             gSaveContext.timer_y[0] = 80;
             D_80125A5C = 1;
         }
-    }
-    else
-    {
-        if (((D_80125A58 == 0) || (D_80125A58 == 3)) &&
-            (gSaveContext.timer_1_state < 5))
-        {
+    } else {
+        if (((D_80125A58 == 0) || (D_80125A58 == 3)) && (gSaveContext.timer_1_state < 5)) {
             gSaveContext.timer_1_state = 0;
         }
     }
 
-    if (gSaveContext.minigame_state == 1)
-    {
+    if (gSaveContext.minigame_state == 1) {
         gSaveContext.minigame_score += interfaceCtx->unk_23C;
         interfaceCtx->unk_23C = 0;
 
-        if (sHBAScoreTier == 0)
-        {
-            if (gSaveContext.minigame_score >= 1000)
+        if (sHBAScoreTier == 0) {
+            if (gSaveContext.minigame_score >= 1000) {
                 sHBAScoreTier++;
-        }
-        else if (sHBAScoreTier == 1)
-        {
-            if (gSaveContext.minigame_score >= 1500)
+            }
+        } else if (sHBAScoreTier == 1) {
+            if (gSaveContext.minigame_score >= 1500) {
                 sHBAScoreTier++;
+            }
         }
 
         sHBAScoreDigits[1] = 0;
@@ -4930,74 +4266,60 @@ void Interface_Update(GlobalContext* globalCtx)
         sHBAScoreDigits[2] = 0;
         sHBAScoreDigits[3] = gSaveContext.minigame_score;
 
-        while (sHBAScoreDigits[3] >= 1000)
-        {
+        while (sHBAScoreDigits[3] >= 1000) {
             sHBAScoreDigits[0]++;
             sHBAScoreDigits[3] -= 1000;
         }
 
-        while (sHBAScoreDigits[3] >= 100)
-        {
+        while (sHBAScoreDigits[3] >= 100) {
             sHBAScoreDigits[1]++;
             sHBAScoreDigits[3] -= 100;
         }
 
-        while (sHBAScoreDigits[3] >= 10)
-        {
+        while (sHBAScoreDigits[3] >= 10) {
             sHBAScoreDigits[2]++;
             sHBAScoreDigits[3] -= 10;
         }
     }
 
-    if (gSaveContext.unk_1422 != 0)
-    {
-        if ((msgCtx->unk_E3F0 != 0x31) && (gSaveContext.unk_1422 == 1))
+    if (gSaveContext.unk_1422 != 0) {
+        if ((msgCtx->unk_E3F0 != 0x31) && (gSaveContext.unk_1422 == 1)) {
             globalCtx->msgCtx.unk_E3EE = 4;
+        }
 
-        if (globalCtx->unk_10A26 != 0)
-        {
-            if (gSaveContext.unk_1422 != 2)
-            {
+        if (globalCtx->unk_10A26 != 0) {
+            if (gSaveContext.unk_1422 != 2) {
                 D_80125B60 = 0;
-                if ((gSaveContext.day_time >= 0x4555) && (gSaveContext.day_time <= 0xC001))
+                if ((gSaveContext.day_time >= 0x4555) && (gSaveContext.day_time <= 0xC001)) {
                     D_80125B60 = 1;
+                }
 
                 gSaveContext.unk_1422 = 2;
                 D_80125B64 = D_8011FB40;
                 D_8011FB40 = 400;
-            }
-            else if ((D_80125B60 == 0) && (gSaveContext.day_time >= 0x4555) && (gSaveContext.day_time <= 0xC001))
-            {
+            } else if ((D_80125B60 == 0) && (gSaveContext.day_time >= 0x4555) && (gSaveContext.day_time <= 0xC001)) {
                 gSaveContext.unk_1422 = 0;
                 D_8011FB40 = D_80125B64;
                 globalCtx->msgCtx.unk_E3EE = 4;
-            }
-            else if (gSaveContext.day_time > 0xC001)
-            {
+            } else if (gSaveContext.day_time > 0xC001) {
                 gSaveContext.unk_1422 = 0;
                 D_8011FB40 = D_80125B64;
                 globalCtx->msgCtx.unk_E3EE = 4;
             }
-        }
-        else if ((globalCtx->roomCtx.curRoom.unk_03 != 1) && (interfaceCtx->restrictions.sunsSong != 3))
-        {
-            if ((gSaveContext.day_time >= 0x4555) && (gSaveContext.day_time < 0xC001))
-            {
+        } else if ((globalCtx->roomCtx.curRoom.unk_03 != 1) && (interfaceCtx->restrictions.sunsSong != 3)) {
+            if ((gSaveContext.day_time >= 0x4555) && (gSaveContext.day_time < 0xC001)) {
                 gSaveContext.next_day_time = 0;
                 globalCtx->fadeOutTransition = 4;
                 gSaveContext.transition_type = 2;
                 globalCtx->unk_11DE9 = 1;
-            }
-            else
-            {
+            } else {
                 gSaveContext.next_day_time = 0x8001;
                 globalCtx->fadeOutTransition = 5;
                 gSaveContext.transition_type = 3;
                 globalCtx->unk_11DE9 = 1;
             }
 
-            if (globalCtx->sceneNum == SCENE_SPOT13)
-            {
+            if (globalCtx->sceneNum == SCENE_SPOT13) {
                 globalCtx->fadeOutTransition = 0xE;
                 gSaveContext.transition_type = 0xE;
             }
@@ -5009,9 +4331,7 @@ void Interface_Update(GlobalContext* globalCtx)
             func_800F6964(30);
             gSaveContext.seq_index = 0xFF;
             gSaveContext.night_sfx = 0xFF;
-        }
-        else
-        {
+        } else {
             gSaveContext.unk_1422 = 3;
         }
     }
diff --git a/src/code/z_path.c b/src/code/z_path.c
new file mode 100644
index 000000000..03dc6d6f6
--- /dev/null
+++ b/src/code/z_path.c
@@ -0,0 +1,46 @@
+#include <ultra64.h>
+#include <global.h>
+
+Path* Path_GetByIndex(GlobalContext* globalCtx, s16 index, s16 max) {
+    Path* path;
+
+    if (index != max) {
+        path = &globalCtx->setupPathList[index];
+    } else {
+        path = NULL;
+    }
+
+    return path;
+}
+
+f32 Path_OrientAndGetDistSq(Actor* actor, Path* path, s16 waypoint, s16* yaw) {
+    f32 dx;
+    f32 dz;
+    Vec3s* pointPos;
+
+    if (path == NULL) {
+        return -1.0;
+    }
+
+    pointPos = SEGMENTED_TO_VIRTUAL(path->points);
+    pointPos = &pointPos[waypoint];
+
+    dx = pointPos->x - actor->posRot.pos.x;
+    dz = pointPos->z - actor->posRot.pos.z;
+
+    *yaw = Math_atan2f(dx, dz) * (32768 / M_PI);
+
+    return SQ(dx) + SQ(dz);
+}
+
+void Path_CopyLastPoint(Path* path, Vec3f* dest) {
+    Vec3s* pointPos;
+
+    if (path != NULL) {
+        pointPos = &((Vec3s*)SEGMENTED_TO_VIRTUAL(path->points))[path->count - 1];
+
+        dest->x = pointPos->x;
+        dest->y = pointPos->y;
+        dest->z = pointPos->z;
+    }
+}
diff --git a/src/code/z_play.c b/src/code/z_play.c
index 96378ada9..99d454e6f 100644
--- a/src/code/z_play.c
+++ b/src/code/z_play.c
@@ -1,39 +1,33 @@
 #include <ultra64.h>
 #include <global.h>
 
-void func_800BC450(GlobalContext* globalCtx)
-{
-      func_8005A7A8(globalCtx->cameraCtx.activeCameraPtrs[globalCtx->cameraCtx.unk_5C0],
-                    globalCtx->unk_1242B - 1, globalCtx);
+void func_800BC450(GlobalContext* globalCtx) {
+    func_8005A7A8(globalCtx->cameraCtx.activeCameraPtrs[globalCtx->cameraCtx.unk_5C0], globalCtx->unk_1242B - 1,
+                  globalCtx);
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_play/func_800BC490.s")
 
-s32 func_800BC56C(GlobalContext* globalCtx, s16 arg1)
-{
+s32 func_800BC56C(GlobalContext* globalCtx, s16 arg1) {
     return arg1 == globalCtx->unk_1242B;
 }
 
-void func_800BC590(GlobalContext* globalCtx)
-{
+void func_800BC590(GlobalContext* globalCtx) {
     osSyncPrintf("Game_play_shop_pr_vr_switch_set()\n");
-    if (YREG(15) == 0x10)
-    {
+    if (YREG(15) == 0x10) {
         globalCtx->unk_1242B = 2;
     }
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_play/func_800BC5E0.s")
 
-void func_800BC88C(GlobalContext* globalCtx)
-{
+void func_800BC88C(GlobalContext* globalCtx) {
     globalCtx->unk_123F0 = -1;
 }
 
-Gfx* func_800BC8A0(GlobalContext* globalCtx, Gfx* a1)
-{
-    func_80093708(a1, globalCtx->lightCtx.unk_07, globalCtx->lightCtx.unk_08,
-                  globalCtx->lightCtx.unk_09, 0, globalCtx->lightCtx.unk_0A, 1000);
+Gfx* func_800BC8A0(GlobalContext* globalCtx, Gfx* a1) {
+    Gfx_SetFog2(a1, globalCtx->lightCtx.unk_07, globalCtx->lightCtx.unk_08, globalCtx->lightCtx.unk_09, 0,
+                globalCtx->lightCtx.unk_0A, 1000);
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_play/func_800BC8EC.s")
@@ -48,8 +42,7 @@ Gfx* func_800BC8A0(GlobalContext* globalCtx, Gfx* a1)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_play/func_800BFAE4.s")
 
-s32 func_800BFC84(GlobalContext* globalCtx)
-{
+s32 func_800BFC84(GlobalContext* globalCtx) {
     return globalCtx->csCtx.state != 0 || func_8008E988(globalCtx) != 0;
 }
 
@@ -59,14 +52,13 @@ s32 func_800BFC84(GlobalContext* globalCtx)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_play/func_800BFEC4.s")
 
-void func_800BFF0C(GlobalContext* globalCtx, s32 a1)
-{
+void func_800BFF0C(GlobalContext* globalCtx, s32 a1) {
     globalCtx->curSpawn = a1;
     globalCtx->linkActorEntry = NULL;
     globalCtx->unk_11DFC = NULL;
     globalCtx->setupEntranceList = NULL;
     globalCtx->setupExitList = NULL;
-    globalCtx->naviMsgSegment = NULL;
+    globalCtx->cUpElfMsgs = NULL;
     globalCtx->setupPathList = NULL;
     globalCtx->nbSetupActors = 0;
     Object_InitBank(globalCtx, &globalCtx->objectCtx);
@@ -85,8 +77,7 @@ void func_800BFF0C(GlobalContext* globalCtx, s32 a1)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_play/func_800C0230.s")
 
-s16 func_800C030C(GlobalContext* globalCtx)
-{
+s16 func_800C030C(GlobalContext* globalCtx) {
     return globalCtx->cameraCtx.unk_5C0;
 }
 
@@ -120,8 +111,7 @@ s16 func_800C030C(GlobalContext* globalCtx)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_play/func_800C0AF4.s")
 
-void func_800C0B60(GlobalContext* globalCtx)
-{
+void func_800C0B60(GlobalContext* globalCtx) {
     gSaveContext.respawn[RESPAWN_MODE_DOWN].temp_swch_flags = globalCtx->actorCtx.flags.tempSwch;
     gSaveContext.respawn[RESPAWN_MODE_DOWN].temp_collect_flags = globalCtx->actorCtx.flags.tempCollect;
     gSaveContext.respawn_flag = 1;
@@ -130,48 +120,35 @@ void func_800C0B60(GlobalContext* globalCtx)
     globalCtx->fadeOutTransition = 2;
 }
 
-void func_800C0BB4(GlobalContext* globalCtx)
-{
+void func_800C0BB4(GlobalContext* globalCtx) {
     gSaveContext.respawn_flag = -1;
     globalCtx->sceneLoadFlag = 0x14;
 
-    if (globalCtx->sceneNum == SCENE_GANON_SONOGO ||
-        globalCtx->sceneNum == SCENE_GANON_FINAL ||
-        globalCtx->sceneNum == SCENE_GANONTIKA_SONOGO ||
-        globalCtx->sceneNum == SCENE_GANON_DEMO)
-    {
+    if (globalCtx->sceneNum == SCENE_GANON_SONOGO || globalCtx->sceneNum == SCENE_GANON_FINAL ||
+        globalCtx->sceneNum == SCENE_GANONTIKA_SONOGO || globalCtx->sceneNum == SCENE_GANON_DEMO) {
         globalCtx->nextEntranceIndex = 0x043F;
         Item_Give(globalCtx, ITEM_SWORD_MASTER);
-    }
-    else if (gSaveContext.entrance_index == 0x028A ||
-            gSaveContext.entrance_index == 0x028E ||
-            gSaveContext.entrance_index == 0x0292 ||
-            gSaveContext.entrance_index == 0x0476)
-    {
+    } else if (gSaveContext.entrance_index == 0x028A || gSaveContext.entrance_index == 0x028E ||
+               gSaveContext.entrance_index == 0x0292 || gSaveContext.entrance_index == 0x0476) {
         globalCtx->nextEntranceIndex = 0x01F9;
-    }
-    else
-    {
+    } else {
         globalCtx->nextEntranceIndex = gSaveContext.entrance_index;
     }
 
     globalCtx->fadeOutTransition = 2;
 }
 
-void func_800C0C88(GlobalContext* globalCtx)
-{
+void func_800C0C88(GlobalContext* globalCtx) {
     func_800C0AF4(globalCtx, 0, 0xDFF);
     func_800C0BB4(globalCtx);
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_play/func_800C0CB8.s")
 
-s32 func_800C0D28(GlobalContext* globalCtx)
-{
+s32 func_800C0D28(GlobalContext* globalCtx) {
     return globalCtx->unk_7B8 != 0;
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_play/func_800C0D34.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_play/func_800C0DB4.s")
-
diff --git a/src/code/z_player_call.c b/src/code/z_player_call.c
index 3adf3bc21..cf525ff24 100644
--- a/src/code/z_player_call.c
+++ b/src/code/z_player_call.c
@@ -15,8 +15,7 @@ void PlayerCall_Destroy(Player* player, GlobalContext* globalCtx);
 void PlayerCall_Update(Player* player, GlobalContext* globalCtx);
 void PlayerCall_Draw(Player* player, GlobalContext* globalCtx);
 
-const ActorInit Player_InitVars =
-{
+const ActorInit Player_InitVars = {
     ACTOR_PLAYER,
     ACTORTYPE_PLAYER,
     0,
@@ -29,35 +28,30 @@ const ActorInit Player_InitVars =
     (ActorFunc)PlayerCall_Draw,
 };
 
-void PlayerCall_InitFuncPtrs()
-{
+void PlayerCall_InitFuncPtrs() {
     sPlayerCallInitFunc = KaleidoManager_GetRamAddr(func_80846CD8);
     sPlayerCallDestroyFunc = KaleidoManager_GetRamAddr(func_8084AB54);
     sPlayerCallUpdateFunc = KaleidoManager_GetRamAddr(func_80849EA8);
     sPlayerCallDrawFunc = KaleidoManager_GetRamAddr(func_8084A5C4);
 }
 
-void PlayerCall_Init(Player* player, GlobalContext* globalCtx)
-{
+void PlayerCall_Init(Player* player, GlobalContext* globalCtx) {
     KaleidoScopeCall_LoadPlayer();
     PlayerCall_InitFuncPtrs();
     sPlayerCallInitFunc(player, globalCtx);
 }
 
-void PlayerCall_Destroy(Player* player, GlobalContext* globalCtx)
-{
+void PlayerCall_Destroy(Player* player, GlobalContext* globalCtx) {
     KaleidoScopeCall_LoadPlayer();
     sPlayerCallDestroyFunc(player, globalCtx);
 }
 
-void PlayerCall_Update(Player* player, GlobalContext* globalCtx)
-{
+void PlayerCall_Update(Player* player, GlobalContext* globalCtx) {
     KaleidoScopeCall_LoadPlayer();
     sPlayerCallUpdateFunc(player, globalCtx);
 }
 
-void PlayerCall_Draw(Player* player, GlobalContext* globalCtx)
-{
+void PlayerCall_Draw(Player* player, GlobalContext* globalCtx) {
     KaleidoScopeCall_LoadPlayer();
     sPlayerCallDrawFunc(player, globalCtx);
 }
diff --git a/src/code/z_player_lib.c b/src/code/z_player_lib.c
index 06d2741ff..4ddb530fe 100644
--- a/src/code/z_player_lib.c
+++ b/src/code/z_player_lib.c
@@ -3,33 +3,22 @@
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_8008E750.s")
 
-UNK_TYPE func_8008E8DC(GlobalContext* globalCtx, Player* player)
-{
-    return (
-            player->stateFlags1 & 0x20000080 ||
-            player->action ||
-            globalCtx->sceneLoadFlag == 0x14 ||
-            player->stateFlags1 & 1 ||
-            player->unk_692 & 0x80 ||
-            gSaveContext.unk_13F0 &&
-            func_8008F0D8(player, player->unk_154) >= 0
-    );
-
-}
-
-UNK_TYPE func_8008E988(GlobalContext* globalCtx)
-{
+UNK_TYPE func_8008E8DC(GlobalContext* globalCtx, Player* player) {
+    return (player->stateFlags1 & 0x20000080 || player->action || globalCtx->sceneLoadFlag == 0x14 ||
+            player->stateFlags1 & 1 || player->unk_692 & 0x80 ||
+            gSaveContext.unk_13F0 && func_8008F0D8(player, player->unk_154) >= 0);
+}
+
+UNK_TYPE func_8008E988(GlobalContext* globalCtx) {
     Player* player = PLAYER;
     return func_8008E8DC(globalCtx, player) || player->unk_6AD == 4;
 }
 
-UNK_TYPE func_8008E9C4(Player* player)
-{
+UNK_TYPE func_8008E9C4(Player* player) {
     return player->stateFlags1 & 0x10;
 }
 
-UNK_TYPE func_8008E9D0(Player* player)
-{
+UNK_TYPE func_8008E9D0(Player* player) {
     return LINK_IS_CHILD && player->currentShield == 2;
 }
 
@@ -41,8 +30,7 @@ UNK_TYPE func_8008E9D0(Player* player)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_8008EC04.s")
 
-void func_8008EC70(Player* player)
-{
+void func_8008EC70(Player* player) {
     player->unk_154 = player->unk_151;
     func_8008EC04(player, func_8008E9F8(player, player->unk_151));
     player->unk_6AD = 0;
@@ -50,19 +38,16 @@ void func_8008EC70(Player* player)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_8008ECAC.s")
 
-void func_8008ED9C(GlobalContext* globalCtx, Player* player, UNK_TYPE item, UNK_TYPE arg2)
-{
+void func_8008ED9C(GlobalContext* globalCtx, Player* player, UNK_TYPE item, UNK_TYPE arg2) {
     Inventory_UpdateBottleItem(globalCtx, item, player->unk_150);
-    if (item != ITEM_BOTTLE)
-    {
+    if (item != ITEM_BOTTLE) {
         player->unk_152 = item;
         player->unk_151 = arg2;
     }
     player->unk_154 = arg2;
 }
 
-void func_8008EDF0(Player* player)
-{
+void func_8008EDF0(Player* player) {
     player->unk_664 = NULL;
     player->stateFlags2 &= ~0x2000;
 }
@@ -71,8 +56,7 @@ void func_8008EDF0(Player* player)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_8008EEAC.s")
 
-UNK_TYPE func_8008EF44(GlobalContext* globalCtx, UNK_TYPE arg1)
-{
+UNK_TYPE func_8008EF44(GlobalContext* globalCtx, UNK_TYPE arg1) {
     globalCtx->unk_11E5C = (arg1 + 1);
     return 1;
 }
@@ -81,69 +65,56 @@ UNK_TYPE func_8008EF44(GlobalContext* globalCtx, UNK_TYPE arg1)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_8008F034.s")
 
-u8 func_8008F080(GlobalContext* globalCtx)
-{
+u8 func_8008F080(GlobalContext* globalCtx) {
     Player* player = PLAYER;
     return player->currentMask;
 }
 
-void func_8008F08C(GlobalContext* globalCtx)
-{
+void func_8008F08C(GlobalContext* globalCtx) {
     Player* player = PLAYER;
     player->currentMask = 0;
 }
 
-UNK_TYPE func_8008F098(GlobalContext* globalCtx)
-{
+UNK_TYPE func_8008F098(GlobalContext* globalCtx) {
     Player* player = PLAYER;
     return player->currentShield == 3;
 }
 
-UNK_TYPE func_8008F0AC(GlobalContext* globalCtx)
-{
+UNK_TYPE func_8008F0AC(GlobalContext* globalCtx) {
     Player* player = PLAYER;
     return player->unk_15D == 0xa && player->currentShield == 3;
 }
 
-s32 func_8008F0D8(Player* player, UNK_TYPE arg1)
-{
+s32 func_8008F0D8(Player* player, UNK_TYPE arg1) {
     s32 temp_v0 = arg1 - 0x15;
-    if (temp_v0 >= 0 && temp_v0 < 6)
-    {
+    if (temp_v0 >= 0 && temp_v0 < 6) {
         return temp_v0;
     }
     return -1;
 }
 
-UNK_TYPE func_8008F104(Player* player)
-{
+UNK_TYPE func_8008F104(Player* player) {
     return player->unk_151 == 0x10 || player->unk_151 == 0x11;
 }
 
-UNK_TYPE func_8008F128(Player* player)
-{
+UNK_TYPE func_8008F128(Player* player) {
     return func_8008F104(player) && player->heldActor == NULL;
 }
 
-s32 func_8008F158(UNK_TYPE arg0)
-{
+s32 func_8008F158(UNK_TYPE arg0) {
     s32 temp_v0 = arg0 - 2;
-    if (temp_v0 > 0 && temp_v0 < 6)
-    {
+    if (temp_v0 > 0 && temp_v0 < 6) {
         return temp_v0;
     }
     return 0;
 }
 
-void func_8008F180(Player* player)
-{
+void func_8008F180(Player* player) {
     func_8008F158(player->unk_151);
 }
 
-UNK_TYPE func_8008F1A0(Player* player)
-{
-    if (player->unk_151 >= 5 && player->unk_151 < 8)
-    {
+UNK_TYPE func_8008F1A0(Player* player) {
+    if (player->unk_151 >= 5 && player->unk_151 < 8) {
         return 1;
     }
     return 0;
@@ -151,33 +122,27 @@ UNK_TYPE func_8008F1A0(Player* player)
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_player_lib/func_8008F1CC.s")
 
-s32 func_8008F224(Player* player, UNK_TYPE arg1)
-{
+s32 func_8008F224(Player* player, UNK_TYPE arg1) {
     s32 temp_v0 = arg1 - 0x1E;
-    if (temp_v0 >= 0 && temp_v0 < 0xD)
-    {
+    if (temp_v0 >= 0 && temp_v0 < 0xD) {
         return temp_v0;
     }
     return -1;
 }
 
-void func_8008F250(Player* player)
-{
+void func_8008F250(Player* player) {
     func_8008F224(player, player->unk_151);
 }
 
-s32 func_8008F270(Player* player, UNK_TYPE arg1)
-{
+s32 func_8008F270(Player* player, UNK_TYPE arg1) {
     s32 temp_v0 = arg1 - 0x12;
-    if (temp_v0 >= 0 && temp_v0 < 2)
-    {
+    if (temp_v0 >= 0 && temp_v0 < 2) {
         return temp_v0;
     }
     return -1;
 }
 
-s32 func_8008F29C(Player* player)
-{
+s32 func_8008F29C(Player* player) {
     return func_8008F270(player, player->unk_151);
 }
 
diff --git a/src/code/z_prenmi.c b/src/code/z_prenmi.c
index 1ea813704..286c6328f 100644
--- a/src/code/z_prenmi.c
+++ b/src/code/z_prenmi.c
@@ -2,23 +2,20 @@
 #include <global.h>
 #include <vt.h>
 
-void func_80092320(PreNMIContext* prenmiCtx)
-{
+void func_80092320(PreNMIContext* prenmiCtx) {
     prenmiCtx->state.running = false;
     prenmiCtx->state.init = NULL;
     prenmiCtx->state.size = 0;
 }
 
-void PreNMI_Update(PreNMIContext* prenmiCtx)
-{
+void PreNMI_Update(PreNMIContext* prenmiCtx) {
     osSyncPrintf(VT_COL(YELLOW, BLACK) "prenmi_move\n" VT_RST);
 
     // Strings existing only in rodata
     ("../z_prenmi.c");
     ("(int)volume = %d\n");
 
-    if (prenmiCtx->timer == 0)
-    {
+    if (prenmiCtx->timer == 0) {
         ViConfig_UpdateVi(1);
         func_80092320(prenmiCtx);
         return;
@@ -27,39 +24,35 @@ void PreNMI_Update(PreNMIContext* prenmiCtx)
     prenmiCtx->timer--;
 }
 
-void PreNMI_Draw(PreNMIContext* prenmiCtx)
-{
+void PreNMI_Draw(PreNMIContext* prenmiCtx) {
     GraphicsContext* gfxCtx = prenmiCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
     osSyncPrintf(VT_COL(YELLOW, BLACK) "prenmi_draw\n" VT_RST);
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_prenmi.c", 96);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_prenmi.c", 96);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x00, NULL);
     func_80095248(gfxCtx, 0, 0, 0);
     func_800940B0(gfxCtx);
-    gDPSetFillColor(gfxCtx->polyOpa.p++, -1);
-    gDPFillRectangle(gfxCtx->polyOpa.p++, 0, prenmiCtx->timer + 100, 319, prenmiCtx->timer + 100);
+    gDPSetFillColor(gfxCtx->polyOpa.p++,
+                    (GPACK_RGBA5551(0xFF, 0xFF, 0xFF, 1) << 16) | GPACK_RGBA5551(0xFF, 0xFF, 0xFF, 1));
+    gDPFillRectangle(gfxCtx->polyOpa.p++, 0, prenmiCtx->timer + 100, SCREEN_WIDTH - 1, prenmiCtx->timer + 100);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_prenmi.c", 112);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_prenmi.c", 112);
 }
 
-void PreNMI_Main(PreNMIContext* prenmiCtx)
-{
+void PreNMI_Main(PreNMIContext* prenmiCtx) {
     PreNMI_Update(prenmiCtx);
     PreNMI_Draw(prenmiCtx);
 
     prenmiCtx->state.unk_A0 = 1;
 }
 
-void PreNMI_Destroy(PreNMIContext* prenmiCtx)
-{
-
+void PreNMI_Destroy(PreNMIContext* prenmiCtx) {
 }
 
-void PreNMI_Init(PreNMIContext* prenmiCtx)
-{
+void PreNMI_Init(PreNMIContext* prenmiCtx) {
     prenmiCtx->state.main = PreNMI_Main;
     prenmiCtx->state.destroy = PreNMI_Destroy;
     prenmiCtx->timer = 30;
diff --git a/src/code/z_prenmi_buff.c b/src/code/z_prenmi_buff.c
new file mode 100644
index 000000000..9c5924bc9
--- /dev/null
+++ b/src/code/z_prenmi_buff.c
@@ -0,0 +1,27 @@
+#include <ultra64.h>
+#include <global.h>
+
+#define COLD_RESET 0
+#define NMI 1
+
+void PreNmiBuff_Init(PreNmiBuff* this) {
+    this->resetting = false;
+    if (osResetType == COLD_RESET) {
+        this->resetCount = 0;
+        this->duration = 0;
+    } else {
+        this->resetCount++;
+        this->duration += this->resetTime;
+    }
+
+    this->resetTime = 0;
+}
+
+void PreNmiBuff_SetReset(PreNmiBuff* this) {
+    this->resetting = true;
+    this->resetTime = osGetTime();
+}
+
+u32 PreNmiBuff_IsResetting(PreNmiBuff* this) {
+    return this->resetting;
+}
diff --git a/src/code/z_quake.c b/src/code/z_quake.c
new file mode 100644
index 000000000..50db67ec5
--- /dev/null
+++ b/src/code/z_quake.c
@@ -0,0 +1,391 @@
+#include <global.h>
+#include <vt.h>
+
+QuakeRequest sQuakeRequest[4];
+s16 D_80126250 = 1;
+s16 sQuakeRequestCount = 0;
+s16 (*sQuakeCallbacks[])(QuakeRequest*, ShakeInfo*) = {
+    NULL, Quake_Callback1, Quake_Callback2, Quake_Callback3, Quake_Callback4, Quake_Callback5, Quake_Callback6,
+};
+
+Vec3f* Quake_AddVec(Vec3f* dst, Vec3f* arg1, struct_80045714* arg2) {
+    Vec3f vec1;
+    Vec3f vec2;
+
+    func_8007C25C(&vec2, arg2);
+    vec1.x = arg1->x + vec2.x;
+    vec1.y = arg1->y + vec2.y;
+    vec1.z = arg1->z + vec2.z;
+    *dst = vec1;
+    return dst;
+}
+
+void Quake_UpdateShakeInfo(QuakeRequest* req, ShakeInfo* shake, f32 y, f32 x) {
+    Vec3f* unk50 = &req->cam->unk_50;
+    Vec3f* unk5C = &req->cam->unk_5C;
+
+    Vec3f vec;
+    struct_80045714 struc2;
+    struct_80045714 struc1;
+    Vec3f vec2;
+
+    if (req->unk_1C) {
+        vec.x = 0;
+        vec.y = 0;
+        vec.z = 0;
+        func_8007C490(&struc1, unk5C, unk50);
+        struc2.unk_00 = req->y * y;
+        struc2.unk_04 = struc1.unk_04 + req->unk_14.unk_00 + 0x4000;
+        struc2.unk_06 = struc1.unk_06 + req->unk_14.unk_02;
+        Quake_AddVec(&vec, &vec, &struc2);
+        struc2.unk_00 = req->x * x;
+        struc2.unk_04 = struc1.unk_04 + req->unk_14.unk_00;
+        struc2.unk_06 = struc1.unk_06 + req->unk_14.unk_02 + 0x4000;
+        Quake_AddVec(&vec, &vec, &struc2);
+    } else {
+        vec.x = 0;
+        vec.y = req->y * y;
+        vec.z = 0;
+        struc2.unk_00 = req->x * x;
+        struc2.unk_04 = req->unk_14.unk_00;
+        struc2.unk_06 = req->unk_14.unk_02;
+        Quake_AddVec(&vec, &vec, &struc2);
+    }
+
+    vec2 = vec;
+    shake->vec2 = vec2;
+    shake->vec1 = vec2;
+    shake->unk_1A = (f32)0x8000 * y;
+    shake->rotZ = req->rotZ * y;
+    shake->zoom = req->zoom * y;
+}
+
+s16 Quake_Callback1(QuakeRequest* req, ShakeInfo* shake) {
+    u32 pad;
+    if (req->countdown > 0) {
+        f32 a = Math_Sins(req->speed * req->countdown);
+        Quake_UpdateShakeInfo(req, shake, a, Math_Rand_ZeroOne() * a);
+        req->countdown--;
+    }
+    return req->countdown;
+}
+
+s16 Quake_Callback5(QuakeRequest* req, ShakeInfo* shake) {
+    if (req->countdown > 0) {
+        f32 a = Math_Sins(req->speed * req->countdown);
+        Quake_UpdateShakeInfo(req, shake, a, a);
+        req->countdown--;
+    }
+    return req->countdown;
+}
+
+s16 Quake_Callback6(QuakeRequest* req, ShakeInfo* shake) {
+    u32 pad;
+    f32 a;
+
+    req->countdown--;
+    a = Math_Sins(req->speed * ((req->countdown & 0xF) + 500));
+    Quake_UpdateShakeInfo(req, shake, a, Math_Rand_ZeroOne() * a);
+    return 1;
+}
+
+s16 Quake_Callback3(QuakeRequest* req, ShakeInfo* shake) {
+    if (req->countdown > 0) {
+        f32 a = Math_Sins(req->speed * req->countdown) * ((f32)req->countdown / (f32)req->countdownMax);
+        Quake_UpdateShakeInfo(req, shake, a, a);
+        req->countdown--;
+    }
+    return req->countdown;
+}
+
+s16 Quake_Callback2(QuakeRequest* req, ShakeInfo* shake) {
+    if (req->countdown > 0) {
+        f32 a = Math_Rand_ZeroOne();
+        Quake_UpdateShakeInfo(req, shake, a, Math_Rand_ZeroOne() * a);
+        req->countdown--;
+    }
+    return req->countdown;
+}
+
+s16 Quake_Callback4(QuakeRequest* req, ShakeInfo* shake) {
+    if (req->countdown > 0) {
+        f32 a = Math_Rand_ZeroOne() * ((f32)req->countdown / (f32)req->countdownMax);
+        Quake_UpdateShakeInfo(req, shake, a, Math_Rand_ZeroOne() * a);
+        req->countdown--;
+    }
+    return req->countdown;
+}
+
+s16 Quake_GetFreeIndex() {
+    s32 i;
+    s32 ret;
+    s32 min = 0x10000;
+
+    for (i = 0; i < ARRAY_COUNT(sQuakeRequest); i++) {
+        if (sQuakeRequest[i].callbackIdx == 0) {
+            ret = i;
+            min = 0x20000;
+            break;
+        }
+
+        if (sQuakeRequest[i].countdown < min) {
+            min = sQuakeRequest[i].countdown;
+            ret = i;
+        }
+    }
+
+    if (min != 0x20000) {
+        osSyncPrintf(VT_COL(YELLOW, BLACK) "quake: too many request %d is changed new one !!\n" VT_RST, ret);
+    }
+
+    return ret;
+}
+
+QuakeRequest* Quake_AddImpl(Camera* cam, u32 callbackIdx) {
+    s16 idx = Quake_GetFreeIndex();
+    QuakeRequest* req = sQuakeRequest + idx;
+
+    func_80106860(req, 0, sizeof(QuakeRequest)); // memset
+    req->cam = cam;
+    req->camPtrIdx = cam->unk_164;
+    req->callbackIdx = callbackIdx;
+    req->unk_1C = 1;
+    req->randIdx = ((s16)(Math_Rand_ZeroOne() * (f32)0x10000) & ~3) + idx;
+    sQuakeRequestCount++;
+
+    return req;
+}
+
+void Quake_Remove(QuakeRequest* req) {
+    req->callbackIdx = 0;
+    req->countdown = -1;
+    sQuakeRequestCount--;
+}
+
+QuakeRequest* Quake_GetRequest(s16 idx) {
+    QuakeRequest* req = sQuakeRequest + (idx & 3);
+    if (req->callbackIdx == 0) {
+        return NULL;
+    }
+
+    if (idx != req->randIdx) {
+        return NULL;
+    }
+
+    return req;
+}
+
+QuakeRequest* Quake_SetValue(s16 idx, s16 valueType, s16 value) {
+    QuakeRequest* req;
+
+    req = Quake_GetRequest(idx);
+    if (req == NULL) {
+        return NULL;
+    } else {
+        switch (valueType) {
+            case 1:
+                req->speed = value;
+                break;
+            case 2:
+                req->y = value;
+                break;
+            case 4:
+                req->x = value;
+                break;
+            case 8:
+                req->zoom = value;
+                break;
+            case 0x10:
+                req->rotZ = value;
+                break;
+            case 0x20:
+                req->unk_14.unk_00 = value;
+                break;
+            case 0x40:
+                req->unk_14.unk_02 = value;
+                break;
+            case 0x80:
+                req->unk_14.unk_04 = value;
+                break;
+            case 0x100:
+                req->countdown = value;
+                req->countdownMax = req->countdown;
+                break;
+            case 0x200:
+                req->unk_1C = value;
+                break;
+        }
+    }
+}
+
+u32 Quake_SetSpeed(s16 idx, s16 value) {
+    QuakeRequest* req = Quake_GetRequest(idx);
+    if (req) {
+        req->speed = value;
+        return true;
+    }
+    return false;
+}
+
+u32 Quake_SetCountdown(s16 idx, s16 value) {
+    QuakeRequest* req = Quake_GetRequest(idx);
+    if (req) {
+        req->countdown = value;
+        req->countdownMax = req->countdown;
+        return true;
+    }
+    return false;
+}
+
+s16 Quake_GetCountdown(s16 idx) {
+    QuakeRequest* req = Quake_GetRequest(idx);
+    if (req) {
+        return req->countdown;
+    }
+    return 0;
+}
+
+u32 Quake_SetQuakeValues(s16 idx, s16 y, s16 x, s16 zoom, s16 rotZ) {
+    QuakeRequest* req = Quake_GetRequest(idx);
+    if (req) {
+        req->y = y;
+        req->x = x;
+        req->zoom = zoom;
+        req->rotZ = rotZ;
+        return true;
+    }
+    return false;
+}
+
+u32 Quake_SetUnkValues(s16 idx, s16 arg1, SubQuakeRequest14 arg2) {
+    QuakeRequest* req = Quake_GetRequest(idx);
+    if (req) {
+        req->unk_1C = arg1;
+
+        req->unk_14 = arg2;
+        return true;
+    }
+    return false;
+}
+
+void Quake_Init() {
+    s16 i;
+    for (i = 0; i < ARRAY_COUNT(sQuakeRequest); i++) {
+        sQuakeRequest[i].callbackIdx = 0;
+        sQuakeRequest[i].countdown = 0;
+    }
+    D_80126250 = 1;
+    sQuakeRequestCount = 0;
+}
+
+s16 Quake_Add(Camera* cam, u32 callbackIdx) {
+    return Quake_AddImpl(cam, callbackIdx)->randIdx;
+}
+
+u32 Quake_RemoveFromIdx(s16 idx) {
+    QuakeRequest* req = Quake_GetRequest(idx);
+    if (req) {
+        Quake_Remove(req);
+        return true;
+    }
+    return false;
+}
+
+s16 Quake_Calc(Camera* camera, UnkQuakeCalcStruct* camData) {
+    f32 max;
+    f32 max2;
+    QuakeRequest* req;
+    ShakeInfo shake;
+    f32 absSpeedDiv;
+    s16* temp;
+    u32 pad2;
+    s32 idx;
+    s32 ret;
+    u32 eq;
+    Vec3f vec;
+    GlobalContext* globalCtx;
+
+    globalCtx = camera->globalCtx;
+    vec.x = 0.0f;
+    vec.y = 0.0f;
+    vec.z = 0.0f;
+    camData->rotZ = 0;
+    camData->unk_1A = 0;
+    camData->zoom = 0;
+    camData->vec1.x = 0.0f;
+    camData->vec1.y = 0.0f;
+    camData->vec1.z = 0.0f;
+    camData->vec2.x = 0.0f;
+    camData->vec2.y = 0.0f;
+    camData->vec2.z = 0.0f;
+    camData->unk_20 = 0.0f;
+
+    if (sQuakeRequestCount == 0) {
+        return 0;
+    }
+
+    ret = 0;
+    for (idx = 0; idx < ARRAY_COUNT(sQuakeRequest); idx++) {
+        req = &sQuakeRequest[idx];
+        if (req->callbackIdx != 0) {
+            if (globalCtx->cameraCtx.activeCameraPtrs[req->camPtrIdx] == 0) {
+                osSyncPrintf(VT_COL(YELLOW, BLACK) "quake: stopped! 'coz camera [%d] killed!!\n" VT_RST,
+                             req->camPtrIdx);
+                Quake_Remove(req);
+            } else {
+                temp = &camera->unk_164;
+                eq = req->cam->unk_164 != *temp;
+                absSpeedDiv = ABS(req->speed) / (f32)0x8000;
+                if (sQuakeCallbacks[req->callbackIdx](req, &shake) == 0) {
+                    Quake_Remove(req);
+                } else if (eq == 0) {
+                    if (fabsf(camData->vec1.x) < fabsf(shake.vec1.x)) {
+                        camData->vec1.x = shake.vec1.x;
+                    }
+                    if (fabsf(camData->vec1.y) < fabsf(shake.vec1.y)) {
+                        camData->vec1.y = shake.vec1.y;
+                    }
+                    if (fabsf(camData->vec1.z) < fabsf(shake.vec1.z)) {
+                        camData->vec1.z = shake.vec1.z;
+                    }
+                    if (fabsf(camData->vec2.x) < fabsf(shake.vec2.x)) {
+                        camData->vec2.x = shake.vec2.x;
+                    }
+                    if (fabsf(camData->vec2.y) < fabsf(shake.vec2.y)) {
+                        camData->vec2.y = shake.vec2.y;
+                    }
+                    if (fabsf(camData->vec2.z) < fabsf(shake.vec2.z)) {
+                        camData->vec2.z = shake.vec2.z;
+                    }
+                    if (camData->rotZ < shake.rotZ) {
+                        camData->rotZ = shake.rotZ;
+                        camData->unk_1A = shake.unk_1A;
+                    }
+                    if (camData->zoom < shake.zoom) {
+                        camData->zoom = shake.zoom;
+                    }
+
+                    max = func_8007BF90(&shake.vec1, &vec) * absSpeedDiv;
+                    max2 = func_8007BF90(&shake.vec2, &vec) * absSpeedDiv;
+                    if (max < max2) {
+                        max = max2;
+                    }
+                    max2 = (camData->rotZ * 0.005f) * absSpeedDiv;
+                    if (max < max2) {
+                        max = max2;
+                    }
+                    max2 = (camData->zoom * 0.005f) * absSpeedDiv;
+                    if (max < max2) {
+                        max = max2;
+                    }
+                    if (camData->unk_20 < max) {
+                        camData->unk_20 = max;
+                    }
+
+                    ret++;
+                }
+            }
+        }
+    }
+    return ret;
+}
diff --git a/src/code/z_rcp.c b/src/code/z_rcp.c
index 27d750315..754405655 100644
--- a/src/code/z_rcp.c
+++ b/src/code/z_rcp.c
@@ -1,161 +1,1412 @@
 #include <ultra64.h>
 #include <global.h>
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093370.s")
+Gfx sSetupDL[] = {
+    /* 0x00 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineLERP(PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, PRIMITIVE, 0, TEXEL0, 0, 0, 0, 0, COMBINED, 0, 0, 0,
+                       COMBINED),
+    gsDPSetOtherMode(G_AD_NOISE | G_CD_NOISE | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_FOG_SHADE_A | G_RM_ZB_CLD_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_FOG | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x01 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
+    gsDPSetCombineMode(G_CC_SHADE, G_CC_PASS2),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_FOG_SHADE_A | G_RM_AA_OPA_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_CULL_BACK | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x02 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
+    gsDPSetCombineMode(G_CC_SHADE, G_CC_SHADE),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_ZB_OPA_SURF | G_RM_AA_ZB_OPA_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x03 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
+    gsDPSetCombineMode(G_CC_SHADE, G_CC_PASS2),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_FOG_SHADE_A | G_RM_AA_ZB_OPA_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x04 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
+    gsDPSetCombineLERP(PRIMITIVE, 0, SHADE, 0, 0, 0, 0, PRIMITIVE, PRIMITIVE, 0, SHADE, 0, 0, 0, 0, PRIMITIVE),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_ZB_XLU_SURF | G_RM_AA_ZB_XLU_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x05 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEI_PRIM, G_CC_MODULATEI_PRIM),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_ZB_XLU_SURF | G_RM_AA_ZB_XLU_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x06 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_DECALRGBA, G_CC_PASS2),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_FOG_SHADE_A | G_RM_AA_TEX_EDGE2),
+    gsSPLoadGeometryMode(G_SHADE | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x07 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_XLU_SURF | G_RM_AA_XLU_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x08 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
+    gsDPSetCombineMode(G_CC_SHADE, G_CC_SHADE),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_OPA_SURF | G_RM_AA_OPA_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x09 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA, G_CC_MODULATEIA2),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_FOG_SHADE_A | G_RM_AA_XLU_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x0A */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIDECALA, G_CC_MODULATEIDECALA),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_OPA_SURF | G_RM_AA_OPA_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x0B */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIDECALA, G_CC_MODULATEIA_PRIM2),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_FOG_SHADE_A | G_RM_AA_OPA_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_CULL_BACK | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x0C */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEI_PRIM, G_CC_MODULATEI_PRIM),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_OPA_SURF | G_RM_AA_OPA_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x0D */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_XLU_SURF | G_RM_XLU_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x0E */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_DECALRGBA, G_CC_DECALRGBA),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_ZB_TEX_EDGE | G_RM_AA_ZB_TEX_EDGE2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x0F */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_DECALRGBA, G_CC_PASS2),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_FOG_SHADE_A | G_RM_AA_ZB_TEX_EDGE2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x10 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM2),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_FOG_SHADE_A | G_RM_AA_ZB_XLU_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x11 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIDECALA, G_CC_MODULATEIDECALA),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_ZB_TEX_EDGE | G_RM_AA_ZB_TEX_EDGE2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x12 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIDECALA, G_CC_PASS2),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_FOG_SHADE_A | G_RM_AA_ZB_TEX_EDGE2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x13 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | AA_EN | Z_CMP | IM_RD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA |
+                         FORCE_BL | GBL_c1(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_1MA) |
+                         GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_1MA)),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x14 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | G_RM_ZB_CLD_SURF | G_RM_ZB_CLD_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x15 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA, G_CC_MODULATEIA),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_ZB_XLU_SURF | G_RM_AA_ZB_XLU_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x16 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA, G_CC_MODULATEIA2),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_FOG_SHADE_A | G_RM_AA_ZB_XLU_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x17 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIDECALA, G_CC_MODULATEIDECALA),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_ZB_OPA_SURF | G_RM_AA_ZB_OPA_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x18 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIDECALA, G_CC_MODULATEIA2),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_FOG_SHADE_A | G_RM_AA_ZB_OPA_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x19 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIDECALA, G_CC_MODULATEIA_PRIM2),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_FOG_SHADE_A | G_RM_AA_ZB_OPA_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x1A */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEI_PRIM, G_CC_MODULATEI_PRIM),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_ZB_OPA_SURF | G_RM_AA_ZB_OPA_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x1B */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEI_PRIM, G_CC_MODULATEI_PRIM),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_ZB_XLU_SURF | G_RM_AA_ZB_XLU_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x1C */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIDECALA_PRIM, G_CC_MODULATEIDECALA_PRIM),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_RGBA16 | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | G_RM_AA_TEX_EDGE | G_RM_AA_TEX_EDGE2),
+    gsSPLoadGeometryMode(G_SHADE | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x1D */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineLERP(TEXEL0, 0, SHADE, 0, TEXEL0, 0, SHADE, 0, NOISE, 0, COMBINED, 0, 0, 0, 0, COMBINED),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_PASS | G_RM_AA_ZB_OPA_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x1E */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
+    gsDPSetCombineMode(G_CC_PRIMITIVE, G_CC_PRIMITIVE),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_ZB_XLU_LINE | G_RM_AA_ZB_XLU_LINE2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x1F */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_HILITERGBA, G_CC_HILITERGBA),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_ZB_OPA_SURF | G_RM_AA_ZB_OPA_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_LIGHTING | G_TEXTURE_GEN | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x20 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_HILITERGBA, G_CC_HILITERGBA),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_ZB_OPA_SURF | G_RM_AA_ZB_OPA_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR |
+                         G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x21 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineLERP(TEXEL0, 0, PRIMITIVE, SHADE, 1, 0, TEXEL0, SHADE, ENVIRONMENT, COMBINED, TEXEL0, COMBINED,
+                       ENVIRONMENT, COMBINED, TEXEL0, COMBINED),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_PASS | G_RM_AA_ZB_OPA_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR |
+                         G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x22 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_DECALRGB, G_CC_DECALRGB),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | G_RM_OPA_SURF | G_RM_OPA_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x23 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_DECALRGBA, G_CC_DECALRGBA),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_ZB_XLU_DECAL | G_RM_AA_ZB_XLU_DECAL2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x24 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
+    gsDPSetCombineMode(G_CC_SHADE, G_CC_SHADE),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_FILL | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | G_RM_NOOP | G_RM_NOOP2),
+    gsSPLoadGeometryMode(G_SHADE | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x25 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
+    gsDPSetCombineLERP(PRIMITIVE, 0, SHADE, 0, 0, 0, 0, PRIMITIVE, 0, 0, 0, COMBINED, 0, 0, 0, COMBINED),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_FOG_SHADE_A | G_RM_AA_ZB_OPA_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x26 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
+    gsDPSetCombineMode(G_CC_SHADE, G_CC_SHADE),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_ZB_XLU_SURF | G_RM_AA_ZB_XLU_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x27 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | G_RM_XLU_SURF | G_RM_XLU_SURF2),
+    gsSPLoadGeometryMode(G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x28 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineLERP(TEXEL1, TEXEL0, PRIMITIVE_ALPHA, TEXEL0, TEXEL1, TEXEL0, PRIMITIVE, TEXEL0, 0, 0, 0, COMBINED, 0,
+                       0, 0, COMBINED),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_OPA_SURF | G_RM_OPA_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_CULL_FRONT | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x29 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA, G_CC_MODULATEIA),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_ZB_XLU_SURF | G_RM_ZB_XLU_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x2A */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIDECALA, G_CC_MODULATEIDECALA),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_XLU_SURF | G_RM_XLU_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_CULL_BACK | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x2B */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIDECALA_PRIM, G_CC_MODULATEIDECALA_PRIM),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_RGBA16 | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | G_RM_XLU_SURF | G_RM_XLU_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x2C */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA_PRIM, G_CC_PASS2),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_FOG_SHADE_A | G_RM_ZB_OVL_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_FOG | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x2D */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineLERP(0, 0, 0, PRIMITIVE, 0, 0, 0, TEXEL0, 0, 0, 0, PRIMITIVE, 0, 0, 0, TEXEL0),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | G_RM_XLU_SURF | G_RM_XLU_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x2E */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineLERP(0, 0, 0, PRIMITIVE, 0, 0, 0, TEXEL0, 0, 0, 0, PRIMITIVE, 0, 0, 0, TEXEL0),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_XLU_SURF | G_RM_XLU_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x2F */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEI_PRIM, G_CC_MODULATEI_PRIM),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_ZB_XLU_SURF | G_RM_ZB_XLU_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x30 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
+    gsDPSetCombineMode(G_CC_PRIMITIVE, G_CC_PRIMITIVE),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_XLU_SURF | G_RM_AA_XLU_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_CULL_BACK | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x31 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
+    gsDPSetCombineLERP(PRIMITIVE, 0, SHADE, 0, 0, 0, 0, PRIMITIVE, PRIMITIVE, 0, SHADE, 0, 0, 0, 0, PRIMITIVE),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_XLU_SURF | G_RM_AA_XLU_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x32 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | G_RM_OPA_SURF | G_RM_OPA_SURF2),
+    gsSPLoadGeometryMode(G_CULL_BACK),
+    gsSPEndDisplayList(),
+
+    /* 0x33 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_XLU_SURF | G_RM_XLU_SURF2),
+    gsSPLoadGeometryMode(G_CULL_BACK),
+    gsSPEndDisplayList(),
+
+    /* 0x34 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | G_RM_XLU_SURF | G_RM_XLU_SURF2),
+    gsSPLoadGeometryMode(G_CULL_BACK),
+    gsSPEndDisplayList(),
+
+    /* 0x35 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineLERP(TEXEL1, TEXEL0, ENV_ALPHA, TEXEL0, TEXEL1, TEXEL0, ENVIRONMENT, TEXEL0, PRIMITIVE, ENVIRONMENT,
+                       COMBINED, ENVIRONMENT, COMBINED, 0, PRIMITIVE, 0),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | G_RM_OPA_SURF | G_RM_OPA_SURF2),
+    gsSPLoadGeometryMode(G_CULL_BACK),
+    gsSPEndDisplayList(),
+
+    /* 0x36 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineLERP(TEXEL1, TEXEL0, ENV_ALPHA, TEXEL0, TEXEL1, TEXEL0, ENVIRONMENT, TEXEL0, PRIMITIVE, ENVIRONMENT,
+                       COMBINED, ENVIRONMENT, COMBINED, 0, PRIMITIVE, 0),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | G_RM_PASS | G_RM_XLU_SURF2),
+    gsSPLoadGeometryMode(G_CULL_BACK),
+    gsSPEndDisplayList(),
+
+    /* 0x37 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineLERP(TEXEL1, TEXEL0, ENV_ALPHA, TEXEL0, TEXEL1, TEXEL0, ENVIRONMENT, TEXEL0, PRIMITIVE, ENVIRONMENT,
+                       COMBINED, ENVIRONMENT, COMBINED, 0, PRIMITIVE, 0),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | G_RM_PASS | G_RM_XLU_SURF2),
+    gsSPLoadGeometryMode(G_CULL_BACK),
+    gsSPEndDisplayList(),
+
+    /* 0x38 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_POINT | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | G_RM_XLU_SURF | G_RM_XLU_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_CULL_BACK | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x39 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
+    gsDPSetCombineMode(G_CC_PRIMITIVE, G_CC_PRIMITIVE),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | G_RM_CLD_SURF | G_RM_CLD_SURF2),
+    gsSPLoadGeometryMode(G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x3A */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
+    gsDPSetCombineLERP(PRIMITIVE, 0, SHADE, 0, PRIMITIVE, 0, SHADE, 0, PRIMITIVE, 0, SHADE, 0, PRIMITIVE, 0, SHADE, 0),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_CLD_SURF | G_RM_CLD_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x3B */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineLERP(TEXEL0, 0, PRIMITIVE, SHADE, 1, 0, TEXEL0, SHADE, ENVIRONMENT, COMBINED, TEXEL0, COMBINED,
+                       ENVIRONMENT, COMBINED, TEXEL0, COMBINED),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_PASS | G_RM_AA_OPA_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_CULL_BACK | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x3C */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineLERP(PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, ENVIRONMENT,
+                       TEXEL0, ENVIRONMENT, PRIMITIVE, 0, TEXEL0, 0),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_ZB_CLD_SURF | G_RM_ZB_CLD_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x3D */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineLERP(PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, ENVIRONMENT,
+                       TEXEL0, ENVIRONMENT, PRIMITIVE, 0, TEXEL0, 0),
+    gsDPSetOtherMode(G_AD_NOISE | G_CD_NOISE | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_ZB_CLD_SURF | G_RM_ZB_CLD_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x3E */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIDECALA, G_CC_MODULATEIA_PRIM2),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_FOG_SHADE_A | G_RM_AA_ZB_OPA_SURF2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x3F */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | Z_UPD | IM_RD | CVG_DST_SAVE | ZMODE_OPA | FORCE_BL |
+                         GBL_c1(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_1MA) |
+                         GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_1MA)),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x40 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
+    gsDPSetCombineMode(G_CC_DECALRGBA, G_CC_PASS2),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | G_RM_PASS | G_RM_XLU_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x41 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | G_RM_CLD_SURF | G_RM_CLD_SURF2),
+    gsSPLoadGeometryMode(G_SHADE | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x42 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_DECALRGBA, G_CC_DECALRGBA),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | Z_CMP | Z_UPD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA |
+                         ALPHA_CVG_SEL | G_RM_PASS | GBL_c2(G_BL_CLR_IN, G_BL_0, G_BL_CLR_IN, G_BL_1)),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x43 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | Z_CMP | Z_UPD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA |
+                         ALPHA_CVG_SEL | G_RM_PASS | GBL_c2(G_BL_CLR_IN, G_BL_0, G_BL_CLR_IN, G_BL_1)),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x44 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_DECALRGBA, G_CC_DECALRGBA),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | Z_CMP | Z_UPD | IM_RD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA |
+                         ALPHA_CVG_SEL | GBL_c1(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_A_MEM) |
+                         GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_A_MEM)),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x45 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | Z_CMP | Z_UPD | IM_RD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA |
+                         ALPHA_CVG_SEL | GBL_c1(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_A_MEM) |
+                         GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_A_MEM)),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+
+    /* 0x46 */
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
+    gsDPSetCombineMode(G_CC_DECALRGBA, G_CC_DECALRGBA),
+    gsDPSetOtherMode(G_AD_NOTPATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                     G_AC_THRESHOLD | G_ZS_PIXEL | Z_CMP | Z_UPD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA |
+                         ALPHA_CVG_SEL | G_RM_PASS | GBL_c2(G_BL_CLR_IN, G_BL_0, G_BL_CLR_IN, G_BL_1)),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_FOG | G_SHADING_SMOOTH),
+    gsSPEndDisplayList(),
+};
+
+Gfx sFillSetupDL[] = {
+    gsDPPipeSync(),
+    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
+    gsDPSetCombineMode(G_CC_SHADE, G_CC_SHADE),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_FILL | G_PM_NPRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_NOOP | G_RM_NOOP2),
+    gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
+    gsDPSetScissor(G_SC_NON_INTERLACE, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT),
+    gsDPSetBlendColor(0x00, 0x00, 0x00, 0x08),
+    gsSPClipRatio(FRUSTRATIO_2),
+    gsSPEndDisplayList(),
+};
+
+// unused?
+Gfx D_80127030[] = {
+    gsDPPipeSync(),
+    gsDPSetFillColor((GPACK_RGBA5551(0xFF, 0xFF, 0xF0, 0) << 16) | GPACK_RGBA5551(0xFF, 0xFF, 0xF0, 0)),
+    gsDPFillRectangle(0, 0, SCREEN_WIDTH - 1, SCREEN_HEIGHT - 1),
+    gsDPSetDepthSource(G_ZS_PIXEL),
+    gsDPPipeSync(),
+    gsSPEndDisplayList(),
+};
+
+// unused?
+Gfx D_80127060[] = {
+    gsDPPipeSync(),
+    gsDPSetCycleType(G_CYC_FILL),
+    gsDPSetRenderMode(G_RM_NOOP, G_RM_NOOP2),
+    gsDPSetFillColor((GPACK_RGBA5551(0x00, 0x00, 0x00, 1) << 16) | GPACK_RGBA5551(0x00, 0x00, 0x00, 1)),
+    gsDPFillRectangle(0, 0, SCREEN_WIDTH - 1, SCREEN_HEIGHT - 1),
+    gsDPPipeSync(),
+    gsSPEndDisplayList(),
+};
+
+Gfx gEmptyDL[] = {
+    gsSPEndDisplayList(),
+};
+
+Gfx* Gfx_SetFog(Gfx* gfx, s32 r, s32 g, s32 b, s32 a, s32 n, s32 f) {
+    if (f == n) {
+        f++;
+    }
+
+    if (n == f) {
+        __assert("n != f", "../z_rcp.c", 1155);
+    }
+
+    gDPSetFogColor(gfx++, r, g, b, a);
+
+    if (n >= 1000) {
+        gSPFogFactor(gfx++, 0, 0); // gSPFogPosition(gfx++, ?, ?)
+    } else if (n >= 997) {
+        gSPFogFactor(gfx++, 0x7FFF, 0x8100); // gSPFogPosition(gfx++, ?, ?)
+    } else if (n < 0) {
+        gSPFogFactor(gfx++, 0, 255); // gSPFogPosition(gfx++, ?, ?)
+    } else {
+        gSPFogPosition(gfx++, n, f);
+    }
+
+    return gfx;
+}
+
+Gfx* Gfx_SetFogWithSync(Gfx* gfx, s32 r, s32 g, s32 b, s32 a, s32 n, s32 f) {
+    if (f == n) {
+        f++;
+    }
+
+    if (n == f) {
+        __assert("n != f", "../z_rcp.c", 1187);
+    }
+
+    gDPPipeSync(gfx++);
+    gDPSetFogColor(gfx++, r, g, b, a);
+
+    if (n >= 1000) {
+        gSPFogFactor(gfx++, 0, 0); // gSPFogPosition(gfx++, ?, ?)
+    } else if (n >= 997) {
+        gSPFogFactor(gfx++, 0x7FFF, 0x8100); // gSPFogPosition(gfx++, ?, ?)
+    } else if (n < 0) {
+        gSPFogFactor(gfx++, 0, 255); // gSPFogPosition(gfx++, ?, ?)
+    } else {
+        gSPFogPosition(gfx++, n, f);
+    }
+
+    return gfx;
+}
+
+Gfx* Gfx_SetFog2(Gfx* gfx, s32 r, s32 g, s32 b, s32 a, s32 n, s32 f) {
+    return Gfx_SetFog(gfx, r, g, b, a, n, f);
+}
+
+Gfx* Gfx_CallSetupDLImpl(Gfx* gfx, u32 i) {
+    gSPDisplayList(gfx++, &sSetupDL[6 * i]);
+    return gfx;
+}
+
+Gfx* Gfx_CallSetupDL(Gfx* gfx, u32 i) {
+    return Gfx_CallSetupDLImpl(gfx, i);
+}
+
+void Gfx_CallSetupDLAtPtr(Gfx** gfxp, u32 i) {
+    *gfxp = Gfx_CallSetupDL(*gfxp, i);
+}
+
+Gfx* func_800937C0(Gfx* gfx) {
+    gSPDisplayList(gfx++, &sSetupDL[6 * 0x39]);
+    return gfx;
+}
+
+Gfx* func_800937E4(Gfx* gfx) {
+    gSPDisplayList(gfx++, &sSetupDL[6 * 0x39]);
+    return gfx;
+}
+
+Gfx* func_80093808(Gfx* gfx) {
+    gSPDisplayList(gfx++, &sSetupDL[6 * 0x34]);
+    gDPSetColorDither(gfx++, G_CD_DISABLE);
+    return gfx;
+}
+
+void func_80093848(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1293);
+
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x3A]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1297);
+}
+
+void func_800938B4(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1309);
+
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x39]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1313);
+}
+
+void func_80093920(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1325);
+
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x32]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1329);
+}
+
+void func_8009398C(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1341);
+
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x33]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1345);
+}
+
+void func_800939F8(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1357);
+
+    gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x34]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1361);
+}
+
+void func_80093A64(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1373);
+
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x35]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1377);
+}
+
+void func_80093AD0(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1389);
+
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x36]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1393);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_8009352C.s")
+void func_80093B3C(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093708.s")
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1405);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_8009373C.s")
+    gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x37]);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093774.s")
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1409);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093794.s")
+void func_80093BA8(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_800937C0.s")
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1421);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_800937E4.s")
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x1A]);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093808.s")
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1425);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093848.s")
+void func_80093C14(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_800938B4.s")
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1439);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093920.s")
+    gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x19]);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_8009398C.s")
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1443);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_800939F8.s")
+void func_80093C80(GlobalContext* globalCtx) {
+    GraphicsContext* gfxCtx;
+    Gfx* dispRefs[5];
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093A64.s")
+    gfxCtx = globalCtx->state.gfxCtx;
+    func_80093D18(gfxCtx);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093AD0.s")
+    if (globalCtx->roomCtx.curRoom.unk_03 == 3) {
+        Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1460);
+
+        gDPSetColorDither(gfxCtx->polyOpa.p++, G_CD_DISABLE);
+
+        Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1462);
+    }
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093B3C.s")
+void func_80093D18(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093BA8.s")
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1475);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093C14.s")
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x19]);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093C80.s")
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1479);
+}
+
+void func_80093D84(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1491);
+
+    gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x19]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1495);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093D18.s")
+void func_80093DF0(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093D84.s")
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1507);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093DF0.s")
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x1F]);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093E5C.s")
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1511);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093EC8.s")
+void func_80093E5C(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093F34.s")
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1523);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093F58.s")
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x20]);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093F7C.s")
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1527);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80093FD8.s")
+void func_80093EC8(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094044.s")
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1539);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_800940B0.s")
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x21]);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_8009411C.s")
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1543);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094140.s")
+Gfx* func_80093F34(Gfx* gfx) {
+    gSPDisplayList(gfx++, &sSetupDL[6 * 0x40]);
+    return gfx;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_800941AC.s")
+Gfx* func_80093F58(Gfx* gfx) {
+    gSPDisplayList(gfx++, &sSetupDL[6 * 0x22]);
+    return gfx;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094218.s")
+void func_80093F7C(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094284.s")
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1569);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_800942F0.s")
+    gfxCtx->polyOpa.p = func_80093F58(gfxCtx->polyOpa.p);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_8009435C.s")
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1573);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_800943C8.s")
+void func_80093FD8(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094434.s")
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1585);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_800944A0.s")
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x23]);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_800944C4.s")
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1589);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094520.s")
+void func_80094044(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_8009457C.s")
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1601);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_800945A0.s")
+    gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x2C]);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_8009460C.s")
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1605);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094678.s")
+void func_800940B0(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_800946E4.s")
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1617);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094708.s")
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x24]);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_8009472C.s")
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1621);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_8009476C.s")
+Gfx* func_8009411C(Gfx* gfx) {
+    gSPDisplayList(gfx++, &sSetupDL[6 * 0x1C]);
+    return gfx;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_800947AC.s")
+void func_80094140(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094944.s")
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1640);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094968.s")
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x1C]);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_800949A8.s")
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1644);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094A14.s")
+void func_800941AC(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094A80.s")
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1651);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094AEC.s")
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x2B]);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094B58.s")
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1655);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094BC4.s")
+void func_80094218(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094C50.s")
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1670);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094CBC.s")
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x2D]);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094D28.s")
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1674);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094D4C.s")
+void func_80094284(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094DB8.s")
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1681);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80094E54.s")
+    gSPDisplayList(gfxCtx->overlay.p++, &sSetupDL[6 * 0x2E]);
 
-Gfx* func_80094E78(GraphicsContext* gfxCtx, u32 x, u32 y)
-{
-    return Draw_TexScroll(gfxCtx, x, y, 0, 0);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1685);
 }
 
-Gfx* Draw_TexScroll(GraphicsContext* gfxCtx, u32 x, u32 y, s32 width, s32 height)
-{
+void func_800942F0(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1700);
+
+    gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x26]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1704);
+}
+
+void func_8009435C(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1722);
+
+    gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x04]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1726);
+}
+
+void func_800943C8(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1758);
+
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x25]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1762);
+}
+
+void func_80094434(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1775);
+
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x02]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1779);
+}
+
+Gfx* func_800944A0(Gfx* gfx) {
+    gSPDisplayList(gfx++, &sSetupDL[6 * 0x27]);
+    return gfx;
+}
+
+void func_800944C4(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1799);
+
+    gfxCtx->polyOpa.p = func_800944A0(gfxCtx->polyOpa.p);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1801);
+}
+
+void func_80094520(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1809);
+
+    gfxCtx->overlay.p = func_800944A0(gfxCtx->overlay.p);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1811);
+}
+
+void func_8009457C(Gfx** gfxp) {
+    Gfx* gfx = *gfxp;
+    gSPDisplayList(gfx++, &sSetupDL[6 * 0x27]);
+    *gfxp = gfx;
+}
+
+void func_800945A0(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1837);
+
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x28]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1841);
+}
+
+void func_8009460C(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1853);
+
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x29]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1857);
+}
+
+void func_80094678(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1869);
+
+    gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x2F]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1873);
+}
+
+Gfx* func_800946E4(Gfx* gfx) {
+    gSPDisplayList(gfx++, &sSetupDL[6 * 0x42]);
+    return gfx;
+}
+
+Gfx* func_80094708(Gfx* gfx) {
+    gSPDisplayList(gfx++, &sSetupDL[6 * 0x43]);
+    return gfx;
+}
+
+Gfx* func_8009472C(Gfx* gfx) {
+    gSPDisplayList(gfx++, &sSetupDL[6 * 0x44]);
+    gDPSetColorDither(gfx++, G_CD_DISABLE);
+    return gfx;
+}
+
+Gfx* func_8009476C(Gfx* gfx) {
+    gSPDisplayList(gfx++, &sSetupDL[6 * 0x45]);
+    gDPSetColorDither(gfx++, G_CD_DISABLE);
+    return gfx;
+}
+
+Gfx* func_800947AC(Gfx* gfx) {
+    gSPDisplayList(gfx++, &sSetupDL[6 * 0x41]);
+    gDPSetColorDither(gfx++, G_CD_DISABLE);
+
+    // clang-format off
+    switch (HREG(21)) {
+        case 1: gDPSetAlphaDither(gfx++, G_AD_DISABLE); break;
+        case 2: gDPSetAlphaDither(gfx++, G_AD_PATTERN); break;
+        case 3: gDPSetAlphaDither(gfx++, G_AD_NOTPATTERN); break;
+        case 4: gDPSetAlphaDither(gfx++, G_AD_NOISE); break;
+    }
+
+    switch (HREG(22)) {
+        case 1: gDPSetColorDither(gfx++, G_CD_DISABLE); break;
+        case 2: gDPSetColorDither(gfx++, G_CD_MAGICSQ); break;
+        case 3: gDPSetColorDither(gfx++, G_CD_BAYER); break;
+        case 4: gDPSetColorDither(gfx++, G_CD_NOISE); break;
+    }
+    // clang-format on
+
+    return gfx;
+}
+
+Gfx* func_80094944(Gfx* gfx) {
+    gSPDisplayList(gfx++, &sSetupDL[6 * 0x46]);
+    return gfx;
+}
+
+Gfx* func_80094968(Gfx* gfx) {
+    gSPDisplayList(gfx++, &sSetupDL[6 * 0x14]);
+    gDPSetColorDither(gfx++, G_CD_DISABLE);
+    return gfx;
+}
+
+void func_800949A8(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1953);
+
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x2A]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1957);
+}
+
+void func_80094A14(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1964);
+
+    gSPDisplayList(gfxCtx->overlay.p++, &sSetupDL[6 * 0x2A]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1968);
+}
+
+void func_80094A80(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1992);
+
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x30]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1996);
+}
+
+void func_80094AEC(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 2008);
+
+    gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x31]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 2012);
+}
+
+void func_80094B58(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 2024);
+
+    gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x1B]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 2028);
+}
+
+void func_80094BC4(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 2040);
+
+    gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x3C]);
+    gDPSetColorDither(gfxCtx->polyXlu.p++, G_CD_DISABLE);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 2043);
+}
+
+void func_80094C50(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 2056);
+
+    gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x3D]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 2058);
+}
+
+void func_80094CBC(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 2086);
+
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x38]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 2090);
+}
+
+void func_80094D28(Gfx** gfxp) {
+    Gfx* gfx = *gfxp;
+    gSPDisplayList(gfx++, &sSetupDL[6 * 0x38]);
+    *gfxp = gfx;
+}
+
+void func_80094D4C(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 2112);
+
+    gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x3B]);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 2116);
+}
+
+#ifdef NON_MATCHING
+// regalloc differences
+void Gfx_BranchTexScroll(Gfx** gfxp, u32 x, u32 y, s32 width, s32 height) {
+    Gfx* displayList = Graph_DlistAlloc(gfxp, 3 * sizeof(Gfx));
+
+    gDPTileSync(displayList);
+    gDPSetTileSize(displayList + 1, 0, x, y, (x + ((width - 1) << 2)), (y + ((height - 1) << 2)));
+    gSPEndDisplayList(displayList + 2);
+}
+#else
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/Gfx_BranchTexScroll.s")
+#endif
+
+void func_80094E54(Gfx** gfxp, u32 x, u32 y) {
+    Gfx_BranchTexScroll(gfxp, x, y, 0, 0);
+}
+
+Gfx* func_80094E78(GraphicsContext* gfxCtx, u32 x, u32 y) {
+    return Gfx_TexScroll(gfxCtx, x, y, 0, 0);
+}
+
+Gfx* Gfx_TexScroll(GraphicsContext* gfxCtx, u32 x, u32 y, s32 width, s32 height) {
     Gfx* displayList = Graph_Alloc(gfxCtx, 3 * sizeof(Gfx));
 
     x %= 2048;
     y %= 2048;
 
     gDPTileSync(displayList);
-    gDPSetTileSize(displayList+1, 0, x, y,
-                   (x+((width-1)<<2)), (y+((height-1)<<2)));
-    gSPEndDisplayList(displayList+2);
+    gDPSetTileSize(displayList + 1, 0, x, y, (x + ((width - 1) << 2)), (y + ((height - 1) << 2)));
+    gSPEndDisplayList(displayList + 2);
 
     return displayList;
 }
 
-Gfx* Draw_TwoTexScroll(GraphicsContext* gfxCtx, s32 tile1, u32 x1, u32 y1, s32 width1, s32 height1,
-                       s32 tile2, u32 x2, u32 y2, s32 width2, s32 height2)
-{
+Gfx* Gfx_TwoTexScroll(GraphicsContext* gfxCtx, s32 tile1, u32 x1, u32 y1, s32 width1, s32 height1, s32 tile2, u32 x2,
+                      u32 y2, s32 width2, s32 height2) {
     Gfx* displayList = Graph_Alloc(gfxCtx, 5 * sizeof(Gfx));
 
     x1 %= 2048;
@@ -164,20 +1415,16 @@ Gfx* Draw_TwoTexScroll(GraphicsContext* gfxCtx, s32 tile1, u32 x1, u32 y1, s32 w
     y2 %= 2048;
 
     gDPTileSync(displayList);
-    gDPSetTileSize(displayList+1, tile1, x1, y1,
-                   (x1+((width1-1)<<2)), (y1+((height1-1)<<2)));
-    gDPTileSync(displayList+2);
-    gDPSetTileSize(displayList+3, tile2, x2, y2,
-                   (x2+((width2-1)<<2)), (y2+((height2-1)<<2)));
-    gSPEndDisplayList(displayList+4);
+    gDPSetTileSize(displayList + 1, tile1, x1, y1, (x1 + ((width1 - 1) << 2)), (y1 + ((height1 - 1) << 2)));
+    gDPTileSync(displayList + 2);
+    gDPSetTileSize(displayList + 3, tile2, x2, y2, (x2 + ((width2 - 1) << 2)), (y2 + ((height2 - 1) << 2)));
+    gSPEndDisplayList(displayList + 4);
 
     return displayList;
 }
 
-Gfx* Draw_TwoTexScrollEnvColor(GraphicsContext* gfxCtx, s32 tile1, u32 x1, u32 y1, s32 width1, s32 height1,
-                               s32 tile2, u32 x2, u32 y2, s32 width2, s32 height2,
-                               s32 red, s32 green, s32 blue, s32 alpha)
-{
+Gfx* Gfx_TwoTexScrollEnvColor(GraphicsContext* gfxCtx, s32 tile1, u32 x1, u32 y1, s32 width1, s32 height1, s32 tile2,
+                              u32 x2, u32 y2, s32 width2, s32 height2, s32 r, s32 g, s32 b, s32 a) {
     Gfx* displayList = Graph_Alloc(gfxCtx, 6 * sizeof(Gfx));
 
     x1 %= 2048;
@@ -186,20 +1433,131 @@ Gfx* Draw_TwoTexScrollEnvColor(GraphicsContext* gfxCtx, s32 tile1, u32 x1, u32 y
     y2 %= 2048;
 
     gDPTileSync(displayList);
-    gDPSetTileSize(displayList+1, tile1, x1, y1,
-                   (x1+((width1-1)<<2)), (y1+((height1-1)<<2)));
-    gDPTileSync(displayList+2);
-    gDPSetTileSize(displayList+3, tile2, x2, y2,
-                   (x2+((width2-1)<<2)), (y2+((height2-1)<<2)));
-    gDPSetEnvColor(displayList+4, red, green, blue, alpha);
-    gSPEndDisplayList(displayList+5);
+    gDPSetTileSize(displayList + 1, tile1, x1, y1, (x1 + ((width1 - 1) << 2)), (y1 + ((height1 - 1) << 2)));
+    gDPTileSync(displayList + 2);
+    gDPSetTileSize(displayList + 3, tile2, x2, y2, (x2 + ((width2 - 1) << 2)), (y2 + ((height2 - 1) << 2)));
+    gDPSetEnvColor(displayList + 4, r, g, b, a);
+    gSPEndDisplayList(displayList + 5);
+
+    return displayList;
+}
+
+Gfx* Gfx_EnvColor(GraphicsContext* gfxCtx, s32 r, s32 g, s32 b, s32 a) {
+    Gfx* displayList = Graph_Alloc(gfxCtx, 2 * sizeof(Gfx));
+
+    gDPSetEnvColor(displayList, r, g, b, a);
+    gSPEndDisplayList(displayList + 1);
 
     return displayList;
 }
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_800951D0.s")
+void func_80095248(GraphicsContext* gfxCtx, u8 r, u8 g, u8 b) {
+    Gfx* dispRefs[5];
+    s32 ret;
+
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 2386);
+
+    gSPDisplayList(gfxCtx->polyOpa.p++, sFillSetupDL);
+    gSPDisplayList(gfxCtx->polyXlu.p++, sFillSetupDL);
+    gSPDisplayList(gfxCtx->overlay.p++, sFillSetupDL);
+    gDPSetScissorFrac(gfxCtx->polyOpa.p++, G_SC_NON_INTERLACE, 0, 0, (s32)gScreenWidth * 4.0f,
+                      (s32)gScreenHeight * 4.0f);
+    gDPSetScissorFrac(gfxCtx->polyXlu.p++, G_SC_NON_INTERLACE, 0, 0, (s32)gScreenWidth * 4.0f,
+                      (s32)gScreenHeight * 4.0f);
+    gDPSetScissorFrac(gfxCtx->overlay.p++, G_SC_NON_INTERLACE, 0, 0, (s32)gScreenWidth * 4.0f,
+                      (s32)gScreenHeight * 4.0f);
+
+    gDPSetColorImage(gfxCtx->polyOpa.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->curFrameBuffer);
+    gDPSetColorImage(gfxCtx->polyOpa.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->curFrameBuffer);
+    gDPSetColorImage(gfxCtx->polyXlu.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->curFrameBuffer);
+    gDPSetColorImage(gfxCtx->overlay.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->curFrameBuffer);
+
+    gDPSetDepthImage(gfxCtx->polyOpa.p++, gZBuffer);
+    gDPSetDepthImage(gfxCtx->polyXlu.p++, gZBuffer);
+    gDPSetDepthImage(gfxCtx->overlay.p++, gZBuffer);
+
+    if ((R_PAUSE_MENU_MODE < 2) && (D_80161490 < 2)) {
+        ret = func_800B38FC();
+
+        if (HREG(80) == 16) {
+            if (HREG(95) != 16) {
+                HREG(81) = 3;
+                HREG(82) = 3;
+                HREG(83) = 0;
+                HREG(84) = 0;
+                HREG(85) = 0;
+                HREG(86) = 0;
+                HREG(87) = 0;
+                HREG(88) = 0;
+                HREG(89) = 0;
+                HREG(90) = 0;
+                HREG(91) = 0;
+                HREG(92) = 0;
+                HREG(93) = 0;
+                HREG(94) = 0;
+                HREG(95) = 16;
+            }
+
+            if (HREG(81) & 1) {
+                HREG(83) = ret;
+            }
+
+            if (HREG(81) & 2) {
+                HREG(84) = r;
+                HREG(85) = g;
+                HREG(86) = b;
+            }
+
+            if (HREG(82) & 1) {
+                ret = HREG(83);
+            }
+
+            if (HREG(82) & 2) {
+                r = HREG(84);
+                g = HREG(85);
+                b = HREG(86);
+            }
+        }
+
+        gDPSetColorImage(gfxCtx->polyOpa.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gZBuffer);
+        gDPSetCycleType(gfxCtx->polyOpa.p++, G_CYC_FILL);
+        gDPSetRenderMode(gfxCtx->polyOpa.p++, G_RM_NOOP, G_RM_NOOP2);
+        gDPSetFillColor(gfxCtx->polyOpa.p++,
+                        (GPACK_RGBA5551(0xFF, 0xFF, 0xF0, 0) << 16) | GPACK_RGBA5551(0xFF, 0xFF, 0xF0, 0));
+        gDPFillRectangle(gfxCtx->polyOpa.p++, 0, ret, gScreenWidth - 1, gScreenHeight - ret - 1);
+        gDPPipeSync(gfxCtx->polyOpa.p++);
+
+        gDPSetColorImage(gfxCtx->polyOpa.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->curFrameBuffer);
+        gDPSetCycleType(gfxCtx->polyOpa.p++, G_CYC_FILL);
+        gDPSetRenderMode(gfxCtx->polyOpa.p++, G_RM_NOOP, G_RM_NOOP2);
+        gDPSetFillColor(gfxCtx->polyOpa.p++, (GPACK_RGBA5551(r, g, b, 1) << 16) | GPACK_RGBA5551(r, g, b, 1));
+        gDPFillRectangle(gfxCtx->polyOpa.p++, 0, ret, gScreenWidth - 1, gScreenHeight - ret - 1);
+        gDPPipeSync(gfxCtx->polyOpa.p++);
+
+        if (ret > 0) {
+            gDPPipeSync(gfxCtx->overlay.p++);
+            gDPSetCycleType(gfxCtx->overlay.p++, G_CYC_FILL);
+            gDPSetRenderMode(gfxCtx->overlay.p++, G_RM_NOOP, G_RM_NOOP2);
+            gDPSetFillColor(gfxCtx->overlay.p++, (GPACK_RGBA5551(r, g, b, 1) << 16) | GPACK_RGBA5551(r, g, b, 1));
+            gDPFillRectangle(gfxCtx->overlay.p++, 0, 0, gScreenWidth - 1, ret - 1);
+            gDPFillRectangle(gfxCtx->overlay.p++, 0, gScreenHeight - ret, gScreenWidth - 1, gScreenHeight - 1);
+            gDPPipeSync(gfxCtx->overlay.p++);
+        }
+    }
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 2497);
+}
+
+void func_80095974(GraphicsContext* gfxCtx) {
+    Gfx* dispRefs[5];
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80095248.s")
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 2503);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_rcp/func_80095974.s")
+    gSPDisplayList(gfxCtx->polyOpa.p++, sFillSetupDL);
+    gDPSetScissorFrac(gfxCtx->polyOpa.p++, G_SC_NON_INTERLACE, 0, 0, (s32)gScreenWidth * 4.0f,
+                      (s32)gScreenHeight * 4.0f);
+    gDPSetDepthImage(gfxCtx->polyOpa.p++, gZBuffer);
+    gDPSetColorImage(gfxCtx->polyOpa.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->curFrameBuffer);
 
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 2513);
+}
diff --git a/src/code/z_room.c b/src/code/z_room.c
index bbcb3d6f4..690ce974c 100644
--- a/src/code/z_room.c
+++ b/src/code/z_room.c
@@ -9,55 +9,48 @@ void func_80096F6C(GlobalContext* globalCtx, Room* room, u32 flags);
 Vec3f D_801270A0 = { 0.0f, 0.0f, 0.0f };
 
 // unused
-Gfx D_801270B0[] =
-{
+Gfx D_801270B0[] = {
     gsDPPipeSync(),
     gsSPClearGeometryMode(G_ZBUFFER | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD),
     gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
-    gsDPSetCombineLERP(0, 0, 0, SHADE, 0, 0, 0, SHADE, 0, 0, 0, SHADE, 0, 0, 0, SHADE),
-    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP |
-                     G_TT_NONE | G_TL_TILE | G_TD_CLAMP | G_TP_PERSP | G_CYC_FILL | G_PM_NPRIMITIVE,
+    gsDPSetCombineMode(G_CC_SHADE, G_CC_SHADE),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_FILL | G_PM_NPRIMITIVE,
                      G_AC_NONE | G_ZS_PIXEL | G_RM_NOOP | G_RM_NOOP2),
     gsSPLoadGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
-    gsDPSetScissor(G_SC_NON_INTERLACE, 0, 0, 320, 240),
+    gsDPSetScissor(G_SC_NON_INTERLACE, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT),
     gsSPClipRatio(FRUSTRATIO_1),
     gsSPEndDisplayList(),
 };
 
-void (*sRoomDrawHandlers[])(GlobalContext* globalCtx, Room* room, u32 flags) =
-{
+void (*sRoomDrawHandlers[])(GlobalContext* globalCtx, Room* room, u32 flags) = {
     func_80095AB4,
     func_80096F6C,
     func_80095D04,
 };
 
-void func_80095AA0(GlobalContext* globalCtx, Room* room, UNK_TYPE arg2, UNK_TYPE arg3)
-{
-
+void func_80095AA0(GlobalContext* globalCtx, Room* room, UNK_TYPE arg2, UNK_TYPE arg3) {
 }
 
 // Room Draw Polygon Type 0
-void func_80095AB4(GlobalContext* globalCtx, Room* room, u32 flags)
-{
+void func_80095AB4(GlobalContext* globalCtx, Room* room, u32 flags) {
     s32 i;
     PolygonType0* polygon0;
     PolygonDlist* polygonDlist;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 193);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_room.c", 193);
 
-    if (flags & 1)
-    {
+    if (flags & 1) {
         func_800342EC(&D_801270A0, globalCtx);
         gSPSegment(gfxCtx->polyOpa.p++, 0x03, room->segment);
         func_80093C80(globalCtx);
         gSPMatrix(gfxCtx->polyOpa.p++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
     }
 
-    if (flags & 2)
-    {
+    if (flags & 2) {
         func_8003435C(&D_801270A0, globalCtx);
         gSPSegment(gfxCtx->polyXlu.p++, 0x03, room->segment);
         func_80093D84(globalCtx->state.gfxCtx);
@@ -66,35 +59,34 @@ void func_80095AB4(GlobalContext* globalCtx, Room* room, u32 flags)
 
     polygon0 = &room->mesh->polygon0;
     polygonDlist = SEGMENTED_TO_VIRTUAL(polygon0->start);
-    for (i = 0; i < polygon0->num; i++)
-    {
-        if ((flags & 1) && (polygonDlist->opa != NULL))
+    for (i = 0; i < polygon0->num; i++) {
+        if ((flags & 1) && (polygonDlist->opa != NULL)) {
             gSPDisplayList(gfxCtx->polyOpa.p++, polygonDlist->opa);
+        }
 
-        if ((flags & 2) && (polygonDlist->xlu != NULL))
+        if ((flags & 2) && (polygonDlist->xlu != NULL)) {
             gSPDisplayList(gfxCtx->polyXlu.p++, polygonDlist->xlu);
+        }
 
         polygonDlist++;
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 239);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_room.c", 239);
 }
 
 #define SHAPE_SORT_MAX 64
 
-typedef struct struct_80095D04
-{
+typedef struct struct_80095D04 {
     /* 0x00 */ PolygonDlist2* unk_00;
-    /* 0x04 */ f32            unk_04;
+    /* 0x04 */ f32 unk_04;
     /* 0x08 */ struct struct_80095D04* unk_08;
     /* 0x0C */ struct struct_80095D04* unk_0C;
 } struct_80095D04; // size = 0x10
 
 // Room Draw Polygon Type 2
 #ifdef NON_MATCHING
-// this function still needs some work
-void func_80095D04(GlobalContext* globalCtx, Room* room, u32 flags)
-{
+// this function still needs some work but it should be functionally equivalent
+void func_80095D04(GlobalContext* globalCtx, Room* room, u32 flags) {
     PolygonType2* polygon2;
     PolygonDlist2* polygonDlist;
     struct_80095D04 spB8[SHAPE_SORT_MAX];
@@ -113,23 +105,21 @@ void func_80095D04(GlobalContext* globalCtx, Room* room, u32 flags)
     f32 temp_f0;
     f32 temp_f2;
     GraphicsContext* gfxCtx;
-    Gfx* sp5C[4];
+    Gfx* dispRefs[4];
 
     spB0 = NULL;
     spB4 = NULL;
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(sp5C, globalCtx->state.gfxCtx, "../z_room.c", 287);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_room.c", 287);
 
-    if (flags & 1)
-    {
+    if (flags & 1) {
         func_800342EC(&D_801270A0, globalCtx);
         gSPSegment(gfxCtx->polyOpa.p++, 0x03, room->segment);
         func_80093C80(globalCtx);
         gSPMatrix(gfxCtx->polyOpa.p++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
     }
 
-    if (flags & 2)
-    {
+    if (flags & 2) {
         func_8003435C(&D_801270A0, globalCtx);
         gSPSegment(gfxCtx->polyXlu.p++, 0x03, room->segment);
         func_80093D84(globalCtx->state.gfxCtx);
@@ -139,58 +129,51 @@ void func_80095D04(GlobalContext* globalCtx, Room* room, u32 flags)
     spA4 = &spB8[0];
     polygonDlist = SEGMENTED_TO_VIRTUAL(room->mesh->polygon2.start);
     polygon2 = &room->mesh->polygon2;
-    if (polygon2->num > SHAPE_SORT_MAX)
+    if (polygon2->num > SHAPE_SORT_MAX) {
         __assert("polygon2->num <= SHAPE_SORT_MAX", "../z_room.c", 317);
+    }
 
     sp78 = polygonDlist;
-    for (sp9C = 0; sp9C < polygon2->num; sp9C++)
-    {
+    for (sp9C = 0; sp9C < polygon2->num; sp9C++) {
         sp90.x = polygonDlist->pos.x;
         sp90.y = polygonDlist->pos.y;
         sp90.z = polygonDlist->pos.z;
         func_800A6E10(&globalCtx->mf_11D60, &sp90, &sp84, &sp80);
         temp_f0 = polygonDlist->unk_06;
-        if (-temp_f0 < sp84.z)
-        {
+        if (-temp_f0 < sp84.z) {
             temp_f2 = sp84.z - temp_f0;
-            if (temp_f2 < globalCtx->lightCtx.unk_0C)
-            {
+            if (temp_f2 < globalCtx->lightCtx.unk_0C) {
                 spA4->unk_00 = polygonDlist;
                 spA4->unk_04 = temp_f2;
                 phi_v0 = spB4;
-                if (spB4 == 0)
-                {
+                if (spB4 == 0) {
                     spB0 = spA4;
                     spB4 = spA4;
                     spA4->unk_0C = NULL;
                     spA4->unk_08 = NULL;
-                }
-                else
-                {
-                    do
-                    {
-                        if (spA4->unk_04 < phi_v0->unk_04)
+                } else {
+                    do {
+                        if (spA4->unk_04 < phi_v0->unk_04) {
                             break;
+                        }
                         phi_v0 = phi_v0->unk_0C;
                     } while (phi_v0 != NULL);
 
-                    if (phi_v0 == NULL)
-                    {
+                    if (phi_v0 == NULL) {
                         spA4->unk_08 = spB0;
                         spA4->unk_0C = NULL;
                         spB0->unk_0C = spA4;
                         spB0 = spA4;
-                    }
-                    else
-                    {
+                    } else {
                         phi_a0 = phi_v0->unk_08;
                         spA4->unk_08 = phi_a0;
-                        if (phi_a0 == NULL)
+                        if (phi_a0 == NULL) {
                             spB4 = spA4;
-                        else
+                        } else {
                             phi_a0->unk_0C = spA4;
+                        }
                         phi_v0->unk_08 = spA4;
-                        spA4->unk_0C = (void *) phi_v0;
+                        spA4->unk_0C = (void*)phi_v0;
                     }
                 }
                 spA4 = spA4++;
@@ -202,37 +185,35 @@ void func_80095D04(GlobalContext* globalCtx, Room* room, u32 flags)
     iREG(87) = polygon2->num;
 
     sp9C = 1;
-    while (spB4 != NULL)
-    {
+    while (spB4 != NULL) {
         phi_s0 = spB4->unk_00;
-        if (iREG(86) != 0)
-        {
+        if (iREG(86) != 0) {
             phi_v1 = 0;
-            while (phi_v1 < polygon2->num)
-            {
-                if (phi_s0 == sp78)
+            while (phi_v1 < polygon2->num) {
+                if (phi_s0 == sp78) {
                     break;
+                }
                 phi_v1++;
                 sp78++;
             }
 
-            if (((iREG(86) == 1) && (iREG(89) > sp9C)) ||
-                ((iREG(86) == 2) && (iREG(89) == sp9C)))
-            {
-                if ((flags & 1) && (phi_s0->opa != NULL))
+            if (((iREG(86) == 1) && (iREG(89) > sp9C)) || ((iREG(86) == 2) && (iREG(89) == sp9C))) {
+                if ((flags & 1) && (phi_s0->opa != NULL)) {
                     gSPDisplayList(gfxCtx->polyOpa.p++, phi_s0->opa);
+                }
 
-                if ((flags & 2) && (phi_s0->xlu != NULL))
+                if ((flags & 2) && (phi_s0->xlu != NULL)) {
                     gSPDisplayList(gfxCtx->polyXlu.p++, phi_s0->xlu);
+                }
             }
-        }
-        else
-        {
-            if ((flags & 1) && (phi_s0->opa != NULL))
+        } else {
+            if ((flags & 1) && (phi_s0->opa != NULL)) {
                 gSPDisplayList(gfxCtx->polyOpa.p++, phi_s0->opa);
+            }
 
-            if ((flags & 2) && (phi_s0->xlu != NULL))
+            if ((flags & 2) && (phi_s0->xlu != NULL)) {
                 gSPDisplayList(gfxCtx->polyXlu.p++, phi_s0->xlu);
+            }
         }
 
         spB4 = spB4->unk_0C;
@@ -241,7 +222,7 @@ void func_80095D04(GlobalContext* globalCtx, Room* room, u32 flags)
 
     iREG(88) = sp9C - 1;
 
-    func_800C6B54(sp5C, globalCtx->state.gfxCtx, "../z_room.c", 430);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_room.c", 430);
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_room/func_80095D04.s")
@@ -251,14 +232,12 @@ void func_80095D04(GlobalContext* globalCtx, Room* room, u32 flags)
 
 #ifdef NON_MATCHING
 // long multiplication by 64 doesn't quite match
-s32 func_80096238(void* data)
-{
+s32 func_80096238(void* data) {
     OSTime timeBefore;
     OSTime timeAfter;
     OSTime time;
 
-    if (*(u32*)data == JPEG_MARKER)
-    {
+    if (*(u32*)data == JPEG_MARKER) {
         // Translates to: "EXPANDING JPEG DATA"
         osSyncPrintf("JPEGデータを展開します\n");
         // Translates to: "JPEG DATA ADDRESS %08x"
@@ -267,8 +246,7 @@ s32 func_80096238(void* data)
         osSyncPrintf("ワークバッファアドレス（Ｚバッファ）%08x\n", gZBuffer);
 
         timeBefore = osGetTime();
-        if (!func_8006E418(data, gZBuffer, gGfxSPTaskOutputBuffer, sizeof(gGfxSPTaskOutputBuffer)))
-        {
+        if (!func_8006E418(data, gZBuffer, gGfxSPTaskOutputBuffer, sizeof(gGfxSPTaskOutputBuffer))) {
             timeAfter = osGetTime();
             time = ((timeAfter - timeBefore) * 64) / 3000;
 
@@ -280,9 +258,7 @@ s32 func_80096238(void* data)
             osSyncPrintf("元のバッファのサイズが150キロバイト無いと暴走するでしょう。\n");
 
             bcopy(gZBuffer, data, sizeof(gZBuffer));
-        }
-        else
-        {
+        } else {
             // Translates to: "FAILURE! WHY IS IT 〜"
             osSyncPrintf("失敗！なんで〜\n");
         }
@@ -296,8 +272,8 @@ s32 func_80096238(void* data)
 
 #ifdef NON_MATCHING
 // pointer arithmetic doesn't quite match
-void func_8009638C(Gfx** displayList, u32 source, u32 tlut, u16 width, u16 height, u8 fmt, u8 siz, u16 mode0, u16 tlutCount, f32 frameX, f32 frameY)
-{
+void func_8009638C(Gfx** displayList, u32 source, u32 tlut, u16 width, u16 height, u8 fmt, u8 siz, u16 mode0,
+                   u16 tlutCount, f32 frameX, f32 frameY) {
     Gfx* displayListHead;
     uObjBg* bg;
 
@@ -305,7 +281,7 @@ void func_8009638C(Gfx** displayList, u32 source, u32 tlut, u16 width, u16 heigh
     func_80096238(SEGMENTED_TO_VIRTUAL(source));
 
     displayListHead++;
-    gSPBranchList(displayListHead, displayListHead+5);
+    gSPBranchList(displayListHead, displayListHead + 5);
     bg = (void*)displayListHead;
     bg->b.imageX = 0;
     bg->b.imageW = width * 4;
@@ -320,46 +296,33 @@ void func_8009638C(Gfx** displayList, u32 source, u32 tlut, u16 width, u16 heigh
     bg->b.imagePal = 0;
     bg->b.imageFlip = 0;
 
-    if (fmt == G_IM_FMT_CI)
-    {
-        displayListHead = (void*)(bg+1);
+    if (fmt == G_IM_FMT_CI) {
+        displayListHead = (void*)(bg + 1);
         gDPLoadTLUT(displayListHead++, tlutCount, 256, tlut);
-    }
-    else
-    {
-        displayListHead = (void*)(bg+1);
+    } else {
+        displayListHead = (void*)(bg + 1);
         gDPPipeSync(displayListHead++);
     }
 
-    if ((fmt == G_IM_FMT_RGBA) && (SREG(26) == 0))
-    {
+    if ((fmt == G_IM_FMT_RGBA) && (SREG(26) == 0)) {
         bg->b.frameW = width * 4;
         bg->b.frameH = height * 4;
         func_80104B00(bg);
-        gDPSetOtherMode(displayListHead++,
-                        mode0 | G_AD_PATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_CONV | G_TF_POINT |
-                        G_TT_NONE | G_TL_TILE | G_TD_CLAMP | G_TP_NONE | G_CYC_COPY | G_PM_NPRIMITIVE,
+        gDPSetOtherMode(displayListHead++, mode0 | G_TL_TILE | G_TD_CLAMP | G_TP_NONE | G_CYC_COPY | G_PM_NPRIMITIVE,
                         G_AC_THRESHOLD | G_ZS_PIXEL | G_RM_NOOP | G_RM_NOOP2);
         gSPBgRectCopy(displayListHead++, bg);
-    }
-    else
-    {
+    } else {
         bg->s.frameW = width * 4;
         bg->s.frameH = height * 4;
         bg->s.scaleW = 1024;
         bg->s.scaleH = 1024;
         bg->s.imageYorig = bg->b.imageY;
-        gDPSetOtherMode(displayListHead++,
-                        mode0 | G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_POINT |
-                        G_TT_NONE | G_TL_TILE | G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
-                        G_AC_THRESHOLD | G_ZS_PIXEL | AA_EN |
-                        CVG_DST_CLAMP | ZMODE_OPA | CVG_X_ALPHA | ALPHA_CVG_SEL |
-                        GBL_c1(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_BL, G_BL_1MA) |
-                        GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_BL, G_BL_1MA));
-        gDPSetCombineLERP(displayListHead++,
-                          0, 0, 0, TEXEL0, 0, 0, 0, 1,
-                          0, 0, 0, TEXEL0, 0, 0, 0, 1);
-        gSPObjRenderMode(displayListHead++, 0x0C); // unknown object render mode?
+        gDPSetOtherMode(displayListHead++, mode0 | G_TL_TILE | G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                        G_AC_THRESHOLD | G_ZS_PIXEL | AA_EN | CVG_DST_CLAMP | ZMODE_OPA | CVG_X_ALPHA | ALPHA_CVG_SEL |
+                            GBL_c1(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_BL, G_BL_1MA) |
+                            GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_BL, G_BL_1MA));
+        gDPSetCombineLERP(displayListHead++, 0, 0, 0, TEXEL0, 0, 0, 0, 1, 0, 0, 0, TEXEL0, 0, 0, 0, 1);
+        gSPObjRenderMode(displayListHead++, G_OBJRM_ANTIALIAS | G_OBJRM_BILERP);
         gSPBgRect1Cyc(displayListHead++, bg);
     }
 
@@ -367,13 +330,13 @@ void func_8009638C(Gfx** displayList, u32 source, u32 tlut, u16 width, u16 heigh
     *displayList = displayListHead;
 }
 #else
-void func_8009638C(Gfx** displayList, u32 source, u32 tlut, u16 width, u16 height, u8 fmt, u8 siz, u16 mode0, u16 tlutCount, f32 frameX, f32 frameY);
+void func_8009638C(Gfx** displayList, u32 source, u32 tlut, u16 width, u16 height, u8 fmt, u8 siz, u16 mode0,
+                   u16 tlutCount, f32 frameX, f32 frameY);
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_room/func_8009638C.s")
 #endif
 
 // Room Draw Polygon Type 1 - Single Format
-void func_80096680(GlobalContext* globalCtx, Room* room, u32 flags)
-{
+void func_80096680(GlobalContext* globalCtx, Room* room, u32 flags) {
     Camera* camera;
     Gfx* spA8;
     PolygonType1* polygon1;
@@ -383,10 +346,10 @@ void func_80096680(GlobalContext* globalCtx, Room* room, u32 flags)
     u32 sp94;
     u32 sp90;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 628);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_room.c", 628);
 
     camera = globalCtx->cameraCtx.activeCameraPtrs[globalCtx->cameraCtx.unk_5C0];
     polygon1 = &room->mesh->polygon1;
@@ -396,62 +359,53 @@ void func_80096680(GlobalContext* globalCtx, Room* room, u32 flags)
     sp94 = (flags & 1) && polygonDlist->opa && !(SREG(25) & 2);
     sp90 = (flags & 2) && polygonDlist->xlu && !(SREG(25) & 4);
 
-    if (sp94 || sp98)
-    {
+    if (sp94 || sp98) {
         gSPSegment(gfxCtx->polyOpa.p++, 0x03, room->segment);
 
-        if (sp94)
-        {
+        if (sp94) {
             func_80093D18(globalCtx->state.gfxCtx);
             gSPMatrix(gfxCtx->polyOpa.p++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
             gSPDisplayList(gfxCtx->polyOpa.p++, polygonDlist->opa);
         }
 
-        if (sp98)
-        {
+        if (sp98) {
             // gSPLoadUcodeL(gfxCtx->polyOpa.p++, rspS2DEX)?
             gSPLoadUcodeEx(gfxCtx->polyOpa.p++, D_00113070, D_001579A0, 0x800);
 
-            if (1)
-            {
+            if (1) {
                 Vec3f sp60;
                 spA8 = gfxCtx->polyOpa.p;
                 func_8005AFB4(&sp60, camera);
-                func_8009638C(&spA8, polygon1->single.source, polygon1->single.tlut,
-                              polygon1->single.width, polygon1->single.height,
-                              polygon1->single.fmt, polygon1->single.siz,
+                func_8009638C(&spA8, polygon1->single.source, polygon1->single.tlut, polygon1->single.width,
+                              polygon1->single.height, polygon1->single.fmt, polygon1->single.siz,
                               polygon1->single.mode0, polygon1->single.tlutCount,
-                              (sp60.x + sp60.z) * 1.2f + sp60.y * 0.6f,
-                              sp60.y * 2.4f + (sp60.x + sp60.z) * 0.3f);
+                              (sp60.x + sp60.z) * 1.2f + sp60.y * 0.6f, sp60.y * 2.4f + (sp60.x + sp60.z) * 0.3f);
                 gfxCtx->polyOpa.p = spA8;
             }
 
-            // gSPLoadUcode(gfxCtx->polyOpa.p++, func_800D2E14(), func_800D2E20())?
-            gSPLoadUcodeEx(gfxCtx->polyOpa.p++, func_800D2E14(), func_800D2E20(), 0x800);
+            // gSPLoadUcode(gfxCtx->polyOpa.p++, SysUcode_GetUcode(), SysUcode_GetUcodeData())?
+            gSPLoadUcodeEx(gfxCtx->polyOpa.p++, SysUcode_GetUcode(), SysUcode_GetUcodeData(), 0x800);
         }
     }
 
-    if (sp90)
-    {
+    if (sp90) {
         gSPSegment(gfxCtx->polyXlu.p++, 0x03, room->segment);
         func_80093D84(globalCtx->state.gfxCtx);
         gSPMatrix(gfxCtx->polyXlu.p++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
         gSPDisplayList(gfxCtx->polyXlu.p++, polygonDlist->xlu);
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 691);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_room.c", 691);
 }
 
-typedef struct
-{
+typedef struct {
     char unk_00[0x0E];
-    s16  unk_0E;
+    s16 unk_0E;
 } struct_80041C10_ret;
 
 extern struct_80041C10_ret* func_80041C10(CollisionContext*, s32, s32);
 
-BgImage* func_80096A74(PolygonType1* polygon1, GlobalContext* globalCtx)
-{
+BgImage* func_80096A74(PolygonType1* polygon1, GlobalContext* globalCtx) {
     Camera* camera;
     s32 camId;
     s16 camId2;
@@ -462,17 +416,18 @@ BgImage* func_80096A74(PolygonType1* polygon1, GlobalContext* globalCtx)
     camera = globalCtx->cameraCtx.activeCameraPtrs[globalCtx->cameraCtx.unk_5C0];
     camId = camera->unk_148;
     camId2 = func_80041C10(&globalCtx->colCtx, camId, 50)->unk_0E;
-    if (camId2 >= 0)
+    if (camId2 >= 0) {
         camId = camId2;
+    }
 
     player = PLAYER;
     player->actor.params = (player->actor.params & 0xFF00) | camId;
 
     bgImage = SEGMENTED_TO_VIRTUAL(polygon1->multi.list);
-    for (i = 0; i < polygon1->multi.count; i++)
-    {
-        if (bgImage->id == camId)
+    for (i = 0; i < polygon1->multi.count; i++) {
+        if (bgImage->id == camId) {
             return bgImage;
+        }
         bgImage++;
     }
 
@@ -486,8 +441,7 @@ BgImage* func_80096A74(PolygonType1* polygon1, GlobalContext* globalCtx)
 // Room Draw Polygon Type 1 - Multi Format
 #ifdef NON_MATCHING
 // regalloc differences
-void func_80096B6C(GlobalContext* globalCtx, Room* room, u32 flags)
-{
+void func_80096B6C(GlobalContext* globalCtx, Room* room, u32 flags) {
     Camera* camera;
     Gfx* spA8;
     BgImage* bgImage;
@@ -498,10 +452,10 @@ void func_80096B6C(GlobalContext* globalCtx, Room* room, u32 flags)
     u32 sp90;
     u32 sp8C;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 752);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_room.c", 752);
 
     camera = globalCtx->cameraCtx.activeCameraPtrs[globalCtx->cameraCtx.unk_5C0];
     sp98 = (camera->unk_142 ^ 25) == 0;
@@ -512,78 +466,68 @@ void func_80096B6C(GlobalContext* globalCtx, Room* room, u32 flags)
     sp90 = (flags & 1) && polygonDlist->opa && !(SREG(25) & 2);
     sp8C = (flags & 2) && polygonDlist->xlu && !(SREG(25) & 4);
 
-    if (sp90 || sp94)
-    {
+    if (sp90 || sp94) {
         gSPSegment(gfxCtx->polyOpa.p++, 0x03, room->segment);
 
-        if (sp90)
-        {
+        if (sp90) {
             func_80093D18(globalCtx->state.gfxCtx);
             gSPMatrix(gfxCtx->polyOpa.p++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
             gSPDisplayList(gfxCtx->polyOpa.p++, polygonDlist->opa);
         }
 
-        if (sp94)
-        {
+        if (sp94) {
             // gSPLoadUcodeL(gfxCtx->polyOpa.p++, rspS2DEX)?
             gSPLoadUcodeEx(gfxCtx->polyOpa.p++, D_00113070, D_001579A0, 0x800);
 
-            if (1)
-            {
+            if (1) {
                 Vec3f sp5C;
                 spA8 = gfxCtx->polyOpa.p;
                 func_8005AFB4(&sp5C, camera);
-                func_8009638C(&spA8, bgImage->source, bgImage->tlut,
-                              bgImage->width, bgImage->height,
-                              bgImage->fmt, bgImage->siz,
-                              bgImage->mode0, bgImage->tlutCount,
-                              (sp5C.x + sp5C.z) * 1.2f + sp5C.y * 0.6f,
-                              sp5C.y * 2.4f + (sp5C.x + sp5C.z) * 0.3f);
+                func_8009638C(&spA8, bgImage->source, bgImage->tlut, bgImage->width, bgImage->height, bgImage->fmt,
+                              bgImage->siz, bgImage->mode0, bgImage->tlutCount,
+                              (sp5C.x + sp5C.z) * 1.2f + sp5C.y * 0.6f, sp5C.y * 2.4f + (sp5C.x + sp5C.z) * 0.3f);
                 gfxCtx->polyOpa.p = spA8;
             }
 
-            // gSPLoadUcode(gfxCtx->polyOpa.p++, func_800D2E14(), func_800D2E20())?
-            gSPLoadUcodeEx(gfxCtx->polyOpa.p++, func_800D2E14(), func_800D2E20(), 0x800);
+            // gSPLoadUcode(gfxCtx->polyOpa.p++, SysUcode_GetUcode(), SysUcode_GetUcodeData())?
+            gSPLoadUcodeEx(gfxCtx->polyOpa.p++, SysUcode_GetUcode(), SysUcode_GetUcodeData(), 0x800);
         }
     }
 
-    if (sp8C)
-    {
+    if (sp8C) {
         gSPSegment(gfxCtx->polyXlu.p++, 0x03, room->segment);
         func_80093D84(globalCtx->state.gfxCtx);
         gSPMatrix(gfxCtx->polyXlu.p++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
         gSPDisplayList(gfxCtx->polyXlu.p++, polygonDlist->xlu);
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 819);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_room.c", 819);
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_room/func_80096B6C.s")
 #endif
 
 // Room Draw Polygon Type 1
-void func_80096F6C(GlobalContext* globalCtx, Room* room, u32 flags)
-{
+void func_80096F6C(GlobalContext* globalCtx, Room* room, u32 flags) {
     PolygonType1* polygon1 = &room->mesh->polygon1;
 
-    if (polygon1->format == 1)
+    if (polygon1->format == 1) {
         func_80096680(globalCtx, room, flags);
-    else if (polygon1->format == 2)
+    } else if (polygon1->format == 2) {
         func_80096B6C(globalCtx, room, flags);
-    else
+    } else {
         LogUtils_HungupThread("../z_room.c", 841);
+    }
 }
 
-void func_80096FD4(GlobalContext* globalCtx, Room* room)
-{
+void func_80096FD4(GlobalContext* globalCtx, Room* room) {
     room->num = -1;
     room->segment = NULL;
 }
 
 #ifdef NON_MATCHING
 // regalloc differences
-u32 func_80096FE8(GlobalContext* globalCtx, RoomContext* roomCtx)
-{
+u32 func_80096FE8(GlobalContext* globalCtx, RoomContext* roomCtx) {
     RomFile* roomList;
     TransitionActorEntry* transitionActor;
     s32 i, j;
@@ -598,32 +542,31 @@ u32 func_80096FE8(GlobalContext* globalCtx, RoomContext* roomCtx)
 
     maxRoomSize = 0;
     roomList = globalCtx->roomList;
-    for (i = 0; i < globalCtx->nbRooms; i++)
-    {
+    for (i = 0; i < globalCtx->nbRooms; i++) {
         roomSize = roomList[i].vromEnd - roomList[i].vromStart;
         osSyncPrintf("ROOM%d size=%d\n", i, roomSize);
-        if (maxRoomSize < roomSize)
+        if (maxRoomSize < roomSize) {
             maxRoomSize = roomSize;
+        }
     }
 
-    if (globalCtx->nbTransitionActors != 0)
-    {
+    if (globalCtx->nbTransitionActors != 0) {
         j = 0;
         roomList = globalCtx->roomList;
         transitionActor = &globalCtx->transitionActorList[0];
-        LogUtils_LogThreadId("../z_room.c", 912);
-        osSyncPrintf("game_play->room_rom_address.num = %d\n", globalCtx->nbRooms);
-        for (j = 0; j < globalCtx->nbTransitionActors; j++)
-        {
+        LOG_NUM("game_play->room_rom_address.num", globalCtx->nbRooms, "../z_room.c", 912);
+
+        for (j = 0; j < globalCtx->nbTransitionActors; j++) {
             frontRoom = transitionActor->frontRoom;
             backRoom = transitionActor->backRoom;
             frontRoomSize = (frontRoom < 0) ? 0 : roomList[frontRoom].vromEnd - roomList[frontRoom].vromStart;
             backRoomSize = (backRoom < 0) ? 0 : roomList[backRoom].vromEnd - roomList[backRoom].vromStart;
             cumulRoomSize = (frontRoom != backRoom) ? frontRoomSize + backRoomSize : frontRoomSize;
-            osSyncPrintf("DOOR%d=<%d> ROOM1=<%d, %d> ROOM2=<%d, %d>\n",
-                         j, cumulRoomSize, frontRoom, frontRoomSize, backRoom, backRoomSize);
-            if (maxRoomSize < cumulRoomSize)
+            osSyncPrintf("DOOR%d=<%d> ROOM1=<%d, %d> ROOM2=<%d, %d>\n", j, cumulRoomSize, frontRoom, frontRoomSize,
+                         backRoom, backRoomSize);
+            if (maxRoomSize < cumulRoomSize) {
                 maxRoomSize = cumulRoomSize;
+            }
             transitionActor++;
         }
     }
@@ -641,10 +584,11 @@ u32 func_80096FE8(GlobalContext* globalCtx, RoomContext* roomCtx)
     roomCtx->unk_30 = 0;
     roomCtx->status = 0;
 
-    if (gSaveContext.respawn_flag > 0)
-        nextRoomNum = gSaveContext.respawn[gSaveContext.respawn_flag-1].room_index;
-    else
+    if (gSaveContext.respawn_flag > 0) {
+        nextRoomNum = gSaveContext.respawn[gSaveContext.respawn_flag - 1].room_index;
+    } else {
         nextRoomNum = globalCtx->setupEntranceList[globalCtx->curSpawn].room;
+    }
     func_8009728C(globalCtx, roomCtx, nextRoomNum);
 
     return maxRoomSize;
@@ -653,30 +597,29 @@ u32 func_80096FE8(GlobalContext* globalCtx, RoomContext* roomCtx)
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_room/func_80096FE8.s")
 #endif
 
-s32 func_8009728C(GlobalContext* globalCtx, RoomContext* roomCtx, s32 roomNum)
-{
+s32 func_8009728C(GlobalContext* globalCtx, RoomContext* roomCtx, s32 roomNum) {
     u32 size;
 
-    if (0) ; // Necessary to match
+    if (0) {} // Necessary to match
 
-    if (roomCtx->status == 0)
-    {
+    if (roomCtx->status == 0) {
         roomCtx->prevRoom = roomCtx->curRoom;
         roomCtx->curRoom.num = roomNum;
         roomCtx->curRoom.segment = NULL;
         roomCtx->status = 1;
 
-        if (roomNum >= globalCtx->nbRooms)
+        if (roomNum >= globalCtx->nbRooms) {
             __assert("read_room_ID < game_play->room_rom_address.num", "../z_room.c", 1009);
+        }
 
         size = globalCtx->roomList[roomNum].vromEnd - globalCtx->roomList[roomNum].vromStart;
         roomCtx->unk_34 = (void*)ALIGN16((s32)roomCtx->bufPtrs[roomCtx->unk_30] - ((size + 8) * roomCtx->unk_30 + 7));
 
-        if (0) ; // Also necessary to match
+        if (0) {} // Also necessary to match
 
         osCreateMesgQueue(&roomCtx->loadQueue, &roomCtx->loadMsg, 1);
-        DmaMgr_SendRequest2(&roomCtx->dmaRequest, roomCtx->unk_34, globalCtx->roomList[roomNum].vromStart, size,
-                            0, &roomCtx->loadQueue, NULL, "../z_room.c", 1036);
+        DmaMgr_SendRequest2(&roomCtx->dmaRequest, roomCtx->unk_34, globalCtx->roomList[roomNum].vromStart, size, 0,
+                            &roomCtx->loadQueue, NULL, "../z_room.c", 1036);
         roomCtx->unk_30 ^= 1;
 
         return 1;
@@ -685,12 +628,9 @@ s32 func_8009728C(GlobalContext* globalCtx, RoomContext* roomCtx, s32 roomNum)
     return 0;
 }
 
-s32 func_800973FC(GlobalContext* globalCtx, RoomContext* roomCtx)
-{
-    if (roomCtx->status == 1)
-    {
-        if (!osRecvMesg(&roomCtx->loadQueue, NULL, OS_MESG_NOBLOCK))
-        {
+s32 func_800973FC(GlobalContext* globalCtx, RoomContext* roomCtx) {
+    if (roomCtx->status == 1) {
+        if (!osRecvMesg(&roomCtx->loadQueue, NULL, OS_MESG_NOBLOCK)) {
             roomCtx->status = 0;
             roomCtx->curRoom.segment = roomCtx->unk_34;
             gSegments[3] = PHYSICAL_TO_VIRTUAL2(roomCtx->unk_34);
@@ -708,25 +648,24 @@ s32 func_800973FC(GlobalContext* globalCtx, RoomContext* roomCtx)
     return 1;
 }
 
-void Room_Draw(GlobalContext* globalCtx, Room* room, u32 flags)
-{
-    if (room->segment != NULL)
-    {
+void Room_Draw(GlobalContext* globalCtx, Room* room, u32 flags) {
+    if (room->segment != NULL) {
         gSegments[3] = PHYSICAL_TO_VIRTUAL(room->segment);
-        if (room->mesh->polygon.type >= ARRAY_COUNTU(sRoomDrawHandlers))
+        if (room->mesh->polygon.type >= ARRAY_COUNTU(sRoomDrawHandlers)) {
             __assert("this->ground_shape->polygon.type < number(Room_Draw_Proc)", "../z_room.c", 1125);
+        }
         sRoomDrawHandlers[room->mesh->polygon.type](globalCtx, room, flags);
     }
 }
 
-void func_80097534(GlobalContext* globalCtx, RoomContext* roomCtx)
-{
+void func_80097534(GlobalContext* globalCtx, RoomContext* roomCtx) {
     roomCtx->prevRoom.num = -1;
     roomCtx->prevRoom.segment = NULL;
     func_80031B14(globalCtx, &globalCtx->actorCtx);
     Actor_SpawnTransitionActors(globalCtx, &globalCtx->actorCtx);
     func_80080E04(globalCtx, roomCtx->curRoom.num);
-    if (!((globalCtx->sceneNum >= SCENE_SPOT00) && (globalCtx->sceneNum <= SCENE_SPOT20)))
+    if (!((globalCtx->sceneNum >= SCENE_SPOT00) && (globalCtx->sceneNum <= SCENE_SPOT20))) {
         func_800807A0(globalCtx);
+    }
     func_800F66C0(globalCtx->roomCtx.curRoom.echo);
 }
diff --git a/src/code/z_sample.c b/src/code/z_sample.c
index 441d8451a..ee7bf3caa 100644
--- a/src/code/z_sample.c
+++ b/src/code/z_sample.c
@@ -1,17 +1,109 @@
 #include <ultra64.h>
 #include <global.h>
+#include <PR/os_cont.h>
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_sample/func_800975D0.s")
+void Sample_Calc(SampleContext* this) {
+    if (!~(this->state.input[0].padPressed | ~START_BUTTON)) {
+        SET_NEXT_GAMESTATE(&this->state, func_800BCA64, GlobalContext);
+        this->state.running = false;
+    }
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_sample/func_80097604.s")
+// very close from matching, the only difference is the place of "mtx" in the stack
+#ifdef NON_MATCHING
+void Sample_Draw(SampleContext* this) {
+    u32 pad;
+    GraphicsContext* gfxCtx = this->state.gfxCtx;
+    View* view = &this->view;
+    Gfx* dispRefs[4];
+    Mtx* mtx;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_sample/func_80097820.s")
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_sample.c", 62);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_sample/func_80097848.s")
+    gSPSegment(gfxCtx->polyOpa.p++, 0x00, NULL);
+    gSPSegment(gfxCtx->polyOpa.p++, 0x01, this->staticSegment);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_sample/func_80097850.s")
+    func_80095248(gfxCtx, 0, 0, 0);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_sample/func_80097904.s")
+    view->unk_120 = 7;
+    func_800AAA50(view, 15);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_sample/func_80097974.s")
+    mtx = Graph_Alloc(gfxCtx, sizeof(Mtx));
+    func_80103D58(mtx, SREG(37), SREG(38), SREG(39), 1.0f, SREG(40), SREG(41), SREG(42));
+    gSPMatrix(gfxCtx->polyOpa.p++, mtx, G_MTX_LOAD);
 
+    gfxCtx->polyOpa.p = Gfx_SetFog2(gfxCtx->polyOpa.p, 0xFF, 0xFF, 0xFF, 0, 0, 0);
+    func_80093D18(gfxCtx);
+
+    gDPSetCycleType(gfxCtx->polyOpa.p++, G_CYC_1CYCLE);
+    gDPSetRenderMode(gfxCtx->polyOpa.p++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
+    gDPSetCombineMode(gfxCtx->polyOpa.p++, G_CC_PRIMITIVE, G_CC_PRIMITIVE);
+    gDPSetPrimColor(gfxCtx->polyOpa.p++, 0, 0, 0xFF, 0xFF, 0x00, 0x00);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_sample.c", 111);
+}
+#else
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_sample/Sample_Draw.s")
+#endif
+
+void Sample_Update(SampleContext* this) {
+    Sample_Draw(this);
+    Sample_Calc(this);
+}
+
+void Sample_Destroy(SampleContext* this) {
+}
+
+void Sample_SetupView(SampleContext* this) {
+    View* view;
+    GraphicsContext* gfxCtx;
+    u32 v0[4];
+    Vec3f v1;
+    Vec3f v2;
+    Vec3f v3;
+
+    view = &this->view;
+    gfxCtx = this->state.gfxCtx;
+    func_800AA278(view, gfxCtx);
+
+    // clang-format off
+    v0[1] = SCREEN_HEIGHT; v0[3] = SCREEN_WIDTH; 
+    v0[0] = 0; v0[2] = 0;
+    // clang-format on
+
+    func_800AA4FC(view, &v0);
+    func_800AA460(view, 60, 10, 12800);
+
+    v1.x = 0;
+    v1.y = 0;
+    v2.x = 0;
+    v2.y = 0;
+    v2.z = 0;
+    v3.x = 0;
+    v3.z = 0;
+    v1.z = 3000;
+    v3.y = 1;
+
+    func_800AA358(view, &v1, &v2, &v3);
+}
+
+void Sample_LoadTitleStatic(SampleContext* this) {
+    u32 size = _title_staticSegmentRomEnd - _title_staticSegmentRomStart;
+
+    this->staticSegment = Game_Alloc(&this->state, size, "../z_sample.c", 163);
+    DmaMgr_SendRequest1(this->staticSegment, _title_staticSegmentRomStart, size, "../z_sample.c", 164);
+}
+
+void Sample_Init(SampleContext* this) {
+    this->state.main = Sample_Update;
+    this->state.destroy = Sample_Destroy;
+    R_UPDATE_RATE = 1;
+    Sample_SetupView(this);
+    Sample_LoadTitleStatic(this);
+    SREG(37) = 0;
+    SREG(38) = 0;
+    SREG(39) = 0;
+    SREG(40) = 0;
+    SREG(41) = 0;
+    SREG(42) = 0;
+}
diff --git a/src/code/z_scene.c b/src/code/z_scene.c
index 2bd552296..6ad51d2ee 100644
--- a/src/code/z_scene.c
+++ b/src/code/z_scene.c
@@ -4,26 +4,31 @@
 
 RomFile sNaviMsgFiles[];
 
-s32 Object_Spawn(ObjectContext* objectCtx, s16 objectId)
-{
+s32 Object_Spawn(ObjectContext* objectCtx, s16 objectId) {
     u32 size;
 
     objectCtx->status[objectCtx->num].id = objectId;
     size = gObjectTable[objectId].vromEnd - gObjectTable[objectId].vromStart;
 
-    osSyncPrintf("OBJECT[%d] SIZE %fK SEG=%x\n",
-                 objectId, (f64)(size / 1024.0f), objectCtx->status[objectCtx->num].segment);
+    osSyncPrintf("OBJECT[%d] SIZE %fK SEG=%x\n", objectId, (f64)(size / 1024.0f),
+                 objectCtx->status[objectCtx->num].segment);
 
-    osSyncPrintf("num=%d adrs=%x end=%x\n",
-                 objectCtx->num, (s32)objectCtx->status[objectCtx->num].segment + size, objectCtx->spaceEnd);
+    osSyncPrintf("num=%d adrs=%x end=%x\n", objectCtx->num, (s32)objectCtx->status[objectCtx->num].segment + size,
+                 objectCtx->spaceEnd);
 
-    if (!((objectCtx->num < OBJECT_EXCHANGE_BANK_MAX) && (((s32)objectCtx->status[objectCtx->num].segment + size) < (s32)objectCtx->spaceEnd)))
-        __assert("this->num < OBJECT_EXCHANGE_BANK_MAX && (this->status[this->num].Segment + size) < this->endSegment", "../z_scene.c", 142);
+    if (!((objectCtx->num < OBJECT_EXCHANGE_BANK_MAX) &&
+          (((s32)objectCtx->status[objectCtx->num].segment + size) < (s32)objectCtx->spaceEnd))) {
+        __assert("this->num < OBJECT_EXCHANGE_BANK_MAX && (this->status[this->num].Segment + size) < this->endSegment",
+                 "../z_scene.c", 142);
+    }
 
-    DmaMgr_SendRequest1(objectCtx->status[objectCtx->num].segment, gObjectTable[objectId].vromStart, size, "../z_scene.c", 145);
+    DmaMgr_SendRequest1(objectCtx->status[objectCtx->num].segment, gObjectTable[objectId].vromStart, size,
+                        "../z_scene.c", 145);
 
-    if (objectCtx->num < OBJECT_EXCHANGE_BANK_MAX - 1)
-        objectCtx->status[objectCtx->num + 1].segment = (void*)ALIGN16((s32)objectCtx->status[objectCtx->num].segment + size);
+    if (objectCtx->num < OBJECT_EXCHANGE_BANK_MAX - 1) {
+        objectCtx->status[objectCtx->num + 1].segment =
+            (void*)ALIGN16((s32)objectCtx->status[objectCtx->num].segment + size);
+    }
 
     objectCtx->num++;
     objectCtx->unk_09 = objectCtx->num;
@@ -31,35 +36,33 @@ s32 Object_Spawn(ObjectContext* objectCtx, s16 objectId)
     return objectCtx->num - 1;
 }
 
-void Object_InitBank(GlobalContext* globalCtx, ObjectContext* objectCtx)
-{
+void Object_InitBank(GlobalContext* globalCtx, ObjectContext* objectCtx) {
     GlobalContext* globalCtx2 = globalCtx; // Needs to be a new variable to match (possibly a sub struct?)
     u32 spaceSize;
     s32 i;
 
-    if (globalCtx2->sceneNum == SCENE_SPOT00)
+    if (globalCtx2->sceneNum == SCENE_SPOT00) {
         spaceSize = 1024000;
-    else if (globalCtx2->sceneNum == SCENE_GANON_DEMO)
-    {
-        if (gSaveContext.scene_setup_index != 4)
+    } else if (globalCtx2->sceneNum == SCENE_GANON_DEMO) {
+        if (gSaveContext.scene_setup_index != 4) {
             spaceSize = 1177600;
-        else
+        } else {
             spaceSize = 1024000;
-    }
-    else if (globalCtx2->sceneNum == SCENE_JYASINBOSS)
+        }
+    } else if (globalCtx2->sceneNum == SCENE_JYASINBOSS) {
         spaceSize = 1075200;
-    else if (globalCtx2->sceneNum == SCENE_KENJYANOMA)
+    } else if (globalCtx2->sceneNum == SCENE_KENJYANOMA) {
         spaceSize = 1075200;
-    else if (globalCtx2->sceneNum == SCENE_GANON_BOSS)
+    } else if (globalCtx2->sceneNum == SCENE_GANON_BOSS) {
         spaceSize = 1075200;
-    else
+    } else {
         spaceSize = 1024000;
+    }
 
     objectCtx->num = objectCtx->unk_09 = 0;
     objectCtx->mainKeepIndex = objectCtx->subKeepIndex = 0;
 
-    for (i = 0; i < OBJECT_EXCHANGE_BANK_MAX; i++)
-    {
+    for (i = 0; i < OBJECT_EXCHANGE_BANK_MAX; i++) {
         objectCtx->status[i].id = 0;
     }
 
@@ -68,37 +71,32 @@ void Object_InitBank(GlobalContext* globalCtx, ObjectContext* objectCtx)
     osSyncPrintf("オブジェクト入れ替えバンク情報 %8.3fKB\n", (f64)(spaceSize / 1024.0f));
     osSyncPrintf(VT_RST);
 
-    objectCtx->spaceStart = objectCtx->status[0].segment = Game_Alloc(&globalCtx->state, spaceSize, "../z_scene.c", 219);
+    objectCtx->spaceStart = objectCtx->status[0].segment =
+        Game_Alloc(&globalCtx->state, spaceSize, "../z_scene.c", 219);
     objectCtx->spaceEnd = (void*)((s32)objectCtx->spaceStart + spaceSize);
 
     objectCtx->mainKeepIndex = Object_Spawn(objectCtx, OBJECT_GAMEPLAY_KEEP);
     gSegments[4] = PHYSICAL_TO_VIRTUAL(objectCtx->status[objectCtx->mainKeepIndex].segment);
 }
 
-void Object_UpdateBank(ObjectContext* objectCtx)
-{
+void Object_UpdateBank(ObjectContext* objectCtx) {
     s32 i;
     ObjectStatus* status;
     RomFile* objectFile;
     u32 size;
 
     status = &objectCtx->status[0];
-    for (i = 0; i < objectCtx->num; i++)
-    {
-        if (status->id < 0)
-        {
-            if (status->dmaRequest.vromAddr == 0)
-            {
+    for (i = 0; i < objectCtx->num; i++) {
+        if (status->id < 0) {
+            if (status->dmaRequest.vromAddr == 0) {
                 osCreateMesgQueue(&status->loadQueue, &status->loadMsg, 1);
                 objectFile = &gObjectTable[-status->id];
                 size = objectFile->vromEnd - objectFile->vromStart;
-                osSyncPrintf("OBJECT EXCHANGE BANK-%2d SIZE %8.3fK SEG=%08x\n",
-                             i, (f64)(size / 1024.0f), status->segment);
-                DmaMgr_SendRequest2(&status->dmaRequest, status->segment, objectFile->vromStart, size,
-                                    0, &status->loadQueue, NULL, "../z_scene.c", 266);
-            }
-            else if (!osRecvMesg(&status->loadQueue, NULL, OS_MESG_NOBLOCK))
-            {
+                osSyncPrintf("OBJECT EXCHANGE BANK-%2d SIZE %8.3fK SEG=%08x\n", i, (f64)(size / 1024.0f),
+                             status->segment);
+                DmaMgr_SendRequest2(&status->dmaRequest, status->segment, objectFile->vromStart, size, 0,
+                                    &status->loadQueue, NULL, "../z_scene.c", 266);
+            } else if (!osRecvMesg(&status->loadQueue, NULL, OS_MESG_NOBLOCK)) {
                 status->id = -status->id;
             }
         }
@@ -106,47 +104,43 @@ void Object_UpdateBank(ObjectContext* objectCtx)
     }
 }
 
-s32 Object_GetIndex(ObjectContext* objectCtx, s16 objectId)
-{
+s32 Object_GetIndex(ObjectContext* objectCtx, s16 objectId) {
     s32 i;
 
-    for (i = 0; i < objectCtx->num; i++)
-    {
-        if (ABS(objectCtx->status[i].id) == objectId)
+    for (i = 0; i < objectCtx->num; i++) {
+        if (ABS(objectCtx->status[i].id) == objectId) {
             return i;
+        }
     }
 
     return -1;
 }
 
-s32 Object_IsLoaded(ObjectContext* objectCtx, s32 bankIndex)
-{
-    if (objectCtx->status[bankIndex].id > 0)
+s32 Object_IsLoaded(ObjectContext* objectCtx, s32 bankIndex) {
+    if (objectCtx->status[bankIndex].id > 0) {
         return 1;
-    else
+    } else {
         return 0;
+    }
 }
 
-void func_800981B8(ObjectContext* objectCtx)
-{
+void func_800981B8(ObjectContext* objectCtx) {
     s32 i;
     s32 id;
     u32 size;
 
-    for (i = 0; i < objectCtx->num; i++)
-    {
+    for (i = 0; i < objectCtx->num; i++) {
         id = objectCtx->status[i].id;
         size = gObjectTable[id].vromEnd - gObjectTable[id].vromStart;
-        osSyncPrintf("OBJECT[%d] SIZE %fK SEG=%x\n",
-                     objectCtx->status[i].id, (f64)(size / 1024.0f), objectCtx->status[i].segment);
-        osSyncPrintf("num=%d adrs=%x end=%x\n",
-                     objectCtx->num, (s32)objectCtx->status[i].segment + size, objectCtx->spaceEnd);
+        osSyncPrintf("OBJECT[%d] SIZE %fK SEG=%x\n", objectCtx->status[i].id, (f64)(size / 1024.0f),
+                     objectCtx->status[i].segment);
+        osSyncPrintf("num=%d adrs=%x end=%x\n", objectCtx->num, (s32)objectCtx->status[i].segment + size,
+                     objectCtx->spaceEnd);
         DmaMgr_SendRequest1(objectCtx->status[i].segment, gObjectTable[id].vromStart, size, "../z_scene.c", 342);
     }
 }
 
-void* func_800982FC(ObjectContext* objectCtx, s32 bankIndex, s16 objectId)
-{
+void* func_800982FC(ObjectContext* objectCtx, s32 bankIndex, s16 objectId) {
     ObjectStatus* status = &objectCtx->status[bankIndex];
     RomFile* objectFile = &gObjectTable[objectId];
     u32 size;
@@ -156,14 +150,15 @@ void* func_800982FC(ObjectContext* objectCtx, s32 bankIndex, s16 objectId)
     status->dmaRequest.vromAddr = 0;
 
     size = objectFile->vromEnd - objectFile->vromStart;
-    osSyncPrintf("OBJECT EXCHANGE NO=%2d BANK=%3d SIZE=%8.3fK\n",
-                 bankIndex, objectId, (f64)(size / 1024.0f));
+    osSyncPrintf("OBJECT EXCHANGE NO=%2d BANK=%3d SIZE=%8.3fK\n", bankIndex, objectId, (f64)(size / 1024.0f));
 
-    if (1) // Necessary to match
+    if (1) { // Necessary to match
         nextPtr = (void*)ALIGN16((s32)status->segment + size);
+    }
 
-    if (nextPtr >= objectCtx->spaceEnd)
+    if (nextPtr >= objectCtx->spaceEnd) {
         __assert("nextptr < this->endSegment", "../z_scene.c", 381);
+    }
 
     // Translates to: "OBJECT EXCHANGE FREE SIZE=%08x"
     osSyncPrintf("オブジェクト入れ替え空きサイズ=%08x\n", (s32)objectCtx->spaceEnd - (s32)nextPtr);
@@ -171,25 +166,21 @@ void* func_800982FC(ObjectContext* objectCtx, s32 bankIndex, s16 objectId)
     return nextPtr;
 }
 
-s32 Scene_ExecuteCommands(GlobalContext* globalCtx, SceneCmd* sceneCmd)
-{
+s32 Scene_ExecuteCommands(GlobalContext* globalCtx, SceneCmd* sceneCmd) {
     u32 cmdCode;
 
-    while (1)
-    {
+    while (1) {
         cmdCode = sceneCmd->base.code;
-        osSyncPrintf("*** Scene_Word = { code=%d, data1=%02x, data2=%04x } ***\n",
-                     cmdCode, sceneCmd->base.data1, sceneCmd->base.data2);
+        osSyncPrintf("*** Scene_Word = { code=%d, data1=%02x, data2=%04x } ***\n", cmdCode, sceneCmd->base.data1,
+                     sceneCmd->base.data2);
 
-        if (cmdCode == 0x14)
+        if (cmdCode == 0x14) {
             break;
+        }
 
-        if (cmdCode <= 0x19)
-        {
+        if (cmdCode <= 0x19) {
             gSceneCmdHandlers[cmdCode](globalCtx, sceneCmd);
-        }
-        else
-        {
+        } else {
             osSyncPrintf(VT_FGCOL(RED));
             // Translates to: "code VARIABLE IS ABNORMAL"
             osSyncPrintf("code の値が異常です\n");
@@ -205,8 +196,7 @@ s32 Scene_ExecuteCommands(GlobalContext* globalCtx, SceneCmd* sceneCmd)
 // Scene Command 0x00: Link Spawn List
 #ifdef NON_MATCHING
 // regalloc differences
-void func_80098508(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_80098508(GlobalContext* globalCtx, SceneCmd* cmd) {
     ActorEntry* linkEntry = (ActorEntry*)SEGMENTED_TO_VIRTUAL(cmd->spawnList.segment) +
                             globalCtx->setupEntranceList[globalCtx->curSpawn].spawn;
     s16 linkObjectId;
@@ -227,21 +217,18 @@ void func_80098508(GlobalContext* globalCtx, SceneCmd* cmd);
 #endif
 
 // Scene Command 0x01: Actor List
-void func_800985DC(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_800985DC(GlobalContext* globalCtx, SceneCmd* cmd) {
     globalCtx->nbSetupActors = cmd->actorList.num;
     globalCtx->setupActorList = SEGMENTED_TO_VIRTUAL(cmd->actorList.segment);
 }
 
 // Scene Command 0x02: Cutscene Camera List
-void func_80098630(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_80098630(GlobalContext* globalCtx, SceneCmd* cmd) {
     globalCtx->unk_11DFC = SEGMENTED_TO_VIRTUAL(cmd->csCameraList.segment);
 }
 
 // Scene Command 0x03: Collision Header
-void func_80098674(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_80098674(GlobalContext* globalCtx, SceneCmd* cmd) {
     CollisionHeader* colHeader;
 
     colHeader = SEGMENTED_TO_VIRTUAL(cmd->colHeader.segment);
@@ -256,34 +243,30 @@ void func_80098674(GlobalContext* globalCtx, SceneCmd* cmd)
 }
 
 // Scene Command 0x04: Room List
-void func_800987A4(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_800987A4(GlobalContext* globalCtx, SceneCmd* cmd) {
     globalCtx->nbRooms = cmd->roomList.num;
     globalCtx->roomList = SEGMENTED_TO_VIRTUAL(cmd->roomList.segment);
 }
 
 // Scene Command 0x06: Entrance List
-void func_800987F8(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_800987F8(GlobalContext* globalCtx, SceneCmd* cmd) {
     globalCtx->setupEntranceList = SEGMENTED_TO_VIRTUAL(cmd->entranceList.segment);
 }
 
 // Scene Command 0x07: Special Files
-void func_8009883C(GlobalContext* globalCtx, SceneCmd* cmd)
-{
-    if (cmd->specialFiles.keepObjectId != 0)
-    {
+void func_8009883C(GlobalContext* globalCtx, SceneCmd* cmd) {
+    if (cmd->specialFiles.keepObjectId != 0) {
         globalCtx->objectCtx.subKeepIndex = Object_Spawn(&globalCtx->objectCtx, cmd->specialFiles.keepObjectId);
         gSegments[5] = PHYSICAL_TO_VIRTUAL(globalCtx->objectCtx.status[globalCtx->objectCtx.subKeepIndex].segment);
     }
 
-    if (cmd->specialFiles.naviMsgNum != 0)
-        globalCtx->naviMsgSegment = func_800BFE5C(globalCtx, &sNaviMsgFiles[cmd->specialFiles.naviMsgNum - 1]);
+    if (cmd->specialFiles.cUpElfMsgNum != 0) {
+        globalCtx->cUpElfMsgs = func_800BFE5C(globalCtx, &sNaviMsgFiles[cmd->specialFiles.cUpElfMsgNum - 1]);
+    }
 }
 
 // Scene Command 0x08: Room Behavior
-void func_80098904(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_80098904(GlobalContext* globalCtx, SceneCmd* cmd) {
     globalCtx->roomCtx.curRoom.unk_03 = cmd->roomBehavior.gpFlag1;
     globalCtx->roomCtx.curRoom.unk_02 = cmd->roomBehavior.gpFlag2 & 0xFF;
     globalCtx->roomCtx.curRoom.showInvisActors = (cmd->roomBehavior.gpFlag2 >> 8) & 1;
@@ -291,16 +274,14 @@ void func_80098904(GlobalContext* globalCtx, SceneCmd* cmd)
 }
 
 // Scene Command 0x0A: Mesh Header
-void func_80098958(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_80098958(GlobalContext* globalCtx, SceneCmd* cmd) {
     globalCtx->roomCtx.curRoom.mesh = SEGMENTED_TO_VIRTUAL(cmd->mesh.segment);
 }
 
 // Scene Command 0x0B: Object List
 #ifdef NON_MATCHING
-// this function still needs some work
-void func_8009899C(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+// this function still needs some work but it should be functionally equivalent
+void func_8009899C(GlobalContext* globalCtx, SceneCmd* cmd) {
     s32 i, j, k;
     s16* objectEntry;
     ObjectStatus* status;
@@ -313,21 +294,16 @@ void func_8009899C(GlobalContext* globalCtx, SceneCmd* cmd)
     k = 0;
     status = status2;
     i = globalCtx->objectCtx.unk_09;
-    while (i < globalCtx->objectCtx.num)
-    {
-        if (status->id != *objectEntry)
-        {
+    while (i < globalCtx->objectCtx.num) {
+        if (status->id != *objectEntry) {
             status3 = status2;
-            for (j = i; j < globalCtx->objectCtx.num; j++)
-            {
+            for (j = i; j < globalCtx->objectCtx.num; j++) {
                 status3->id = 0;
                 status3++;
             }
             globalCtx->objectCtx.num = i;
             func_80031A28(globalCtx, &globalCtx->actorCtx);
-        }
-        else
-        {
+        } else {
             i++;
             status++;
             k++;
@@ -336,14 +312,15 @@ void func_8009899C(GlobalContext* globalCtx, SceneCmd* cmd)
         }
     }
 
-    if (cmd->objectList.num > OBJECT_EXCHANGE_BANK_MAX)
+    if (cmd->objectList.num > OBJECT_EXCHANGE_BANK_MAX) {
         __assert("scene_info->object_bank.num <= OBJECT_EXCHANGE_BANK_MAX", "../z_scene.c", 705);
+    }
 
-    while (k < cmd->objectList.num)
-    {
+    while (k < cmd->objectList.num) {
         nextPtr = func_800982FC(&globalCtx->objectCtx, i, *objectEntry);
-        if (i < OBJECT_EXCHANGE_BANK_MAX - 1)
+        if (i < OBJECT_EXCHANGE_BANK_MAX - 1) {
             globalCtx->objectCtx.status[i + 1].segment = nextPtr;
+        }
         k++;
         objectEntry++;
         status++;
@@ -357,75 +334,69 @@ void func_8009899C(GlobalContext* globalCtx, SceneCmd* cmd);
 #endif
 
 // Scene Command 0x0C: Light List
-void func_80098B74(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_80098B74(GlobalContext* globalCtx, SceneCmd* cmd) {
     s32 i;
     LightInfo* lightInfo;
 
     lightInfo = SEGMENTED_TO_VIRTUAL(cmd->lightList.segment);
-    for (i = 0; i < cmd->lightList.num; i++)
-    {
+    for (i = 0; i < cmd->lightList.num; i++) {
         Lights_Insert(globalCtx, &globalCtx->lightCtx, lightInfo);
         lightInfo++;
     }
 }
 
 // Scene Command 0x0D: Path List
-void func_80098C24(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_80098C24(GlobalContext* globalCtx, SceneCmd* cmd) {
     globalCtx->setupPathList = SEGMENTED_TO_VIRTUAL(cmd->pathList.segment);
 }
 
 // Scene Command 0x0E: Transition Actor List
-void func_80098C68(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_80098C68(GlobalContext* globalCtx, SceneCmd* cmd) {
     globalCtx->nbTransitionActors = cmd->transiActorList.num;
     globalCtx->transitionActorList = SEGMENTED_TO_VIRTUAL(cmd->transiActorList.segment);
 }
 
-void func_80098CBC(GlobalContext* globalCtx, u8* nbTransitionActors)
-{
+void func_80098CBC(GlobalContext* globalCtx, u8* nbTransitionActors) {
     *nbTransitionActors = 0;
 }
 
 // Scene Command 0x0F: Light Setting List
-void func_80098CC8(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_80098CC8(GlobalContext* globalCtx, SceneCmd* cmd) {
     globalCtx->nbLightSettings = cmd->lightSettingList.num;
     globalCtx->lightSettingsList = SEGMENTED_TO_VIRTUAL(cmd->lightSettingList.segment);
 }
 
 // Scene Command 0x11: Skybox Settings
-void func_80098D1C(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_80098D1C(GlobalContext* globalCtx, SceneCmd* cmd) {
     globalCtx->skyboxId = cmd->skyboxSettings.skyboxId;
     globalCtx->gloomySky = globalCtx->unk_10A3C = cmd->skyboxSettings.unk_05;
     globalCtx->unk_10A42 = cmd->skyboxSettings.unk_06;
 }
 
 // Scene Command 0x12: Skybox Disables
-void func_80098D5C(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_80098D5C(GlobalContext* globalCtx, SceneCmd* cmd) {
     globalCtx->skyDisabled = cmd->skyboxDisables.unk_04;
     globalCtx->sunMoonDisabled = cmd->skyboxDisables.unk_05;
 }
 
 // Scene Command 0x10: Time Settings
-void func_80098D80(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_80098D80(GlobalContext* globalCtx, SceneCmd* cmd) {
     u32 dayTime;
 
-    if ((cmd->timeSettings.hour != 0xFF) && (cmd->timeSettings.min != 0xFF))
+    if ((cmd->timeSettings.hour != 0xFF) && (cmd->timeSettings.min != 0xFF)) {
         gSaveContext.environment_time = gSaveContext.day_time =
             ((cmd->timeSettings.hour + (cmd->timeSettings.min / 60.0f)) * 60.0f) / 0.021972656f;
+    }
 
-    if (cmd->timeSettings.unk_06 != 0xFF)
+    if (cmd->timeSettings.unk_06 != 0xFF) {
         globalCtx->unk_10A26 = cmd->timeSettings.unk_06;
-    else
+    } else {
         globalCtx->unk_10A26 = 0;
+    }
 
-    if (gSaveContext.unk_1422 == 0)
+    if (gSaveContext.unk_1422 == 0) {
         D_8011FB40 = globalCtx->unk_10A26;
+    }
 
     dayTime = gSaveContext.day_time;
     globalCtx->unk_10A28 = -(Math_Sins(dayTime - 0x8000) * 120.0f) * 25.0f;
@@ -435,23 +406,22 @@ void func_80098D80(GlobalContext* globalCtx, SceneCmd* cmd)
     globalCtx->unk_10A30 = (Math_Coss(dayTime - 0x8000) * 20.0f) * 25.0f;
 
     if (((globalCtx->unk_10A26 == 0) && (gSaveContext.cutscene_index < 0xFFF0)) ||
-        (gSaveContext.entrance_index == 0x0604))
-    {
+        (gSaveContext.entrance_index == 0x0604)) {
         gSaveContext.environment_time = gSaveContext.day_time;
-        if ((gSaveContext.environment_time >= 0x2AAC) && (gSaveContext.environment_time < 0x4555))
+        if ((gSaveContext.environment_time >= 0x2AAC) && (gSaveContext.environment_time < 0x4555)) {
             gSaveContext.environment_time = 0x3556;
-        else if ((gSaveContext.environment_time >= 0x4555) && (gSaveContext.environment_time < 0x5556))
+        } else if ((gSaveContext.environment_time >= 0x4555) && (gSaveContext.environment_time < 0x5556)) {
             gSaveContext.environment_time = 0x5556;
-        else if ((gSaveContext.environment_time >= 0xAAAB) && (gSaveContext.environment_time < 0xB556))
+        } else if ((gSaveContext.environment_time >= 0xAAAB) && (gSaveContext.environment_time < 0xB556)) {
             gSaveContext.environment_time = 0xB556;
-        else if ((gSaveContext.environment_time >= 0xC001) && (gSaveContext.environment_time < 0xCAAC))
+        } else if ((gSaveContext.environment_time >= 0xC001) && (gSaveContext.environment_time < 0xCAAC)) {
             gSaveContext.environment_time = 0xCAAC;
+        }
     }
 }
 
 // Scene Command 0x05: Wind Settings
-void func_80099090(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_80099090(GlobalContext* globalCtx, SceneCmd* cmd) {
     s8 temp1 = cmd->windSettings.unk_04;
     s8 temp2 = cmd->windSettings.unk_05;
     s8 temp3 = cmd->windSettings.unk_06;
@@ -463,38 +433,33 @@ void func_80099090(GlobalContext* globalCtx, SceneCmd* cmd)
 }
 
 // Scene Command 0x13: Exit List
-void func_800990F0(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_800990F0(GlobalContext* globalCtx, SceneCmd* cmd) {
     globalCtx->setupExitList = SEGMENTED_TO_VIRTUAL(cmd->exitList.segment);
 }
 
 // Scene Command 0x09: Undefined
-void func_80099134(GlobalContext* globalCtx, SceneCmd* cmd)
-{
-
+void func_80099134(GlobalContext* globalCtx, SceneCmd* cmd) {
 }
 
 // Scene Command 0x15: Sound Settings
-void func_80099140(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_80099140(GlobalContext* globalCtx, SceneCmd* cmd) {
     globalCtx->soundCtx.musicSeq = cmd->soundSettings.musicSeq;
     globalCtx->soundCtx.nighttimeSFX = cmd->soundSettings.nighttimeSFX;
 
-    if (gSaveContext.seq_index == 0xFF)
+    if (gSaveContext.seq_index == 0xFF) {
         Audio_SetBGM(cmd->soundSettings.bgmId | 0xF0000000);
+    }
 }
 
 // Scene Command 0x16: Echo Setting
-void func_8009918C(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_8009918C(GlobalContext* globalCtx, SceneCmd* cmd) {
     globalCtx->roomCtx.curRoom.echo = cmd->echoSettings.echo;
 }
 
 // Scene Command 0x18: Alternate Headers
 #ifdef NON_MATCHING
 // minor ordering and regalloc differences
-void func_800991A0(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_800991A0(GlobalContext* globalCtx, SceneCmd* cmd) {
     SceneCmd** altHeaders;
     SceneCmd* altHeader;
 
@@ -502,31 +467,25 @@ void func_800991A0(GlobalContext* globalCtx, SceneCmd* cmd)
     osSyncPrintf("\n[ZU]sceneset time   =[%X]", gSaveContext.cutscene_index);
     osSyncPrintf("\n[ZU]sceneset counter=[%X]", gSaveContext.scene_setup_index);
 
-    if (gSaveContext.scene_setup_index != 0)
-    {
+    if (gSaveContext.scene_setup_index != 0) {
         altHeaders = SEGMENTED_TO_VIRTUAL(cmd->altHeaders.segment);
         altHeader = altHeaders[gSaveContext.scene_setup_index - 1];
 
-        if (altHeader != NULL)
-        {
+        if (altHeader != NULL) {
             Scene_ExecuteCommands(globalCtx, SEGMENTED_TO_VIRTUAL(altHeader));
             (cmd + 1)->base.code = 0x14;
-        }
-        else
-        {
+        } else {
             // Translates to: "COUGHH! THERE IS NO SPECIFIED DATAAAAA!"
             osSyncPrintf("\nげぼはっ！ 指定されたデータがないでええっす！");
 
-            if (gSaveContext.scene_setup_index == 3)
-            {
+            if (gSaveContext.scene_setup_index == 3) {
                 altHeaders = SEGMENTED_TO_VIRTUAL(cmd->altHeaders.segment);
                 altHeader = altHeaders[gSaveContext.scene_setup_index - 2];
 
                 // Translates to: "USING ADULT DAY DATA THERE!"
                 osSyncPrintf("\nそこで、大人の昼データを使用するでええっす！！");
 
-                if (altHeader != NULL)
-                {
+                if (altHeader != NULL) {
                     Scene_ExecuteCommands(globalCtx, SEGMENTED_TO_VIRTUAL(altHeader));
                     (cmd + 1)->base.code = 0x14;
                 }
@@ -540,73 +499,47 @@ void func_800991A0(GlobalContext* globalCtx, SceneCmd* cmd);
 #endif
 
 // Scene Command 0x17: Cutscene Data
-void func_8009934C(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_8009934C(GlobalContext* globalCtx, SceneCmd* cmd) {
     osSyncPrintf("\ngame_play->demo_play.data=[%x]", globalCtx->csCtx.segment);
     globalCtx->csCtx.segment = SEGMENTED_TO_VIRTUAL(cmd->cutsceneData.segment);
 }
 
 // Scene Command 0x19: Misc. Settings (Camera & World Map Area)
-void func_800993C0(GlobalContext* globalCtx, SceneCmd* cmd)
-{
+void func_800993C0(GlobalContext* globalCtx, SceneCmd* cmd) {
     YREG(15) = cmd->miscSettings.cameraMovement;
     gSaveContext.world_map_area = cmd->miscSettings.area;
 
-    if ((globalCtx->sceneNum == SCENE_SHOP1) || (globalCtx->sceneNum == SCENE_SYATEKIJYOU))
-    {
-        if (LINK_AGE_IN_YEARS == YEARS_ADULT)
-        {
+    if ((globalCtx->sceneNum == SCENE_SHOP1) || (globalCtx->sceneNum == SCENE_SYATEKIJYOU)) {
+        if (LINK_AGE_IN_YEARS == YEARS_ADULT) {
             gSaveContext.world_map_area = 1;
         }
     }
 
     if (((globalCtx->sceneNum >= SCENE_SPOT00) && (globalCtx->sceneNum <= SCENE_GANON_TOU)) ||
-        ((globalCtx->sceneNum >= SCENE_ENTRA) && (globalCtx->sceneNum <= SCENE_SHRINE_R)))
-    {
-        if (gSaveContext.cutscene_index < 0xFFF0)
-        {
+        ((globalCtx->sceneNum >= SCENE_ENTRA) && (globalCtx->sceneNum <= SCENE_SHRINE_R))) {
+        if (gSaveContext.cutscene_index < 0xFFF0) {
             gSaveContext.world_map_area_data |= gBitFlags[gSaveContext.world_map_area];
-            osSyncPrintf("０００  ａｒｅａ＿ａｒｒｉｖａｌ＝%x (%d)\n", gSaveContext.world_map_area_data, gSaveContext.world_map_area);
+            osSyncPrintf("０００  ａｒｅａ＿ａｒｒｉｖａｌ＝%x (%d)\n", gSaveContext.world_map_area_data,
+                         gSaveContext.world_map_area);
         }
     }
 }
 
-void (*gSceneCmdHandlers[])(GlobalContext*, SceneCmd*) =
-{
-    func_80098508,
-    func_800985DC,
-    func_80098630,
-    func_80098674,
-    func_800987A4,
-    func_80099090,
-    func_800987F8,
-    func_8009883C,
-    func_80098904,
-    func_80099134,
-    func_80098958,
-    func_8009899C,
-    func_80098B74,
-    func_80098C24,
-    func_80098C68,
-    func_80098CC8,
-    func_80098D80,
-    func_80098D1C,
-    func_80098D5C,
-    func_800990F0,
-    NULL,
-    func_80099140,
-    func_8009918C,
-    func_8009934C,
-    func_800991A0,
-    func_800993C0,
+void (*gSceneCmdHandlers[])(GlobalContext*, SceneCmd*) = {
+    func_80098508, func_800985DC, func_80098630, func_80098674, func_800987A4, func_80099090, func_800987F8,
+    func_8009883C, func_80098904, func_80099134, func_80098958, func_8009899C, func_80098B74, func_80098C24,
+    func_80098C68, func_80098CC8, func_80098D80, func_80098D1C, func_80098D5C, func_800990F0, NULL,
+    func_80099140, func_8009918C, func_8009934C, func_800991A0, func_800993C0,
 };
 
-#define ROM_FILE(name) { (u32)_##name##SegmentRomStart, (u32)_##name##SegmentRomEnd }
-#define ROM_FILE_EMPTY(name) { (u32)_##name##SegmentRomStart, (u32)_##name##SegmentRomStart }
-#define ROM_FILE_UNSET { 0 }
+#define ROM_FILE(name) \
+    { (u32) _##name##SegmentRomStart, (u32)_##name##SegmentRomEnd }
+#define ROM_FILE_EMPTY(name) \
+    { (u32) _##name##SegmentRomStart, (u32)_##name##SegmentRomStart }
+#define ROM_FILE_UNSET \
+    { 0 }
 
-RomFile sNaviMsgFiles[] =
-{
+RomFile sNaviMsgFiles[] = {
     ROM_FILE(elf_message_field),
     ROM_FILE(elf_message_ydan),
     ROM_FILE_UNSET,
@@ -616,8 +549,7 @@ s16 gLinkObjectIds[] = { OBJECT_LINK_BOY, OBJECT_LINK_CHILD };
 
 u32 gObjectTableSize = 402;
 
-RomFile gObjectTable[] =
-{
+RomFile gObjectTable[] = {
     ROM_FILE_UNSET,
     ROM_FILE(gameplay_keep),
     ROM_FILE(gameplay_field_keep),
diff --git a/src/code/z_scene_table.c b/src/code/z_scene_table.c
index 54d69eb8c..f4893ac56 100644
--- a/src/code/z_scene_table.c
+++ b/src/code/z_scene_table.c
@@ -1,1582 +1,538 @@
 #include <ultra64.h>
 #include <global.h>
 
-EntranceInfo gEntranceTable[] =
-{
-    { 0x00, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x00, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x00, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x00, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x01, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x01, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x01, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x01, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x0B, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x0B, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x0B, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x0B, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x14, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x14, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x14, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x14, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x05, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x05, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x05, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x05, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x6E, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x6E, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x6E, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x6E, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x6C, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x6C, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x6C, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x6C, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x68, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x68, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x68, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x68, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x69, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x69, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x69, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x69, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x6D, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x6D, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x6D, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x6D, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x02, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x02, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x02, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x02, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x02, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x41, 0x00, 0, 1, 0x02, 0x26 },
-    { 0x41, 0x00, 0, 1, 0x02, 0x26 },
-    { 0x41, 0x00, 0, 1, 0x02, 0x26 },
-    { 0x41, 0x00, 0, 1, 0x02, 0x26 },
-    { 0x41, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x41, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x1B, 0x00, 1, 1, 0x03, 0x03 },
-    { 0x1C, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x1D, 0x00, 1, 1, 0x03, 0x03 },
-    { 0x1D, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x07, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x07, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x07, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x07, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x42, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x42, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x42, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x42, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x3E, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x38, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x38, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x38, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x38, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x6A, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x6A, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x6A, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x6A, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x40, 0x00, 0, 1, 0x02, 0x26 },
-    { 0x40, 0x00, 0, 1, 0x02, 0x26 },
-    { 0x40, 0x00, 0, 1, 0x02, 0x26 },
-    { 0x40, 0x00, 0, 1, 0x02, 0x26 },
-    { 0x4C, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x4C, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x4C, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x4C, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x43, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x00, 0, 1, 0x0B, 0x0B },
-    { 0x43, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x10, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x10, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x10, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x10, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x1E, 0x03, 1, 1, 0x03, 0x03 },
-    { 0x1F, 0x03, 1, 1, 0x02, 0x02 },
-    { 0x1E, 0x03, 1, 1, 0x02, 0x02 },
-    { 0x1F, 0x03, 1, 1, 0x02, 0x02 },
-    { 0x44, 0x00, 0, 1, 0x07, 0x07 },
-    { 0x44, 0x00, 0, 1, 0x07, 0x07 },
-    { 0x44, 0x00, 0, 1, 0x07, 0x07 },
-    { 0x44, 0x00, 0, 1, 0x07, 0x07 },
-    { 0x44, 0x00, 0, 1, 0x0D, 0x02 },
-    { 0x44, 0x00, 0, 1, 0x0D, 0x02 },
-    { 0x44, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x4E, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x4E, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x4E, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x4E, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x6B, 0x00, 0, 1, 0x22, 0x22 },
-    { 0x6B, 0x00, 0, 1, 0x22, 0x22 },
-    { 0x6B, 0x00, 0, 1, 0x22, 0x22 },
-    { 0x6B, 0x00, 0, 1, 0x22, 0x22 },
-    { 0x45, 0x00, 0, 1, 0x22, 0x04 },
-    { 0x46, 0x00, 0, 1, 0x22, 0x04 },
-    { 0x45, 0x00, 0, 1, 0x22, 0x04 },
-    { 0x46, 0x00, 0, 1, 0x22, 0x04 },
-    { 0x4D, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x4D, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x4D, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x4D, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x06, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x06, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x06, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x06, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x06, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x06, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x09, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x09, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x09, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x09, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x09, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x17, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x17, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x17, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x17, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x17, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x17, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x17, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x65, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x65, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x65, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x65, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x08, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x08, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x08, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x08, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x27, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x27, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x27, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x27, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x47, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x47, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x47, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x47, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x47, 0x00, 0, 1, 0x0A, 0x0A },
-    { 0x47, 0x00, 0, 1, 0x02, 0x0A },
-    { 0x47, 0x00, 1, 1, 0x0A, 0x0A },
-    { 0x47, 0x00, 0, 1, 0x0B, 0x0B },
-    { 0x47, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x47, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x47, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x47, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x47, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x1E, 0x00, 1, 1, 0x03, 0x03 },
-    { 0x1F, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x1E, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x1F, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x20, 0x00, 1, 1, 0x03, 0x03 },
-    { 0x21, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x22, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x22, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x20, 0x00, 0, 1, 0x08, 0x08 },
-    { 0x67, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x2C, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x2C, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x2C, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x2C, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x34, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x34, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x34, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x34, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x34, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x34, 0x00, 0, 1, 0x10, 0x10 },
-    { 0x2D, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x2D, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x2D, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x2D, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x01, 0x01, 1, 0, 0x02, 0x02 },
-    { 0x01, 0x01, 1, 0, 0x02, 0x02 },
-    { 0x01, 0x01, 1, 0, 0x02, 0x02 },
-    { 0x01, 0x01, 1, 0, 0x02, 0x02 },
-    { 0x26, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x26, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x26, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x26, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x51, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x51, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x51, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x51, 0x00, 0, 1, 0x21, 0x21 },
-    { 0x51, 0x00, 0, 1, 0x21, 0x21 },
-    { 0x51, 0x00, 0, 1, 0x23, 0x23 },
-    { 0x51, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x51, 0x00, 0, 1, 0x23, 0x23 },
-    { 0x51, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x00, 0, 1, 0x29, 0x29 },
-    { 0x51, 0x00, 1, 1, 0x03, 0x03 },
-    { 0x52, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x52, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x52, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x52, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x52, 0x00, 0, 1, 0x26, 0x26 },
-    { 0x52, 0x00, 0, 1, 0x21, 0x21 },
-    { 0x52, 0x00, 1, 1, 0x21, 0x21 },
-    { 0x52, 0x00, 0, 1, 0x21, 0x21 },
-    { 0x52, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x53, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x53, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x53, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x53, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x54, 0x00, 1, 1, 0x03, 0x03 },
-    { 0x54, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x54, 0x00, 1, 1, 0x03, 0x03 },
-    { 0x54, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x55, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x55, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x55, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x55, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x55, 0x00, 1, 1, 0x0A, 0x0A },
-    { 0x55, 0x00, 0, 1, 0x0A, 0x0A },
-    { 0x55, 0x00, 1, 1, 0x0A, 0x0A },
-    { 0x55, 0x00, 0, 1, 0x0D, 0x0A },
-    { 0x55, 0x00, 0, 1, 0x0A, 0x0A },
-    { 0x55, 0x00, 0, 1, 0x0A, 0x0A },
-    { 0x55, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x55, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x55, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x55, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x56, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x56, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x56, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x56, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x56, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x56, 0x00, 0, 1, 0x00, 0x00 },
-    { 0x57, 0x00, 1, 1, 0x03, 0x03 },
-    { 0x57, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x57, 0x00, 1, 1, 0x03, 0x03 },
-    { 0x57, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x57, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x57, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x58, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x58, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x58, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x58, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x58, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x58, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x59, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x59, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x59, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x59, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x59, 0x00, 0, 1, 0x0D, 0x00 },
-    { 0x59, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x59, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x59, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x59, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x5A, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x5A, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x5A, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x5A, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x5A, 0x00, 1, 1, 0x0C, 0x0A },
-    { 0x5A, 0x00, 1, 1, 0x0A, 0x0A },
-    { 0x5A, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x5B, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x5C, 0x00, 1, 1, 0x0F, 0x0F },
-    { 0x5C, 0x00, 1, 1, 0x0F, 0x0F },
-    { 0x5C, 0x00, 1, 1, 0x0F, 0x0F },
-    { 0x5C, 0x00, 1, 1, 0x0F, 0x0F },
-    { 0x5C, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x5C, 0x00, 1, 1, 0x0F, 0x0F },
-    { 0x5D, 0x00, 1, 1, 0x03, 0x03 },
-    { 0x5D, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x5D, 0x00, 1, 1, 0x03, 0x03 },
-    { 0x5D, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x5D, 0x00, 1, 1, 0x21, 0x21 },
-    { 0x5D, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x5D, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x5E, 0x00, 1, 1, 0x0E, 0x0E },
-    { 0x5E, 0x00, 1, 1, 0x0E, 0x0E },
-    { 0x5E, 0x00, 1, 1, 0x0E, 0x0E },
-    { 0x5E, 0x00, 1, 1, 0x0E, 0x0E },
-    { 0x0E, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x5F, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x5F, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x64, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x64, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x64, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x60, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x60, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x60, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x60, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x60, 0x00, 1, 1, 0x0A, 0x0A },
-    { 0x60, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x60, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x60, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x60, 0x00, 1, 1, 0x03, 0x03 },
-    { 0x60, 0x00, 1, 1, 0x03, 0x03 },
-    { 0x61, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x61, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x62, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x62, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x62, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x62, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x62, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x62, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x58, 0x03, 0, 1, 0x00, 0x00 },
-    { 0x58, 0x03, 0, 1, 0x00, 0x00 },
-    { 0x58, 0x03, 0, 1, 0x00, 0x00 },
-    { 0x58, 0x03, 0, 1, 0x00, 0x00 },
-    { 0x63, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x63, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x63, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x63, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x63, 0x00, 0, 1, 0x20, 0x20 },
-    { 0x63, 0x00, 0, 1, 0x2A, 0x2A },
-    { 0x63, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x63, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x63, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x63, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x63, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x63, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x63, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x63, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x04, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x04, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x04, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x04, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x03, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x03, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x03, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x03, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x42, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x42, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x42, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x42, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x23, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x24, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x25, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x25, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x04, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x04, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x04, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x04, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x51, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x51, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x51, 0x02, 1, 1, 0x03, 0x03 },
-    { 0x51, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x51, 0x02, 1, 1, 0x03, 0x03 },
-    { 0x51, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x51, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x51, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x51, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x51, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x51, 0x04, 1, 1, 0x03, 0x03 },
-    { 0x51, 0x04, 1, 1, 0x02, 0x02 },
-    { 0x51, 0x04, 1, 1, 0x03, 0x03 },
-    { 0x51, 0x04, 1, 1, 0x02, 0x02 },
-    { 0x51, 0x05, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x51, 0x05, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x52, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x52, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x52, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x52, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x52, 0x02, 0, 1, 0x03, 0x03 },
-    { 0x52, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x52, 0x02, 0, 1, 0x03, 0x03 },
-    { 0x52, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x54, 0x01, 1, 1, 0x03, 0x03 },
-    { 0x54, 0x01, 1, 1, 0x03, 0x03 },
-    { 0x54, 0x01, 1, 1, 0x03, 0x03 },
-    { 0x54, 0x01, 1, 1, 0x03, 0x03 },
-    { 0x54, 0x02, 0, 1, 0x03, 0x03 },
-    { 0x54, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x54, 0x02, 0, 1, 0x03, 0x03 },
-    { 0x54, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x58, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x58, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x58, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x58, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x5A, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x5A, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x5A, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x5A, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x5B, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x5B, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x5B, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x5B, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x0E, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x60, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x60, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x60, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x60, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x60, 0x02, 0, 1, 0x03, 0x03 },
-    { 0x60, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x60, 0x02, 0, 1, 0x03, 0x03 },
-    { 0x60, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x62, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x62, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x62, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x62, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x38, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x38, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x38, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x38, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x1A, 0x05, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x05, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x05, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x05, 1, 1, 0x02, 0x02 },
-    { 0x20, 0x08, 0, 1, 0x04, 0x02 },
-    { 0x21, 0x08, 0, 1, 0x04, 0x02 },
-    { 0x22, 0x08, 0, 1, 0x04, 0x02 },
-    { 0x22, 0x08, 0, 1, 0x04, 0x02 },
-    { 0x20, 0x09, 0, 1, 0x04, 0x02 },
-    { 0x21, 0x09, 0, 1, 0x04, 0x02 },
-    { 0x22, 0x09, 0, 1, 0x04, 0x02 },
-    { 0x22, 0x09, 0, 1, 0x04, 0x02 },
-    { 0x20, 0x0A, 0, 1, 0x04, 0x02 },
-    { 0x21, 0x0A, 0, 1, 0x04, 0x02 },
-    { 0x22, 0x0A, 0, 1, 0x04, 0x02 },
-    { 0x22, 0x0A, 0, 1, 0x04, 0x02 },
-    { 0x54, 0x03, 1, 1, 0x03, 0x03 },
-    { 0x54, 0x03, 1, 1, 0x02, 0x02 },
-    { 0x54, 0x03, 1, 1, 0x03, 0x03 },
-    { 0x54, 0x03, 1, 1, 0x02, 0x02 },
-    { 0x54, 0x04, 0, 1, 0x2C, 0x2C },
-    { 0x54, 0x04, 0, 1, 0x2C, 0x2C },
-    { 0x54, 0x04, 0, 1, 0x2C, 0x2C },
-    { 0x54, 0x04, 0, 1, 0x2C, 0x2C },
-    { 0x5C, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x5C, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x5C, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x5C, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x5C, 0x02, 0, 0, 0x03, 0x03 },
-    { 0x5C, 0x02, 0, 0, 0x02, 0x02 },
-    { 0x5C, 0x02, 0, 0, 0x03, 0x03 },
-    { 0x5C, 0x02, 0, 0, 0x02, 0x02 },
-    { 0x5C, 0x03, 0, 0, 0x03, 0x03 },
-    { 0x5C, 0x03, 0, 0, 0x02, 0x02 },
-    { 0x5C, 0x03, 0, 0, 0x03, 0x03 },
-    { 0x5C, 0x03, 0, 0, 0x02, 0x02 },
-    { 0x5C, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x5C, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x5C, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x5C, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x5C, 0x05, 0, 1, 0x03, 0x03 },
-    { 0x5C, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x5C, 0x05, 0, 1, 0x03, 0x03 },
-    { 0x5C, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x5C, 0x06, 1, 0, 0x0F, 0x0F },
-    { 0x5C, 0x06, 1, 0, 0x0F, 0x0F },
-    { 0x5C, 0x06, 1, 0, 0x0F, 0x0F },
-    { 0x5C, 0x06, 1, 0, 0x0F, 0x0F },
-    { 0x51, 0x06, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x51, 0x06, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x51, 0x07, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x07, 0, 1, 0x02, 0x02 },
-    { 0x51, 0x07, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x07, 0, 1, 0x02, 0x02 },
-    { 0x52, 0x03, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x03, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x03, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x03, 0, 1, 0x04, 0x02 },
-    { 0x53, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x53, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x53, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x53, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x55, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x55, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x55, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x55, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x55, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x55, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x55, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x55, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x55, 0x03, 0, 1, 0x04, 0x04 },
-    { 0x55, 0x03, 0, 1, 0x04, 0x04 },
-    { 0x55, 0x03, 0, 1, 0x04, 0x04 },
-    { 0x55, 0x03, 0, 1, 0x04, 0x04 },
-    { 0x56, 0x01, 0, 1, 0x12, 0x12 },
-    { 0x56, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x56, 0x01, 0, 1, 0x12, 0x12 },
-    { 0x56, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x57, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x57, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x57, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x57, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x57, 0x02, 0, 1, 0x13, 0x13 },
-    { 0x57, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x57, 0x02, 0, 1, 0x13, 0x13 },
-    { 0x57, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x59, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x59, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x59, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x59, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x59, 0x02, 0, 1, 0x03, 0x03 },
-    { 0x59, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x59, 0x02, 0, 1, 0x03, 0x03 },
-    { 0x59, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x5A, 0x02, 1, 1, 0x03, 0x03 },
-    { 0x5A, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x5A, 0x02, 1, 1, 0x03, 0x03 },
-    { 0x5A, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x5A, 0x03, 1, 1, 0x03, 0x03 },
-    { 0x5A, 0x03, 1, 1, 0x02, 0x02 },
-    { 0x5A, 0x03, 1, 1, 0x03, 0x03 },
-    { 0x5A, 0x03, 1, 1, 0x02, 0x02 },
-    { 0x5D, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x02, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x02, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x5F, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x5F, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x64, 0x01, 0, 1, 0x05, 0x05 },
-    { 0x64, 0x01, 0, 1, 0x05, 0x05 },
-    { 0x5F, 0x01, 0, 1, 0x00, 0x00 },
-    { 0x60, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x60, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x60, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x60, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x03, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x03, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x03, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x03, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x00, 0x01, 1, 0, 0x02, 0x02 },
-    { 0x00, 0x01, 1, 0, 0x02, 0x02 },
-    { 0x00, 0x01, 1, 0, 0x02, 0x02 },
-    { 0x00, 0x01, 1, 0, 0x02, 0x02 },
-    { 0x0E, 0x03, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x03, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x03, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x03, 1, 1, 0x02, 0x02 },
-    { 0x20, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x21, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x22, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x22, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x20, 0x02, 0, 1, 0x03, 0x03 },
-    { 0x21, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x22, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x22, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x20, 0x03, 1, 1, 0x03, 0x03 },
-    { 0x21, 0x03, 1, 1, 0x02, 0x02 },
-    { 0x22, 0x03, 1, 1, 0x02, 0x02 },
-    { 0x22, 0x03, 1, 1, 0x02, 0x02 },
-    { 0x55, 0x04, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x04, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x04, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x04, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x05, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x05, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x05, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x05, 0, 0, 0x04, 0x04 },
-    { 0x1B, 0x02, 0, 0, 0x02, 0x02 },
-    { 0x1C, 0x02, 0, 0, 0x02, 0x02 },
-    { 0x1D, 0x02, 0, 0, 0x02, 0x02 },
-    { 0x1D, 0x02, 0, 0, 0x02, 0x02 },
-    { 0x34, 0x01, 0, 1, 0x04, 0x04 },
-    { 0x34, 0x01, 0, 1, 0x04, 0x04 },
-    { 0x34, 0x01, 0, 1, 0x04, 0x04 },
-    { 0x34, 0x01, 0, 1, 0x04, 0x04 },
-    { 0x1B, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x1C, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x1D, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x1D, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x51, 0x08, 1, 1, 0x03, 0x03 },
-    { 0x51, 0x08, 1, 1, 0x02, 0x02 },
-    { 0x51, 0x08, 1, 1, 0x03, 0x03 },
-    { 0x51, 0x08, 1, 1, 0x02, 0x02 },
-    { 0x51, 0x09, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x09, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x09, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x09, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x0A, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x0A, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x0A, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x0A, 0, 1, 0x03, 0x03 },
-    { 0x55, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x55, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x55, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x55, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x51, 0x0B, 0, 1, 0x05, 0x05 },
-    { 0x51, 0x0B, 0, 1, 0x04, 0x02 },
-    { 0x51, 0x0B, 0, 1, 0x05, 0x05 },
-    { 0x51, 0x0B, 0, 1, 0x04, 0x02 },
-    { 0x51, 0x0C, 0, 1, 0x05, 0x05 },
-    { 0x51, 0x0C, 0, 1, 0x04, 0x02 },
-    { 0x51, 0x0C, 0, 1, 0x05, 0x05 },
-    { 0x51, 0x0C, 0, 1, 0x04, 0x02 },
-    { 0x51, 0x0D, 0, 1, 0x05, 0x05 },
-    { 0x51, 0x0D, 0, 1, 0x04, 0x02 },
-    { 0x51, 0x0D, 0, 1, 0x05, 0x05 },
-    { 0x51, 0x0D, 0, 1, 0x04, 0x02 },
-    { 0x45, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x46, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x45, 0x01, 0, 1, 0x03, 0x03 },
-    { 0x46, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x1E, 0x01, 1, 1, 0x03, 0x03 },
-    { 0x1F, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x1E, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x1F, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x20, 0x04, 1, 1, 0x03, 0x03 },
-    { 0x21, 0x04, 1, 1, 0x02, 0x02 },
-    { 0x22, 0x04, 1, 1, 0x02, 0x02 },
-    { 0x22, 0x04, 1, 1, 0x02, 0x02 },
-    { 0x20, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x21, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x22, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x22, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x52, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x52, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x52, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x04, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x04, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x63, 0x01, 0, 0, 0x03, 0x03 },
-    { 0x63, 0x01, 0, 0, 0x02, 0x02 },
-    { 0x63, 0x01, 0, 0, 0x03, 0x03 },
-    { 0x63, 0x01, 0, 0, 0x02, 0x02 },
-    { 0x07, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x07, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x07, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x07, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x07, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x07, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x07, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x07, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x5D, 0x05, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x05, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x06, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x06, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x07, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x07, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x07, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x07, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x08, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x08, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x08, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x08, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x02, 0, 1, 0x0A, 0x0A },
-    { 0x43, 0x02, 0, 1, 0x0A, 0x0A },
-    { 0x43, 0x02, 0, 1, 0x0A, 0x0A },
-    { 0x43, 0x02, 0, 1, 0x0A, 0x0A },
-    { 0x44, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x44, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x44, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x44, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x09, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x09, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x09, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x09, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x0A, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x0A, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x0A, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x0A, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x0B, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x0B, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x0B, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x0B, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x0C, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x0C, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x0C, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x0C, 0, 1, 0x02, 0x02 },
-    { 0x63, 0x02, 0, 1, 0x03, 0x03 },
-    { 0x63, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x63, 0x02, 0, 1, 0x03, 0x03 },
-    { 0x63, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x63, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x63, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x63, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x63, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x42, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x42, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x42, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x42, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x56, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x47, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x42, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x42, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x42, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x42, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x42, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x06, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x06, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x06, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x06, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x36, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x36, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x36, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x36, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x2A, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x2A, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x2A, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x2A, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x13, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x13, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x13, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x13, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x15, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x15, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x15, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x15, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x57, 0x06, 0, 1, 0x04, 0x02 },
-    { 0x57, 0x06, 0, 1, 0x04, 0x02 },
-    { 0x57, 0x06, 0, 1, 0x04, 0x02 },
-    { 0x57, 0x06, 0, 1, 0x04, 0x02 },
-    { 0x3A, 0x00, 0, 1, 0x02, 0x20 },
-    { 0x3A, 0x00, 0, 1, 0x02, 0x20 },
-    { 0x3A, 0x00, 0, 1, 0x02, 0x20 },
-    { 0x3A, 0x00, 0, 1, 0x02, 0x20 },
-    { 0x51, 0x0E, 1, 1, 0x03, 0x03 },
-    { 0x51, 0x0E, 1, 1, 0x03, 0x03 },
-    { 0x51, 0x0E, 1, 1, 0x03, 0x03 },
-    { 0x51, 0x0E, 1, 1, 0x03, 0x03 },
-    { 0x3B, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x3B, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x3B, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x3B, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x3B, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x3B, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x3B, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x3F, 0x00, 0, 1, 0x02, 0x26 },
-    { 0x3F, 0x00, 0, 1, 0x02, 0x26 },
-    { 0x3F, 0x00, 0, 1, 0x02, 0x26 },
-    { 0x3F, 0x00, 0, 1, 0x02, 0x26 },
-    { 0x43, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x58, 0x04, 0, 1, 0x2C, 0x2C },
-    { 0x58, 0x04, 0, 1, 0x2C, 0x2C },
-    { 0x58, 0x04, 0, 1, 0x2C, 0x2C },
-    { 0x58, 0x04, 0, 1, 0x2C, 0x2C },
-    { 0x1A, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x03, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x03, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x03, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x03, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x04, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x04, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x04, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x04, 1, 1, 0x02, 0x02 },
-    { 0x55, 0x07, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x07, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x07, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x07, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x08, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x08, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x08, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x08, 0, 0, 0x04, 0x04 },
-    { 0x5F, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x5F, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x64, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x64, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x5F, 0x02, 0, 1, 0x00, 0x00 },
-    { 0x52, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x06, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x06, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x06, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x06, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x07, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x07, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x07, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x07, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x08, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x08, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x08, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x08, 0, 1, 0x04, 0x02 },
-    { 0x53, 0x02, 0, 1, 0x04, 0x02 },
-    { 0x53, 0x02, 0, 1, 0x04, 0x02 },
-    { 0x53, 0x02, 0, 1, 0x04, 0x02 },
-    { 0x53, 0x02, 0, 1, 0x04, 0x02 },
-    { 0x53, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x04, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x04, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x04, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x04, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x05, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x05, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x05, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x05, 0, 1, 0x03, 0x03 },
-    { 0x5E, 0x01, 1, 1, 0x0E, 0x0E },
-    { 0x5E, 0x01, 1, 1, 0x0E, 0x0E },
-    { 0x5E, 0x01, 1, 1, 0x0E, 0x0E },
-    { 0x5E, 0x01, 1, 1, 0x0E, 0x0E },
-    { 0x5E, 0x02, 0, 1, 0x0E, 0x0E },
-    { 0x5E, 0x02, 0, 1, 0x0E, 0x0E },
-    { 0x5E, 0x02, 0, 1, 0x0E, 0x0E },
-    { 0x5E, 0x02, 0, 1, 0x0E, 0x0E },
-    { 0x3C, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x3C, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x3C, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x3C, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x3D, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x3D, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x3D, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x3D, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x3D, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x3D, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x3D, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x63, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x63, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x63, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x63, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x2E, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x2E, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x2E, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x2E, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x2F, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x2F, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x2F, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x2F, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x30, 0x00, 0, 0, 0x04, 0x20 },
-    { 0x30, 0x00, 0, 0, 0x04, 0x20 },
-    { 0x30, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x30, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x31, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x31, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x31, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x31, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x1E, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x1F, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x1E, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x1F, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x32, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x32, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x32, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x32, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x59, 0x05, 0, 1, 0x03, 0x03 },
-    { 0x59, 0x05, 0, 1, 0x03, 0x03 },
-    { 0x59, 0x05, 0, 1, 0x03, 0x03 },
-    { 0x59, 0x05, 0, 1, 0x03, 0x03 },
-    { 0x35, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x35, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x35, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x35, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x37, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x37, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x37, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x37, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x39, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x39, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x39, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x39, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x5D, 0x0D, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x0D, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x0D, 0, 1, 0x03, 0x03 },
-    { 0x5D, 0x0D, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x0E, 0, 1, 0x03, 0x05 },
-    { 0x5D, 0x0E, 0, 1, 0x02, 0x04 },
-    { 0x5D, 0x0E, 0, 1, 0x03, 0x05 },
-    { 0x5D, 0x0E, 0, 1, 0x02, 0x04 },
-    { 0x5D, 0x0F, 1, 1, 0x0F, 0x0F },
-    { 0x5D, 0x0F, 1, 1, 0x0F, 0x0F },
-    { 0x5D, 0x0F, 1, 1, 0x0F, 0x0F },
-    { 0x5D, 0x0F, 1, 1, 0x0F, 0x0F },
-    { 0x5D, 0x10, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x10, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x10, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x10, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x11, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x11, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x11, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x11, 0, 1, 0x02, 0x02 },
-    { 0x20, 0x06, 0, 1, 0x04, 0x02 },
-    { 0x21, 0x06, 0, 1, 0x04, 0x02 },
-    { 0x22, 0x06, 0, 1, 0x04, 0x02 },
-    { 0x22, 0x06, 0, 1, 0x04, 0x02 },
-    { 0x20, 0x07, 0, 1, 0x04, 0x02 },
-    { 0x21, 0x07, 0, 1, 0x04, 0x02 },
-    { 0x22, 0x07, 0, 1, 0x04, 0x02 },
-    { 0x22, 0x07, 0, 1, 0x04, 0x02 },
-    { 0x1E, 0x02, 0, 1, 0x04, 0x02 },
-    { 0x1F, 0x02, 0, 1, 0x04, 0x02 },
-    { 0x1E, 0x02, 0, 1, 0x03, 0x03 },
-    { 0x1F, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x58, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x58, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x58, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x58, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x57, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x57, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x57, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x57, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x57, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x57, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x57, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x57, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x5A, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x5A, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x5A, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x5A, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x59, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x59, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x59, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x59, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x59, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x59, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x59, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x59, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x0E, 0x04, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x04, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x04, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x04, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x05, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x05, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x05, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x05, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x06, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x06, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x06, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x06, 1, 1, 0x02, 0x02 },
-    { 0x30, 0x01, 0, 0, 0x04, 0x20 },
-    { 0x30, 0x01, 0, 0, 0x04, 0x20 },
-    { 0x30, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x30, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x30, 0x02, 0, 0, 0x04, 0x20 },
-    { 0x30, 0x02, 0, 0, 0x04, 0x20 },
-    { 0x30, 0x02, 0, 1, 0x04, 0x20 },
-    { 0x30, 0x02, 0, 1, 0x04, 0x20 },
-    { 0x06, 0x02, 0, 0, 0x02, 0x02 },
-    { 0x06, 0x02, 0, 0, 0x02, 0x02 },
-    { 0x06, 0x02, 0, 0, 0x02, 0x02 },
-    { 0x06, 0x02, 0, 0, 0x02, 0x02 },
-    { 0x06, 0x03, 0, 0, 0x02, 0x02 },
-    { 0x06, 0x03, 0, 0, 0x02, 0x02 },
-    { 0x06, 0x03, 0, 0, 0x02, 0x02 },
-    { 0x06, 0x03, 0, 0, 0x02, 0x02 },
-    { 0x06, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x06, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x06, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x06, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x62, 0x02, 0, 1, 0x04, 0x02 },
-    { 0x62, 0x02, 0, 1, 0x04, 0x02 },
-    { 0x62, 0x02, 0, 1, 0x04, 0x02 },
-    { 0x62, 0x02, 0, 1, 0x04, 0x02 },
-    { 0x4A, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x4A, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x4A, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x4A, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x4A, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x4A, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x4A, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x02, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x02, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x02, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x02, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x12, 0x00, 1, 0, 0x02, 0x02 },
-    { 0x12, 0x00, 1, 0, 0x02, 0x02 },
-    { 0x12, 0x00, 1, 0, 0x02, 0x02 },
-    { 0x12, 0x00, 1, 0, 0x02, 0x02 },
-    { 0x11, 0x00, 1, 0, 0x02, 0x02 },
-    { 0x11, 0x00, 1, 0, 0x02, 0x02 },
-    { 0x11, 0x00, 1, 0, 0x02, 0x02 },
-    { 0x11, 0x00, 1, 0, 0x02, 0x02 },
-    { 0x18, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x18, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x18, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x18, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x16, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x16, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x16, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x16, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x0A, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x0A, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x0A, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x0A, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x19, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x19, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x19, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x19, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x05, 0x01, 1, 1, 0x03, 0x02 },
-    { 0x05, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x05, 0x01, 1, 1, 0x03, 0x02 },
-    { 0x05, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x0A, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x0A, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x0A, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x0A, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x0A, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x0A, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x0A, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x0A, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x63, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x63, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x63, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x63, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x28, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x28, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x28, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x28, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x29, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x29, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x29, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x29, 0x00, 0, 1, 0x04, 0x04 },
-    { 0x2B, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x2B, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x2B, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x2B, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x1A, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x55, 0x09, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x09, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x09, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x09, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x0A, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x0A, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x0A, 0, 0, 0x04, 0x04 },
-    { 0x55, 0x0A, 0, 0, 0x04, 0x04 },
-    { 0x52, 0x09, 0, 1, 0x04, 0x04 },
-    { 0x52, 0x09, 0, 1, 0x04, 0x04 },
-    { 0x52, 0x09, 0, 1, 0x04, 0x04 },
-    { 0x52, 0x09, 0, 1, 0x04, 0x04 },
-    { 0x48, 0x00, 0, 1, 0x02, 0x26 },
-    { 0x48, 0x00, 0, 1, 0x02, 0x26 },
-    { 0x48, 0x00, 0, 1, 0x02, 0x26 },
-    { 0x48, 0x00, 0, 1, 0x02, 0x26 },
-    { 0x48, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x48, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x48, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x48, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x55, 0x0B, 0, 1, 0x04, 0x02 },
-    { 0x55, 0x0B, 0, 1, 0x04, 0x02 },
-    { 0x55, 0x0B, 0, 1, 0x04, 0x02 },
-    { 0x55, 0x0B, 0, 1, 0x04, 0x02 },
-    { 0x60, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x60, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x60, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x60, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x49, 0x00, 0, 1, 0x02, 0x20 },
-    { 0x49, 0x00, 0, 1, 0x02, 0x20 },
-    { 0x49, 0x00, 0, 1, 0x02, 0x20 },
-    { 0x49, 0x00, 0, 1, 0x02, 0x20 },
-    { 0x52, 0x0A, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x0A, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x0A, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x0A, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x00, 0, 1, 0x04, 0x02 },
-    { 0x23, 0x01, 0, 1, 0x04, 0x02 },
-    { 0x24, 0x01, 0, 1, 0x04, 0x02 },
-    { 0x25, 0x01, 0, 1, 0x04, 0x02 },
-    { 0x25, 0x01, 0, 1, 0x04, 0x02 },
-    { 0x51, 0x0F, 0, 1, 0x05, 0x05 },
-    { 0x51, 0x0F, 0, 1, 0x04, 0x02 },
-    { 0x51, 0x0F, 0, 1, 0x05, 0x05 },
-    { 0x51, 0x0F, 0, 1, 0x04, 0x02 },
-    { 0x60, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x60, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x60, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x60, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x5F, 0x04, 0, 1, 0x03, 0x03 },
-    { 0x5F, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x64, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x64, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x07, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x07, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x07, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x07, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x08, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x08, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x08, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x08, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x09, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x09, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x09, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x09, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x0A, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x0A, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x0A, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x0A, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x0B, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x0B, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x0B, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x0B, 0, 1, 0x02, 0x02 },
-    { 0x0E, 0x07, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x07, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x07, 1, 1, 0x02, 0x02 },
-    { 0x0E, 0x07, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x01, 1, 1, 0x02, 0x02 },
-    { 0x3B, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x3B, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x3B, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x3B, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x3B, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x3B, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x3B, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x3B, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x63, 0x06, 0, 0, 0x02, 0x26 },
-    { 0x63, 0x06, 0, 0, 0x02, 0x26 },
-    { 0x63, 0x06, 0, 0, 0x02, 0x26 },
-    { 0x63, 0x06, 0, 0, 0x02, 0x26 },
-    { 0x63, 0x07, 0, 0, 0x2E, 0x2E },
-    { 0x63, 0x07, 0, 0, 0x2E, 0x2E },
-    { 0x63, 0x07, 0, 0, 0x2E, 0x2E },
-    { 0x63, 0x07, 0, 0, 0x2E, 0x2E },
-    { 0x5B, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x06, 0, 1, 0x2C, 0x2C },
-    { 0x5B, 0x06, 0, 1, 0x2C, 0x2C },
-    { 0x5B, 0x06, 0, 1, 0x2C, 0x2C },
-    { 0x5B, 0x06, 0, 1, 0x2C, 0x2C },
-    { 0x5B, 0x07, 0, 1, 0x2C, 0x2C },
-    { 0x5B, 0x07, 0, 1, 0x2C, 0x2C },
-    { 0x5B, 0x07, 0, 1, 0x2C, 0x2C },
-    { 0x5B, 0x07, 0, 1, 0x2C, 0x2C },
-    { 0x5B, 0x08, 0, 0, 0x02, 0x02 },
-    { 0x5B, 0x08, 0, 0, 0x02, 0x02 },
-    { 0x5B, 0x08, 0, 0, 0x02, 0x02 },
-    { 0x5B, 0x08, 0, 0, 0x02, 0x02 },
-    { 0x62, 0x03, 0, 1, 0x2C, 0x2C },
-    { 0x62, 0x03, 0, 1, 0x2C, 0x2C },
-    { 0x62, 0x03, 0, 1, 0x2C, 0x2C },
-    { 0x62, 0x03, 0, 1, 0x2C, 0x2C },
-    { 0x57, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x57, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x57, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x57, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x07, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x07, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x07, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x07, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x52, 0x0B, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x0B, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x0B, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x0B, 0, 1, 0x04, 0x02 },
-    { 0x3B, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x3B, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x3B, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x3B, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x5F, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x5F, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x64, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x64, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x5F, 0x03, 0, 1, 0x00, 0x00 },
-    { 0x52, 0x0C, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x0C, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x0C, 0, 1, 0x04, 0x02 },
-    { 0x52, 0x0C, 0, 1, 0x04, 0x02 },
-    { 0x48, 0x02, 1, 1, 0x04, 0x20 },
-    { 0x48, 0x02, 1, 1, 0x04, 0x20 },
-    { 0x48, 0x02, 1, 1, 0x04, 0x20 },
-    { 0x48, 0x02, 1, 1, 0x04, 0x20 },
-    { 0x4B, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x4B, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x4B, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x4B, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x53, 0x06, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x06, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x06, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x06, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x10, 0, 1, 0x0B, 0x0B },
-    { 0x51, 0x10, 0, 1, 0x0B, 0x0B },
-    { 0x51, 0x10, 0, 1, 0x0B, 0x0B },
-    { 0x51, 0x10, 0, 1, 0x0B, 0x0B },
-    { 0x52, 0x0D, 0, 1, 0x03, 0x03 },
-    { 0x52, 0x0D, 0, 1, 0x02, 0x02 },
-    { 0x52, 0x0D, 0, 1, 0x03, 0x03 },
-    { 0x52, 0x0D, 0, 1, 0x02, 0x02 },
-    { 0x4F, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x4F, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x4F, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x4F, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x4F, 0x00, 0, 1, 0x03, 0x03 },
-    { 0x1A, 0x06, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x06, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x06, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x06, 1, 1, 0x02, 0x02 },
-    { 0x66, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x66, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x66, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x66, 0x00, 0, 1, 0x02, 0x02 },
-    { 0x1A, 0x07, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x07, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x07, 1, 1, 0x02, 0x02 },
-    { 0x1A, 0x07, 1, 1, 0x02, 0x02 },
-    { 0x32, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x32, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x32, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x32, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x2C, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x2C, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x2C, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x2C, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x33, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x33, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x33, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x33, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x0D, 0x01, 0, 0, 0x04, 0x02 },
-    { 0x0D, 0x01, 0, 0, 0x04, 0x02 },
-    { 0x0D, 0x01, 0, 0, 0x04, 0x02 },
-    { 0x0D, 0x01, 0, 0, 0x04, 0x02 },
-    { 0x0D, 0x02, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x02, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x02, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x02, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x03, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x03, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x03, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x03, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x04, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x05, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x06, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x06, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x06, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x06, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x07, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x07, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x07, 0, 1, 0x04, 0x02 },
-    { 0x0D, 0x07, 0, 1, 0x04, 0x02 },
-    { 0x50, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x50, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x50, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x50, 0x00, 0, 1, 0x04, 0x20 },
-    { 0x52, 0x0E, 0, 1, 0x03, 0x03 },
-    { 0x52, 0x0E, 0, 1, 0x02, 0x02 },
-    { 0x52, 0x0E, 0, 1, 0x03, 0x03 },
-    { 0x52, 0x0E, 0, 1, 0x02, 0x02 },
-    { 0x63, 0x08, 0, 0, 0x20, 0x20 },
-    { 0x63, 0x08, 0, 0, 0x20, 0x20 },
-    { 0x63, 0x08, 0, 0, 0x20, 0x20 },
-    { 0x63, 0x08, 0, 0, 0x20, 0x20 },
-    { 0x63, 0x09, 0, 0, 0x02, 0x02 },
-    { 0x63, 0x09, 0, 0, 0x02, 0x02 },
-    { 0x63, 0x09, 0, 0, 0x02, 0x02 },
-    { 0x63, 0x09, 0, 0, 0x02, 0x02 },
-    { 0x57, 0x07, 0, 1, 0x2C, 0x2C },
-    { 0x57, 0x07, 0, 1, 0x2C, 0x2C },
-    { 0x57, 0x07, 0, 1, 0x2C, 0x2C },
-    { 0x57, 0x07, 0, 1, 0x2C, 0x2C },
-    { 0x61, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x61, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x53, 0x07, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x07, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x07, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x07, 0, 1, 0x03, 0x03 },
-    { 0x0F, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x0F, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x0F, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x0F, 0x00, 1, 1, 0x02, 0x02 },
-    { 0x0C, 0x0C, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x0C, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x0C, 0, 1, 0x02, 0x02 },
-    { 0x0C, 0x0C, 0, 1, 0x02, 0x02 },
-    { 0x41, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x41, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x41, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x41, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x3D, 0x01, 0, 1, 0x04, 0x04 },
-    { 0x3D, 0x01, 0, 1, 0x04, 0x04 },
-    { 0x3D, 0x01, 0, 1, 0x04, 0x04 },
-    { 0x3D, 0x01, 0, 1, 0x04, 0x04 },
-    { 0x5C, 0x07, 0, 1, 0x03, 0x03 },
-    { 0x5C, 0x07, 0, 1, 0x02, 0x02 },
-    { 0x5C, 0x07, 0, 1, 0x03, 0x03 },
-    { 0x5C, 0x07, 0, 1, 0x02, 0x02 },
-    { 0x53, 0x08, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x08, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x08, 0, 1, 0x03, 0x03 },
-    { 0x53, 0x08, 0, 1, 0x03, 0x03 },
-    { 0x03, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x03, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x03, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x03, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x3D, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x3D, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x3D, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x3D, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x05, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x51, 0x11, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x11, 0, 1, 0x02, 0x02 },
-    { 0x51, 0x11, 0, 1, 0x03, 0x03 },
-    { 0x51, 0x11, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x03, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x04, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x05, 0, 1, 0x02, 0x03 },
-    { 0x3E, 0x05, 0, 1, 0x02, 0x03 },
-    { 0x3E, 0x05, 0, 1, 0x02, 0x03 },
-    { 0x3E, 0x05, 0, 1, 0x02, 0x03 },
-    { 0x3E, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x06, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x07, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x07, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x07, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x07, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x08, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x08, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x08, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x08, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x09, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x09, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x09, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x09, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x0A, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x0A, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x0A, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x0A, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x0B, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x0B, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x0B, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x0B, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x0C, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x0C, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x0C, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x0C, 0, 1, 0x02, 0x02 },
-    { 0x37, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x37, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x37, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x37, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x08, 0x01, 0, 1, 0x04, 0x04 },
-    { 0x08, 0x01, 0, 1, 0x04, 0x04 },
-    { 0x08, 0x01, 0, 1, 0x04, 0x04 },
-    { 0x08, 0x01, 0, 1, 0x04, 0x04 },
-    { 0x4C, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x4C, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x4C, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x4C, 0x01, 0, 1, 0x04, 0x20 },
-    { 0x63, 0x0A, 0, 1, 0x04, 0x02 },
-    { 0x63, 0x0A, 0, 1, 0x04, 0x02 },
-    { 0x63, 0x0A, 0, 1, 0x04, 0x02 },
-    { 0x63, 0x0A, 0, 1, 0x04, 0x02 },
-    { 0x09, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x09, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x09, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x09, 0x01, 0, 1, 0x02, 0x02 },
-    { 0x52, 0x0F, 0, 1, 0x03, 0x03 },
-    { 0x52, 0x0F, 0, 1, 0x02, 0x02 },
-    { 0x52, 0x0F, 0, 1, 0x03, 0x03 },
-    { 0x52, 0x0F, 0, 1, 0x02, 0x02 },
-    { 0x5B, 0x09, 0, 0, 0x02, 0x02 },
-    { 0x5B, 0x09, 0, 0, 0x02, 0x02 },
-    { 0x5B, 0x09, 0, 0, 0x02, 0x02 },
-    { 0x5B, 0x09, 0, 0, 0x02, 0x02 },
-    { 0x4C, 0x02, 0, 1, 0x04, 0x20 },
-    { 0x4C, 0x02, 0, 1, 0x04, 0x20 },
-    { 0x4C, 0x02, 0, 1, 0x04, 0x20 },
-    { 0x4C, 0x02, 0, 1, 0x04, 0x20 },
-    { 0x55, 0x0C, 0, 1, 0x04, 0x02 },
-    { 0x55, 0x0C, 0, 1, 0x04, 0x02 },
-    { 0x55, 0x0C, 0, 1, 0x04, 0x02 },
-    { 0x55, 0x0C, 0, 1, 0x04, 0x02 },
-    { 0x17, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x17, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x17, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x17, 0x02, 1, 1, 0x02, 0x02 },
-    { 0x4A, 0x01, 0, 0, 0x03, 0x03 },
-    { 0x4A, 0x01, 0, 0, 0x02, 0x02 },
-    { 0x4A, 0x01, 0, 0, 0x03, 0x03 },
-    { 0x4A, 0x01, 0, 0, 0x02, 0x02 },
-    { 0x43, 0x07, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x07, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x07, 0, 1, 0x02, 0x02 },
-    { 0x43, 0x07, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x12, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x12, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x12, 0, 1, 0x02, 0x02 },
-    { 0x5D, 0x12, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x0D, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x0D, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x0D, 0, 1, 0x02, 0x02 },
-    { 0x3E, 0x0D, 0, 1, 0x02, 0x02 },
-    { 0x56, 0x02, 0, 1, 0x12, 0x12 },
-    { 0x56, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x56, 0x02, 0, 1, 0x12, 0x12 },
-    { 0x56, 0x02, 0, 1, 0x02, 0x02 },
-    { 0x57, 0x08, 0, 1, 0x02, 0x02 },
-    { 0x57, 0x08, 0, 1, 0x02, 0x02 },
-    { 0x57, 0x08, 0, 1, 0x02, 0x02 },
-    { 0x57, 0x08, 0, 1, 0x02, 0x02 },
-    { 0x56, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x56, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x56, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x56, 0x03, 0, 1, 0x03, 0x03 },
-    { 0x57, 0x09, 0, 1, 0x03, 0x03 },
-    { 0x57, 0x09, 0, 1, 0x03, 0x03 },
-    { 0x57, 0x09, 0, 1, 0x03, 0x03 },
-    { 0x57, 0x09, 0, 1, 0x03, 0x03 },
-    { 0x5C, 0x08, 0, 1, 0x03, 0x03 },
-    { 0x5C, 0x08, 0, 1, 0x03, 0x03 },
-    { 0x5C, 0x08, 0, 1, 0x03, 0x03 },
-    { 0x5C, 0x08, 0, 1, 0x03, 0x03 },
+EntranceInfo gEntranceTable[] = {
+    { 0x00, 0x00, 0, 1, 0x02, 0x02 }, { 0x00, 0x00, 0, 1, 0x02, 0x02 }, { 0x00, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x00, 0x00, 0, 1, 0x02, 0x02 }, { 0x01, 0x00, 0, 1, 0x02, 0x02 }, { 0x01, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x01, 0x00, 0, 1, 0x02, 0x02 }, { 0x01, 0x00, 0, 1, 0x02, 0x02 }, { 0x0B, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x0B, 0x00, 0, 1, 0x02, 0x02 }, { 0x0B, 0x00, 0, 1, 0x02, 0x02 }, { 0x0B, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x14, 0x00, 1, 1, 0x02, 0x02 }, { 0x14, 0x00, 1, 1, 0x02, 0x02 }, { 0x14, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x14, 0x00, 1, 1, 0x02, 0x02 }, { 0x05, 0x00, 0, 1, 0x02, 0x02 }, { 0x05, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x05, 0x00, 0, 1, 0x02, 0x02 }, { 0x05, 0x00, 0, 1, 0x02, 0x02 }, { 0x6E, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x6E, 0x00, 0, 1, 0x02, 0x02 }, { 0x6E, 0x00, 0, 1, 0x02, 0x02 }, { 0x6E, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x6C, 0x00, 0, 1, 0x02, 0x02 }, { 0x6C, 0x00, 0, 1, 0x02, 0x02 }, { 0x6C, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x6C, 0x00, 0, 1, 0x02, 0x02 }, { 0x68, 0x00, 0, 1, 0x02, 0x02 }, { 0x68, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x68, 0x00, 0, 1, 0x02, 0x02 }, { 0x68, 0x00, 0, 1, 0x02, 0x02 }, { 0x69, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x69, 0x00, 0, 1, 0x02, 0x02 }, { 0x69, 0x00, 0, 1, 0x02, 0x02 }, { 0x69, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x6D, 0x00, 0, 1, 0x02, 0x02 }, { 0x6D, 0x00, 0, 1, 0x02, 0x02 }, { 0x6D, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x6D, 0x00, 0, 1, 0x02, 0x02 }, { 0x02, 0x00, 0, 1, 0x02, 0x02 }, { 0x02, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x02, 0x00, 0, 1, 0x02, 0x02 }, { 0x02, 0x00, 0, 1, 0x02, 0x02 }, { 0x02, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x41, 0x00, 0, 1, 0x02, 0x26 }, { 0x41, 0x00, 0, 1, 0x02, 0x26 }, { 0x41, 0x00, 0, 1, 0x02, 0x26 },
+    { 0x41, 0x00, 0, 1, 0x02, 0x26 }, { 0x41, 0x00, 0, 1, 0x02, 0x02 }, { 0x41, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x1B, 0x00, 1, 1, 0x03, 0x03 }, { 0x1C, 0x00, 1, 1, 0x02, 0x02 }, { 0x1D, 0x00, 1, 1, 0x03, 0x03 },
+    { 0x1D, 0x00, 1, 1, 0x02, 0x02 }, { 0x07, 0x00, 0, 1, 0x02, 0x02 }, { 0x07, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x07, 0x00, 0, 1, 0x02, 0x02 }, { 0x07, 0x00, 0, 1, 0x02, 0x02 }, { 0x42, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x42, 0x00, 0, 1, 0x04, 0x20 }, { 0x42, 0x00, 0, 1, 0x04, 0x20 }, { 0x42, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x3E, 0x00, 0, 1, 0x02, 0x02 }, { 0x3E, 0x00, 0, 1, 0x02, 0x02 }, { 0x3E, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x3E, 0x00, 0, 1, 0x02, 0x02 }, { 0x38, 0x00, 0, 1, 0x04, 0x20 }, { 0x38, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x38, 0x00, 0, 1, 0x04, 0x20 }, { 0x38, 0x00, 0, 1, 0x04, 0x20 }, { 0x6A, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x6A, 0x00, 0, 1, 0x02, 0x02 }, { 0x6A, 0x00, 0, 1, 0x02, 0x02 }, { 0x6A, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x40, 0x00, 0, 1, 0x02, 0x26 }, { 0x40, 0x00, 0, 1, 0x02, 0x26 }, { 0x40, 0x00, 0, 1, 0x02, 0x26 },
+    { 0x40, 0x00, 0, 1, 0x02, 0x26 }, { 0x4C, 0x00, 0, 1, 0x04, 0x20 }, { 0x4C, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x4C, 0x00, 0, 1, 0x04, 0x20 }, { 0x4C, 0x00, 0, 1, 0x04, 0x20 }, { 0x43, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x43, 0x00, 0, 1, 0x02, 0x02 }, { 0x43, 0x00, 0, 1, 0x02, 0x02 }, { 0x43, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x43, 0x00, 0, 1, 0x02, 0x02 }, { 0x43, 0x00, 0, 1, 0x02, 0x02 }, { 0x43, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x43, 0x00, 0, 1, 0x02, 0x02 }, { 0x43, 0x00, 0, 1, 0x02, 0x02 }, { 0x43, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x43, 0x00, 0, 1, 0x02, 0x02 }, { 0x43, 0x00, 0, 1, 0x0B, 0x0B }, { 0x43, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x43, 0x00, 0, 1, 0x02, 0x02 }, { 0x43, 0x00, 0, 1, 0x02, 0x02 }, { 0x43, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x10, 0x00, 0, 1, 0x04, 0x20 }, { 0x10, 0x00, 0, 1, 0x04, 0x20 }, { 0x10, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x10, 0x00, 0, 1, 0x04, 0x20 }, { 0x1E, 0x03, 1, 1, 0x03, 0x03 }, { 0x1F, 0x03, 1, 1, 0x02, 0x02 },
+    { 0x1E, 0x03, 1, 1, 0x02, 0x02 }, { 0x1F, 0x03, 1, 1, 0x02, 0x02 }, { 0x44, 0x00, 0, 1, 0x07, 0x07 },
+    { 0x44, 0x00, 0, 1, 0x07, 0x07 }, { 0x44, 0x00, 0, 1, 0x07, 0x07 }, { 0x44, 0x00, 0, 1, 0x07, 0x07 },
+    { 0x44, 0x00, 0, 1, 0x0D, 0x02 }, { 0x44, 0x00, 0, 1, 0x0D, 0x02 }, { 0x44, 0x00, 0, 1, 0x03, 0x03 },
+    { 0x4E, 0x00, 0, 1, 0x04, 0x20 }, { 0x4E, 0x00, 0, 1, 0x04, 0x20 }, { 0x4E, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x4E, 0x00, 0, 1, 0x04, 0x20 }, { 0x6B, 0x00, 0, 1, 0x22, 0x22 }, { 0x6B, 0x00, 0, 1, 0x22, 0x22 },
+    { 0x6B, 0x00, 0, 1, 0x22, 0x22 }, { 0x6B, 0x00, 0, 1, 0x22, 0x22 }, { 0x45, 0x00, 0, 1, 0x22, 0x04 },
+    { 0x46, 0x00, 0, 1, 0x22, 0x04 }, { 0x45, 0x00, 0, 1, 0x22, 0x04 }, { 0x46, 0x00, 0, 1, 0x22, 0x04 },
+    { 0x4D, 0x00, 0, 1, 0x02, 0x02 }, { 0x4D, 0x00, 0, 1, 0x02, 0x02 }, { 0x4D, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x4D, 0x00, 0, 1, 0x02, 0x02 }, { 0x06, 0x00, 0, 1, 0x02, 0x02 }, { 0x06, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x06, 0x00, 0, 1, 0x02, 0x02 }, { 0x06, 0x00, 0, 1, 0x02, 0x02 }, { 0x06, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x06, 0x00, 0, 1, 0x02, 0x02 }, { 0x09, 0x00, 0, 1, 0x02, 0x02 }, { 0x09, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x09, 0x00, 0, 1, 0x02, 0x02 }, { 0x09, 0x00, 0, 1, 0x02, 0x02 }, { 0x09, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x17, 0x00, 1, 1, 0x02, 0x02 }, { 0x17, 0x00, 1, 1, 0x02, 0x02 }, { 0x17, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x17, 0x00, 1, 1, 0x02, 0x02 }, { 0x17, 0x00, 0, 1, 0x02, 0x02 }, { 0x17, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x17, 0x00, 0, 1, 0x02, 0x02 }, { 0x65, 0x00, 0, 1, 0x02, 0x02 }, { 0x65, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x65, 0x00, 0, 1, 0x02, 0x02 }, { 0x65, 0x00, 0, 1, 0x02, 0x02 }, { 0x08, 0x00, 0, 1, 0x04, 0x04 },
+    { 0x08, 0x00, 0, 1, 0x04, 0x04 }, { 0x08, 0x00, 0, 1, 0x04, 0x04 }, { 0x08, 0x00, 0, 1, 0x04, 0x04 },
+    { 0x27, 0x00, 0, 1, 0x04, 0x04 }, { 0x27, 0x00, 0, 1, 0x04, 0x04 }, { 0x27, 0x00, 0, 1, 0x04, 0x04 },
+    { 0x27, 0x00, 0, 1, 0x04, 0x04 }, { 0x47, 0x00, 0, 1, 0x03, 0x03 }, { 0x47, 0x00, 0, 1, 0x03, 0x03 },
+    { 0x47, 0x00, 0, 1, 0x03, 0x03 }, { 0x47, 0x00, 0, 1, 0x03, 0x03 }, { 0x47, 0x00, 0, 1, 0x0A, 0x0A },
+    { 0x47, 0x00, 0, 1, 0x02, 0x0A }, { 0x47, 0x00, 1, 1, 0x0A, 0x0A }, { 0x47, 0x00, 0, 1, 0x0B, 0x0B },
+    { 0x47, 0x00, 0, 1, 0x03, 0x03 }, { 0x47, 0x00, 0, 1, 0x02, 0x02 }, { 0x47, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x47, 0x00, 0, 1, 0x03, 0x03 }, { 0x47, 0x00, 0, 1, 0x03, 0x03 }, { 0x1E, 0x00, 1, 1, 0x03, 0x03 },
+    { 0x1F, 0x00, 1, 1, 0x02, 0x02 }, { 0x1E, 0x00, 1, 1, 0x02, 0x02 }, { 0x1F, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x20, 0x00, 1, 1, 0x03, 0x03 }, { 0x21, 0x00, 1, 1, 0x02, 0x02 }, { 0x22, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x22, 0x00, 1, 1, 0x02, 0x02 }, { 0x20, 0x00, 0, 1, 0x08, 0x08 }, { 0x67, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x2C, 0x00, 0, 1, 0x04, 0x20 }, { 0x2C, 0x00, 0, 1, 0x04, 0x20 }, { 0x2C, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x2C, 0x00, 0, 1, 0x04, 0x20 }, { 0x34, 0x00, 0, 1, 0x04, 0x04 }, { 0x34, 0x00, 0, 1, 0x04, 0x04 },
+    { 0x34, 0x00, 0, 1, 0x04, 0x04 }, { 0x34, 0x00, 0, 1, 0x04, 0x04 }, { 0x34, 0x00, 0, 1, 0x04, 0x02 },
+    { 0x34, 0x00, 0, 1, 0x10, 0x10 }, { 0x2D, 0x00, 0, 1, 0x04, 0x04 }, { 0x2D, 0x00, 0, 1, 0x04, 0x04 },
+    { 0x2D, 0x00, 0, 1, 0x04, 0x04 }, { 0x2D, 0x00, 0, 1, 0x04, 0x04 }, { 0x01, 0x01, 1, 0, 0x02, 0x02 },
+    { 0x01, 0x01, 1, 0, 0x02, 0x02 }, { 0x01, 0x01, 1, 0, 0x02, 0x02 }, { 0x01, 0x01, 1, 0, 0x02, 0x02 },
+    { 0x26, 0x00, 0, 1, 0x04, 0x04 }, { 0x26, 0x00, 0, 1, 0x04, 0x04 }, { 0x26, 0x00, 0, 1, 0x04, 0x04 },
+    { 0x26, 0x00, 0, 1, 0x04, 0x04 }, { 0x51, 0x00, 0, 1, 0x03, 0x03 }, { 0x51, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x51, 0x00, 0, 1, 0x03, 0x03 }, { 0x51, 0x00, 0, 1, 0x02, 0x02 }, { 0x51, 0x00, 0, 1, 0x04, 0x02 },
+    { 0x51, 0x00, 0, 1, 0x21, 0x21 }, { 0x51, 0x00, 0, 1, 0x21, 0x21 }, { 0x51, 0x00, 0, 1, 0x23, 0x23 },
+    { 0x51, 0x00, 0, 1, 0x03, 0x03 }, { 0x51, 0x00, 1, 1, 0x02, 0x02 }, { 0x51, 0x00, 0, 1, 0x23, 0x23 },
+    { 0x51, 0x00, 0, 1, 0x03, 0x03 }, { 0x51, 0x00, 0, 1, 0x29, 0x29 }, { 0x51, 0x00, 1, 1, 0x03, 0x03 },
+    { 0x52, 0x00, 0, 1, 0x03, 0x03 }, { 0x52, 0x00, 0, 1, 0x02, 0x02 }, { 0x52, 0x00, 0, 1, 0x03, 0x03 },
+    { 0x52, 0x00, 0, 1, 0x02, 0x02 }, { 0x52, 0x00, 0, 1, 0x26, 0x26 }, { 0x52, 0x00, 0, 1, 0x21, 0x21 },
+    { 0x52, 0x00, 1, 1, 0x21, 0x21 }, { 0x52, 0x00, 0, 1, 0x21, 0x21 }, { 0x52, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x53, 0x00, 0, 1, 0x03, 0x03 }, { 0x53, 0x00, 0, 1, 0x02, 0x02 }, { 0x53, 0x00, 0, 1, 0x03, 0x03 },
+    { 0x53, 0x00, 0, 1, 0x02, 0x02 }, { 0x53, 0x00, 0, 1, 0x04, 0x02 }, { 0x53, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x54, 0x00, 1, 1, 0x03, 0x03 }, { 0x54, 0x00, 1, 1, 0x02, 0x02 }, { 0x54, 0x00, 1, 1, 0x03, 0x03 },
+    { 0x54, 0x00, 1, 1, 0x02, 0x02 }, { 0x55, 0x00, 0, 1, 0x03, 0x03 }, { 0x55, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x55, 0x00, 0, 1, 0x03, 0x03 }, { 0x55, 0x00, 0, 1, 0x02, 0x02 }, { 0x55, 0x00, 1, 1, 0x0A, 0x0A },
+    { 0x55, 0x00, 0, 1, 0x0A, 0x0A }, { 0x55, 0x00, 1, 1, 0x0A, 0x0A }, { 0x55, 0x00, 0, 1, 0x0D, 0x0A },
+    { 0x55, 0x00, 0, 1, 0x0A, 0x0A }, { 0x55, 0x00, 0, 1, 0x0A, 0x0A }, { 0x55, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x55, 0x00, 1, 1, 0x02, 0x02 }, { 0x55, 0x00, 1, 1, 0x02, 0x02 }, { 0x55, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x56, 0x00, 1, 1, 0x02, 0x02 }, { 0x56, 0x00, 1, 1, 0x02, 0x02 }, { 0x56, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x56, 0x00, 1, 1, 0x02, 0x02 }, { 0x56, 0x00, 0, 1, 0x03, 0x03 }, { 0x56, 0x00, 0, 1, 0x00, 0x00 },
+    { 0x57, 0x00, 1, 1, 0x03, 0x03 }, { 0x57, 0x00, 1, 1, 0x02, 0x02 }, { 0x57, 0x00, 1, 1, 0x03, 0x03 },
+    { 0x57, 0x00, 1, 1, 0x02, 0x02 }, { 0x57, 0x00, 0, 1, 0x03, 0x03 }, { 0x57, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x58, 0x00, 0, 1, 0x02, 0x02 }, { 0x58, 0x00, 0, 1, 0x02, 0x02 }, { 0x58, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x58, 0x00, 0, 1, 0x02, 0x02 }, { 0x58, 0x00, 1, 1, 0x02, 0x02 }, { 0x58, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x59, 0x00, 0, 1, 0x03, 0x03 }, { 0x59, 0x00, 0, 1, 0x02, 0x02 }, { 0x59, 0x00, 0, 1, 0x03, 0x03 },
+    { 0x59, 0x00, 0, 1, 0x02, 0x02 }, { 0x59, 0x00, 0, 1, 0x0D, 0x00 }, { 0x59, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x59, 0x00, 1, 1, 0x02, 0x02 }, { 0x59, 0x00, 0, 1, 0x02, 0x02 }, { 0x59, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x5A, 0x00, 0, 1, 0x03, 0x03 }, { 0x5A, 0x00, 0, 1, 0x02, 0x02 }, { 0x5A, 0x00, 0, 1, 0x03, 0x03 },
+    { 0x5A, 0x00, 0, 1, 0x02, 0x02 }, { 0x5A, 0x00, 1, 1, 0x0C, 0x0A }, { 0x5A, 0x00, 1, 1, 0x0A, 0x0A },
+    { 0x5A, 0x00, 1, 1, 0x02, 0x02 }, { 0x5B, 0x00, 0, 1, 0x02, 0x02 }, { 0x5B, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x5B, 0x00, 0, 1, 0x02, 0x02 }, { 0x5B, 0x00, 0, 1, 0x02, 0x02 }, { 0x5B, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x5C, 0x00, 1, 1, 0x0F, 0x0F }, { 0x5C, 0x00, 1, 1, 0x0F, 0x0F }, { 0x5C, 0x00, 1, 1, 0x0F, 0x0F },
+    { 0x5C, 0x00, 1, 1, 0x0F, 0x0F }, { 0x5C, 0x00, 1, 1, 0x02, 0x02 }, { 0x5C, 0x00, 1, 1, 0x0F, 0x0F },
+    { 0x5D, 0x00, 1, 1, 0x03, 0x03 }, { 0x5D, 0x00, 1, 1, 0x02, 0x02 }, { 0x5D, 0x00, 1, 1, 0x03, 0x03 },
+    { 0x5D, 0x00, 1, 1, 0x02, 0x02 }, { 0x5D, 0x00, 1, 1, 0x21, 0x21 }, { 0x5D, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x5D, 0x00, 1, 1, 0x02, 0x02 }, { 0x5E, 0x00, 1, 1, 0x0E, 0x0E }, { 0x5E, 0x00, 1, 1, 0x0E, 0x0E },
+    { 0x5E, 0x00, 1, 1, 0x0E, 0x0E }, { 0x5E, 0x00, 1, 1, 0x0E, 0x0E }, { 0x0E, 0x01, 1, 1, 0x02, 0x02 },
+    { 0x0E, 0x01, 1, 1, 0x02, 0x02 }, { 0x0E, 0x01, 1, 1, 0x02, 0x02 }, { 0x0E, 0x01, 1, 1, 0x02, 0x02 },
+    { 0x5F, 0x00, 0, 1, 0x03, 0x03 }, { 0x5F, 0x00, 0, 1, 0x02, 0x02 }, { 0x64, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x64, 0x00, 0, 1, 0x02, 0x02 }, { 0x64, 0x00, 0, 1, 0x04, 0x02 }, { 0x60, 0x00, 0, 1, 0x03, 0x03 },
+    { 0x60, 0x00, 0, 1, 0x02, 0x02 }, { 0x60, 0x00, 0, 1, 0x03, 0x03 }, { 0x60, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x60, 0x00, 1, 1, 0x0A, 0x0A }, { 0x60, 0x00, 0, 1, 0x03, 0x03 }, { 0x60, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x60, 0x00, 1, 1, 0x02, 0x02 }, { 0x60, 0x00, 1, 1, 0x03, 0x03 }, { 0x60, 0x00, 1, 1, 0x03, 0x03 },
+    { 0x61, 0x00, 0, 1, 0x02, 0x02 }, { 0x61, 0x00, 0, 1, 0x02, 0x02 }, { 0x61, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x61, 0x00, 0, 1, 0x02, 0x02 }, { 0x61, 0x00, 0, 1, 0x03, 0x03 }, { 0x61, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x62, 0x00, 0, 1, 0x02, 0x02 }, { 0x62, 0x00, 0, 1, 0x02, 0x02 }, { 0x62, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x62, 0x00, 0, 1, 0x02, 0x02 }, { 0x62, 0x00, 0, 1, 0x02, 0x02 }, { 0x62, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x58, 0x03, 0, 1, 0x00, 0x00 }, { 0x58, 0x03, 0, 1, 0x00, 0x00 }, { 0x58, 0x03, 0, 1, 0x00, 0x00 },
+    { 0x58, 0x03, 0, 1, 0x00, 0x00 }, { 0x63, 0x00, 0, 1, 0x03, 0x03 }, { 0x63, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x63, 0x00, 0, 1, 0x03, 0x03 }, { 0x63, 0x00, 0, 1, 0x02, 0x02 }, { 0x63, 0x00, 0, 1, 0x20, 0x20 },
+    { 0x63, 0x00, 0, 1, 0x2A, 0x2A }, { 0x63, 0x00, 1, 1, 0x02, 0x02 }, { 0x63, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x63, 0x00, 1, 1, 0x02, 0x02 }, { 0x63, 0x00, 1, 1, 0x02, 0x02 }, { 0x63, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x63, 0x00, 1, 1, 0x02, 0x02 }, { 0x63, 0x00, 1, 1, 0x02, 0x02 }, { 0x63, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x04, 0x00, 0, 1, 0x02, 0x02 }, { 0x04, 0x00, 0, 1, 0x02, 0x02 }, { 0x04, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x04, 0x00, 0, 1, 0x02, 0x02 }, { 0x03, 0x00, 0, 1, 0x02, 0x02 }, { 0x03, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x03, 0x00, 0, 1, 0x02, 0x02 }, { 0x03, 0x00, 0, 1, 0x02, 0x02 }, { 0x42, 0x01, 0, 1, 0x04, 0x20 },
+    { 0x42, 0x01, 0, 1, 0x04, 0x20 }, { 0x42, 0x01, 0, 1, 0x04, 0x20 }, { 0x42, 0x01, 0, 1, 0x04, 0x20 },
+    { 0x23, 0x00, 0, 1, 0x03, 0x03 }, { 0x24, 0x00, 0, 1, 0x02, 0x02 }, { 0x25, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x25, 0x00, 0, 1, 0x02, 0x02 }, { 0x04, 0x01, 1, 1, 0x02, 0x02 }, { 0x04, 0x01, 1, 1, 0x02, 0x02 },
+    { 0x04, 0x01, 1, 1, 0x02, 0x02 }, { 0x04, 0x01, 1, 1, 0x02, 0x02 }, { 0x0E, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x0E, 0x00, 1, 1, 0x02, 0x02 }, { 0x0E, 0x00, 1, 1, 0x02, 0x02 }, { 0x0E, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x51, 0x01, 0, 1, 0x03, 0x03 }, { 0x51, 0x01, 0, 1, 0x02, 0x02 }, { 0x51, 0x01, 0, 1, 0x03, 0x03 },
+    { 0x51, 0x01, 0, 1, 0x02, 0x02 }, { 0x51, 0x02, 1, 1, 0x03, 0x03 }, { 0x51, 0x02, 1, 1, 0x02, 0x02 },
+    { 0x51, 0x02, 1, 1, 0x03, 0x03 }, { 0x51, 0x02, 1, 1, 0x02, 0x02 }, { 0x51, 0x03, 0, 1, 0x02, 0x02 },
+    { 0x51, 0x03, 0, 1, 0x02, 0x02 }, { 0x51, 0x03, 0, 1, 0x02, 0x02 }, { 0x51, 0x03, 0, 1, 0x02, 0x02 },
+    { 0x51, 0x04, 1, 1, 0x03, 0x03 }, { 0x51, 0x04, 1, 1, 0x02, 0x02 }, { 0x51, 0x04, 1, 1, 0x03, 0x03 },
+    { 0x51, 0x04, 1, 1, 0x02, 0x02 }, { 0x51, 0x05, 0, 1, 0x03, 0x03 }, { 0x51, 0x05, 0, 1, 0x02, 0x02 },
+    { 0x51, 0x05, 0, 1, 0x03, 0x03 }, { 0x51, 0x05, 0, 1, 0x02, 0x02 }, { 0x52, 0x01, 0, 1, 0x03, 0x03 },
+    { 0x52, 0x01, 0, 1, 0x02, 0x02 }, { 0x52, 0x01, 0, 1, 0x03, 0x03 }, { 0x52, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x52, 0x02, 0, 1, 0x03, 0x03 }, { 0x52, 0x02, 0, 1, 0x02, 0x02 }, { 0x52, 0x02, 0, 1, 0x03, 0x03 },
+    { 0x52, 0x02, 0, 1, 0x02, 0x02 }, { 0x54, 0x01, 1, 1, 0x03, 0x03 }, { 0x54, 0x01, 1, 1, 0x03, 0x03 },
+    { 0x54, 0x01, 1, 1, 0x03, 0x03 }, { 0x54, 0x01, 1, 1, 0x03, 0x03 }, { 0x54, 0x02, 0, 1, 0x03, 0x03 },
+    { 0x54, 0x02, 0, 1, 0x02, 0x02 }, { 0x54, 0x02, 0, 1, 0x03, 0x03 }, { 0x54, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x58, 0x01, 0, 1, 0x02, 0x02 }, { 0x58, 0x01, 0, 1, 0x02, 0x02 }, { 0x58, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x58, 0x01, 0, 1, 0x02, 0x02 }, { 0x5A, 0x01, 0, 1, 0x03, 0x03 }, { 0x5A, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x5A, 0x01, 0, 1, 0x03, 0x03 }, { 0x5A, 0x01, 0, 1, 0x02, 0x02 }, { 0x5B, 0x01, 1, 1, 0x02, 0x02 },
+    { 0x5B, 0x01, 1, 1, 0x02, 0x02 }, { 0x5B, 0x01, 1, 1, 0x02, 0x02 }, { 0x5B, 0x01, 1, 1, 0x02, 0x02 },
+    { 0x5B, 0x02, 0, 1, 0x02, 0x02 }, { 0x5B, 0x02, 0, 1, 0x02, 0x02 }, { 0x5B, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x5B, 0x02, 0, 1, 0x02, 0x02 }, { 0x5B, 0x03, 0, 1, 0x02, 0x02 }, { 0x5B, 0x03, 0, 1, 0x02, 0x02 },
+    { 0x5B, 0x03, 0, 1, 0x02, 0x02 }, { 0x5B, 0x03, 0, 1, 0x02, 0x02 }, { 0x0E, 0x02, 1, 1, 0x02, 0x02 },
+    { 0x0E, 0x02, 1, 1, 0x02, 0x02 }, { 0x0E, 0x02, 1, 1, 0x02, 0x02 }, { 0x0E, 0x02, 1, 1, 0x02, 0x02 },
+    { 0x60, 0x01, 0, 1, 0x03, 0x03 }, { 0x60, 0x01, 0, 1, 0x02, 0x02 }, { 0x60, 0x01, 0, 1, 0x03, 0x03 },
+    { 0x60, 0x01, 0, 1, 0x02, 0x02 }, { 0x60, 0x02, 0, 1, 0x03, 0x03 }, { 0x60, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x60, 0x02, 0, 1, 0x03, 0x03 }, { 0x60, 0x02, 0, 1, 0x02, 0x02 }, { 0x62, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x62, 0x01, 0, 1, 0x02, 0x02 }, { 0x62, 0x01, 0, 1, 0x02, 0x02 }, { 0x62, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x38, 0x01, 0, 1, 0x04, 0x20 }, { 0x38, 0x01, 0, 1, 0x04, 0x20 }, { 0x38, 0x01, 0, 1, 0x04, 0x20 },
+    { 0x38, 0x01, 0, 1, 0x04, 0x20 }, { 0x1A, 0x05, 1, 1, 0x02, 0x02 }, { 0x1A, 0x05, 1, 1, 0x02, 0x02 },
+    { 0x1A, 0x05, 1, 1, 0x02, 0x02 }, { 0x1A, 0x05, 1, 1, 0x02, 0x02 }, { 0x20, 0x08, 0, 1, 0x04, 0x02 },
+    { 0x21, 0x08, 0, 1, 0x04, 0x02 }, { 0x22, 0x08, 0, 1, 0x04, 0x02 }, { 0x22, 0x08, 0, 1, 0x04, 0x02 },
+    { 0x20, 0x09, 0, 1, 0x04, 0x02 }, { 0x21, 0x09, 0, 1, 0x04, 0x02 }, { 0x22, 0x09, 0, 1, 0x04, 0x02 },
+    { 0x22, 0x09, 0, 1, 0x04, 0x02 }, { 0x20, 0x0A, 0, 1, 0x04, 0x02 }, { 0x21, 0x0A, 0, 1, 0x04, 0x02 },
+    { 0x22, 0x0A, 0, 1, 0x04, 0x02 }, { 0x22, 0x0A, 0, 1, 0x04, 0x02 }, { 0x54, 0x03, 1, 1, 0x03, 0x03 },
+    { 0x54, 0x03, 1, 1, 0x02, 0x02 }, { 0x54, 0x03, 1, 1, 0x03, 0x03 }, { 0x54, 0x03, 1, 1, 0x02, 0x02 },
+    { 0x54, 0x04, 0, 1, 0x2C, 0x2C }, { 0x54, 0x04, 0, 1, 0x2C, 0x2C }, { 0x54, 0x04, 0, 1, 0x2C, 0x2C },
+    { 0x54, 0x04, 0, 1, 0x2C, 0x2C }, { 0x5C, 0x01, 0, 1, 0x03, 0x03 }, { 0x5C, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x5C, 0x01, 0, 1, 0x03, 0x03 }, { 0x5C, 0x01, 0, 1, 0x02, 0x02 }, { 0x5C, 0x02, 0, 0, 0x03, 0x03 },
+    { 0x5C, 0x02, 0, 0, 0x02, 0x02 }, { 0x5C, 0x02, 0, 0, 0x03, 0x03 }, { 0x5C, 0x02, 0, 0, 0x02, 0x02 },
+    { 0x5C, 0x03, 0, 0, 0x03, 0x03 }, { 0x5C, 0x03, 0, 0, 0x02, 0x02 }, { 0x5C, 0x03, 0, 0, 0x03, 0x03 },
+    { 0x5C, 0x03, 0, 0, 0x02, 0x02 }, { 0x5C, 0x04, 0, 1, 0x02, 0x02 }, { 0x5C, 0x04, 0, 1, 0x02, 0x02 },
+    { 0x5C, 0x04, 0, 1, 0x02, 0x02 }, { 0x5C, 0x04, 0, 1, 0x02, 0x02 }, { 0x5C, 0x05, 0, 1, 0x03, 0x03 },
+    { 0x5C, 0x05, 0, 1, 0x02, 0x02 }, { 0x5C, 0x05, 0, 1, 0x03, 0x03 }, { 0x5C, 0x05, 0, 1, 0x02, 0x02 },
+    { 0x5C, 0x06, 1, 0, 0x0F, 0x0F }, { 0x5C, 0x06, 1, 0, 0x0F, 0x0F }, { 0x5C, 0x06, 1, 0, 0x0F, 0x0F },
+    { 0x5C, 0x06, 1, 0, 0x0F, 0x0F }, { 0x51, 0x06, 0, 1, 0x03, 0x03 }, { 0x51, 0x06, 0, 1, 0x02, 0x02 },
+    { 0x51, 0x06, 0, 1, 0x03, 0x03 }, { 0x51, 0x06, 0, 1, 0x02, 0x02 }, { 0x51, 0x07, 0, 1, 0x03, 0x03 },
+    { 0x51, 0x07, 0, 1, 0x02, 0x02 }, { 0x51, 0x07, 0, 1, 0x03, 0x03 }, { 0x51, 0x07, 0, 1, 0x02, 0x02 },
+    { 0x52, 0x03, 0, 1, 0x04, 0x02 }, { 0x52, 0x03, 0, 1, 0x04, 0x02 }, { 0x52, 0x03, 0, 1, 0x04, 0x02 },
+    { 0x52, 0x03, 0, 1, 0x04, 0x02 }, { 0x53, 0x01, 0, 1, 0x02, 0x02 }, { 0x53, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x53, 0x01, 0, 1, 0x02, 0x02 }, { 0x53, 0x01, 0, 1, 0x02, 0x02 }, { 0x55, 0x01, 0, 1, 0x03, 0x03 },
+    { 0x55, 0x01, 0, 1, 0x02, 0x02 }, { 0x55, 0x01, 0, 1, 0x03, 0x03 }, { 0x55, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x55, 0x02, 0, 1, 0x02, 0x02 }, { 0x55, 0x02, 0, 1, 0x02, 0x02 }, { 0x55, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x55, 0x02, 0, 1, 0x02, 0x02 }, { 0x55, 0x03, 0, 1, 0x04, 0x04 }, { 0x55, 0x03, 0, 1, 0x04, 0x04 },
+    { 0x55, 0x03, 0, 1, 0x04, 0x04 }, { 0x55, 0x03, 0, 1, 0x04, 0x04 }, { 0x56, 0x01, 0, 1, 0x12, 0x12 },
+    { 0x56, 0x01, 0, 1, 0x02, 0x02 }, { 0x56, 0x01, 0, 1, 0x12, 0x12 }, { 0x56, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x57, 0x01, 0, 1, 0x03, 0x03 }, { 0x57, 0x01, 0, 1, 0x02, 0x02 }, { 0x57, 0x01, 0, 1, 0x03, 0x03 },
+    { 0x57, 0x01, 0, 1, 0x02, 0x02 }, { 0x57, 0x02, 0, 1, 0x13, 0x13 }, { 0x57, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x57, 0x02, 0, 1, 0x13, 0x13 }, { 0x57, 0x02, 0, 1, 0x02, 0x02 }, { 0x59, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x59, 0x01, 0, 1, 0x02, 0x02 }, { 0x59, 0x01, 0, 1, 0x02, 0x02 }, { 0x59, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x59, 0x02, 0, 1, 0x03, 0x03 }, { 0x59, 0x02, 0, 1, 0x02, 0x02 }, { 0x59, 0x02, 0, 1, 0x03, 0x03 },
+    { 0x59, 0x02, 0, 1, 0x02, 0x02 }, { 0x5A, 0x02, 1, 1, 0x03, 0x03 }, { 0x5A, 0x02, 1, 1, 0x02, 0x02 },
+    { 0x5A, 0x02, 1, 1, 0x03, 0x03 }, { 0x5A, 0x02, 1, 1, 0x02, 0x02 }, { 0x5A, 0x03, 1, 1, 0x03, 0x03 },
+    { 0x5A, 0x03, 1, 1, 0x02, 0x02 }, { 0x5A, 0x03, 1, 1, 0x03, 0x03 }, { 0x5A, 0x03, 1, 1, 0x02, 0x02 },
+    { 0x5D, 0x01, 0, 1, 0x03, 0x03 }, { 0x5D, 0x01, 0, 1, 0x02, 0x02 }, { 0x5D, 0x01, 0, 1, 0x03, 0x03 },
+    { 0x5D, 0x01, 0, 1, 0x02, 0x02 }, { 0x5D, 0x02, 0, 1, 0x03, 0x03 }, { 0x5D, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x5D, 0x02, 0, 1, 0x03, 0x03 }, { 0x5D, 0x02, 0, 1, 0x02, 0x02 }, { 0x5D, 0x03, 0, 1, 0x03, 0x03 },
+    { 0x5D, 0x03, 0, 1, 0x02, 0x02 }, { 0x5D, 0x03, 0, 1, 0x03, 0x03 }, { 0x5D, 0x03, 0, 1, 0x02, 0x02 },
+    { 0x5F, 0x01, 0, 1, 0x03, 0x03 }, { 0x5F, 0x01, 0, 1, 0x02, 0x02 }, { 0x64, 0x01, 0, 1, 0x05, 0x05 },
+    { 0x64, 0x01, 0, 1, 0x05, 0x05 }, { 0x5F, 0x01, 0, 1, 0x00, 0x00 }, { 0x60, 0x03, 0, 1, 0x03, 0x03 },
+    { 0x60, 0x03, 0, 1, 0x02, 0x02 }, { 0x60, 0x03, 0, 1, 0x03, 0x03 }, { 0x60, 0x03, 0, 1, 0x02, 0x02 },
+    { 0x61, 0x01, 0, 1, 0x02, 0x02 }, { 0x61, 0x01, 0, 1, 0x02, 0x02 }, { 0x61, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x61, 0x01, 0, 1, 0x02, 0x02 }, { 0x61, 0x02, 0, 1, 0x02, 0x02 }, { 0x61, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x61, 0x02, 0, 1, 0x02, 0x02 }, { 0x61, 0x02, 0, 1, 0x02, 0x02 }, { 0x03, 0x01, 1, 1, 0x02, 0x02 },
+    { 0x03, 0x01, 1, 1, 0x02, 0x02 }, { 0x03, 0x01, 1, 1, 0x02, 0x02 }, { 0x03, 0x01, 1, 1, 0x02, 0x02 },
+    { 0x00, 0x01, 1, 0, 0x02, 0x02 }, { 0x00, 0x01, 1, 0, 0x02, 0x02 }, { 0x00, 0x01, 1, 0, 0x02, 0x02 },
+    { 0x00, 0x01, 1, 0, 0x02, 0x02 }, { 0x0E, 0x03, 1, 1, 0x02, 0x02 }, { 0x0E, 0x03, 1, 1, 0x02, 0x02 },
+    { 0x0E, 0x03, 1, 1, 0x02, 0x02 }, { 0x0E, 0x03, 1, 1, 0x02, 0x02 }, { 0x20, 0x01, 0, 1, 0x03, 0x03 },
+    { 0x21, 0x01, 0, 1, 0x02, 0x02 }, { 0x22, 0x01, 0, 1, 0x02, 0x02 }, { 0x22, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x20, 0x02, 0, 1, 0x03, 0x03 }, { 0x21, 0x02, 0, 1, 0x02, 0x02 }, { 0x22, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x22, 0x02, 0, 1, 0x02, 0x02 }, { 0x20, 0x03, 1, 1, 0x03, 0x03 }, { 0x21, 0x03, 1, 1, 0x02, 0x02 },
+    { 0x22, 0x03, 1, 1, 0x02, 0x02 }, { 0x22, 0x03, 1, 1, 0x02, 0x02 }, { 0x55, 0x04, 0, 0, 0x04, 0x04 },
+    { 0x55, 0x04, 0, 0, 0x04, 0x04 }, { 0x55, 0x04, 0, 0, 0x04, 0x04 }, { 0x55, 0x04, 0, 0, 0x04, 0x04 },
+    { 0x55, 0x05, 0, 0, 0x04, 0x04 }, { 0x55, 0x05, 0, 0, 0x04, 0x04 }, { 0x55, 0x05, 0, 0, 0x04, 0x04 },
+    { 0x55, 0x05, 0, 0, 0x04, 0x04 }, { 0x1B, 0x02, 0, 0, 0x02, 0x02 }, { 0x1C, 0x02, 0, 0, 0x02, 0x02 },
+    { 0x1D, 0x02, 0, 0, 0x02, 0x02 }, { 0x1D, 0x02, 0, 0, 0x02, 0x02 }, { 0x34, 0x01, 0, 1, 0x04, 0x04 },
+    { 0x34, 0x01, 0, 1, 0x04, 0x04 }, { 0x34, 0x01, 0, 1, 0x04, 0x04 }, { 0x34, 0x01, 0, 1, 0x04, 0x04 },
+    { 0x1B, 0x01, 0, 1, 0x03, 0x03 }, { 0x1C, 0x01, 0, 1, 0x02, 0x02 }, { 0x1D, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x1D, 0x01, 0, 1, 0x02, 0x02 }, { 0x51, 0x08, 1, 1, 0x03, 0x03 }, { 0x51, 0x08, 1, 1, 0x02, 0x02 },
+    { 0x51, 0x08, 1, 1, 0x03, 0x03 }, { 0x51, 0x08, 1, 1, 0x02, 0x02 }, { 0x51, 0x09, 0, 1, 0x03, 0x03 },
+    { 0x51, 0x09, 0, 1, 0x03, 0x03 }, { 0x51, 0x09, 0, 1, 0x03, 0x03 }, { 0x51, 0x09, 0, 1, 0x03, 0x03 },
+    { 0x51, 0x0A, 0, 1, 0x03, 0x03 }, { 0x51, 0x0A, 0, 1, 0x03, 0x03 }, { 0x51, 0x0A, 0, 1, 0x03, 0x03 },
+    { 0x51, 0x0A, 0, 1, 0x03, 0x03 }, { 0x55, 0x06, 0, 1, 0x02, 0x02 }, { 0x55, 0x06, 0, 1, 0x02, 0x02 },
+    { 0x55, 0x06, 0, 1, 0x02, 0x02 }, { 0x55, 0x06, 0, 1, 0x02, 0x02 }, { 0x51, 0x0B, 0, 1, 0x05, 0x05 },
+    { 0x51, 0x0B, 0, 1, 0x04, 0x02 }, { 0x51, 0x0B, 0, 1, 0x05, 0x05 }, { 0x51, 0x0B, 0, 1, 0x04, 0x02 },
+    { 0x51, 0x0C, 0, 1, 0x05, 0x05 }, { 0x51, 0x0C, 0, 1, 0x04, 0x02 }, { 0x51, 0x0C, 0, 1, 0x05, 0x05 },
+    { 0x51, 0x0C, 0, 1, 0x04, 0x02 }, { 0x51, 0x0D, 0, 1, 0x05, 0x05 }, { 0x51, 0x0D, 0, 1, 0x04, 0x02 },
+    { 0x51, 0x0D, 0, 1, 0x05, 0x05 }, { 0x51, 0x0D, 0, 1, 0x04, 0x02 }, { 0x45, 0x01, 0, 1, 0x03, 0x03 },
+    { 0x46, 0x01, 0, 1, 0x02, 0x02 }, { 0x45, 0x01, 0, 1, 0x03, 0x03 }, { 0x46, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x1E, 0x01, 1, 1, 0x03, 0x03 }, { 0x1F, 0x01, 1, 1, 0x02, 0x02 }, { 0x1E, 0x01, 1, 1, 0x02, 0x02 },
+    { 0x1F, 0x01, 1, 1, 0x02, 0x02 }, { 0x20, 0x04, 1, 1, 0x03, 0x03 }, { 0x21, 0x04, 1, 1, 0x02, 0x02 },
+    { 0x22, 0x04, 1, 1, 0x02, 0x02 }, { 0x22, 0x04, 1, 1, 0x02, 0x02 }, { 0x20, 0x05, 0, 1, 0x04, 0x02 },
+    { 0x21, 0x05, 0, 1, 0x04, 0x02 }, { 0x22, 0x05, 0, 1, 0x04, 0x02 }, { 0x22, 0x05, 0, 1, 0x04, 0x02 },
+    { 0x52, 0x04, 0, 1, 0x02, 0x02 }, { 0x52, 0x04, 0, 1, 0x02, 0x02 }, { 0x52, 0x04, 0, 1, 0x02, 0x02 },
+    { 0x52, 0x04, 0, 1, 0x02, 0x02 }, { 0x5D, 0x04, 0, 1, 0x03, 0x03 }, { 0x5D, 0x04, 0, 1, 0x02, 0x02 },
+    { 0x5D, 0x04, 0, 1, 0x03, 0x03 }, { 0x5D, 0x04, 0, 1, 0x02, 0x02 }, { 0x63, 0x01, 0, 0, 0x03, 0x03 },
+    { 0x63, 0x01, 0, 0, 0x02, 0x02 }, { 0x63, 0x01, 0, 0, 0x03, 0x03 }, { 0x63, 0x01, 0, 0, 0x02, 0x02 },
+    { 0x07, 0x01, 0, 1, 0x02, 0x02 }, { 0x07, 0x01, 0, 1, 0x02, 0x02 }, { 0x07, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x07, 0x01, 0, 1, 0x02, 0x02 }, { 0x07, 0x02, 1, 1, 0x02, 0x02 }, { 0x07, 0x02, 1, 1, 0x02, 0x02 },
+    { 0x07, 0x02, 1, 1, 0x02, 0x02 }, { 0x07, 0x02, 1, 1, 0x02, 0x02 }, { 0x5D, 0x05, 0, 1, 0x03, 0x03 },
+    { 0x5D, 0x05, 0, 1, 0x02, 0x02 }, { 0x5D, 0x05, 0, 1, 0x03, 0x03 }, { 0x5D, 0x05, 0, 1, 0x02, 0x02 },
+    { 0x5D, 0x06, 0, 1, 0x03, 0x03 }, { 0x5D, 0x06, 0, 1, 0x02, 0x02 }, { 0x5D, 0x06, 0, 1, 0x03, 0x03 },
+    { 0x5D, 0x06, 0, 1, 0x02, 0x02 }, { 0x5D, 0x07, 0, 1, 0x03, 0x03 }, { 0x5D, 0x07, 0, 1, 0x02, 0x02 },
+    { 0x5D, 0x07, 0, 1, 0x03, 0x03 }, { 0x5D, 0x07, 0, 1, 0x02, 0x02 }, { 0x5D, 0x08, 0, 1, 0x03, 0x03 },
+    { 0x5D, 0x08, 0, 1, 0x02, 0x02 }, { 0x5D, 0x08, 0, 1, 0x03, 0x03 }, { 0x5D, 0x08, 0, 1, 0x02, 0x02 },
+    { 0x43, 0x02, 0, 1, 0x0A, 0x0A }, { 0x43, 0x02, 0, 1, 0x0A, 0x0A }, { 0x43, 0x02, 0, 1, 0x0A, 0x0A },
+    { 0x43, 0x02, 0, 1, 0x0A, 0x0A }, { 0x44, 0x01, 0, 1, 0x02, 0x02 }, { 0x44, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x44, 0x01, 0, 1, 0x02, 0x02 }, { 0x44, 0x01, 0, 1, 0x02, 0x02 }, { 0x5D, 0x09, 0, 1, 0x03, 0x03 },
+    { 0x5D, 0x09, 0, 1, 0x02, 0x02 }, { 0x5D, 0x09, 0, 1, 0x03, 0x03 }, { 0x5D, 0x09, 0, 1, 0x02, 0x02 },
+    { 0x5D, 0x0A, 0, 1, 0x03, 0x03 }, { 0x5D, 0x0A, 0, 1, 0x02, 0x02 }, { 0x5D, 0x0A, 0, 1, 0x03, 0x03 },
+    { 0x5D, 0x0A, 0, 1, 0x02, 0x02 }, { 0x5D, 0x0B, 0, 1, 0x03, 0x03 }, { 0x5D, 0x0B, 0, 1, 0x02, 0x02 },
+    { 0x5D, 0x0B, 0, 1, 0x03, 0x03 }, { 0x5D, 0x0B, 0, 1, 0x02, 0x02 }, { 0x5D, 0x0C, 0, 1, 0x03, 0x03 },
+    { 0x5D, 0x0C, 0, 1, 0x02, 0x02 }, { 0x5D, 0x0C, 0, 1, 0x03, 0x03 }, { 0x5D, 0x0C, 0, 1, 0x02, 0x02 },
+    { 0x63, 0x02, 0, 1, 0x03, 0x03 }, { 0x63, 0x02, 0, 1, 0x02, 0x02 }, { 0x63, 0x02, 0, 1, 0x03, 0x03 },
+    { 0x63, 0x02, 0, 1, 0x02, 0x02 }, { 0x63, 0x03, 0, 1, 0x03, 0x03 }, { 0x63, 0x03, 0, 1, 0x02, 0x02 },
+    { 0x63, 0x03, 0, 1, 0x03, 0x03 }, { 0x63, 0x03, 0, 1, 0x02, 0x02 }, { 0x42, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x42, 0x00, 0, 1, 0x02, 0x02 }, { 0x42, 0x00, 0, 1, 0x02, 0x02 }, { 0x42, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x56, 0x00, 0, 1, 0x02, 0x02 }, { 0x47, 0x00, 0, 1, 0x02, 0x02 }, { 0x42, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x42, 0x00, 0, 1, 0x02, 0x02 }, { 0x42, 0x00, 0, 1, 0x02, 0x02 }, { 0x42, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x42, 0x00, 0, 1, 0x02, 0x02 }, { 0x06, 0x01, 1, 1, 0x02, 0x02 }, { 0x06, 0x01, 1, 1, 0x02, 0x02 },
+    { 0x06, 0x01, 1, 1, 0x02, 0x02 }, { 0x06, 0x01, 1, 1, 0x02, 0x02 }, { 0x36, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x36, 0x00, 0, 1, 0x04, 0x20 }, { 0x36, 0x00, 0, 1, 0x04, 0x20 }, { 0x36, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x2A, 0x00, 0, 1, 0x04, 0x20 }, { 0x2A, 0x00, 0, 1, 0x04, 0x20 }, { 0x2A, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x2A, 0x00, 0, 1, 0x04, 0x20 }, { 0x13, 0x00, 1, 1, 0x02, 0x02 }, { 0x13, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x13, 0x00, 1, 1, 0x02, 0x02 }, { 0x13, 0x00, 1, 1, 0x02, 0x02 }, { 0x15, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x15, 0x00, 1, 1, 0x02, 0x02 }, { 0x15, 0x00, 1, 1, 0x02, 0x02 }, { 0x15, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x57, 0x06, 0, 1, 0x04, 0x02 }, { 0x57, 0x06, 0, 1, 0x04, 0x02 }, { 0x57, 0x06, 0, 1, 0x04, 0x02 },
+    { 0x57, 0x06, 0, 1, 0x04, 0x02 }, { 0x3A, 0x00, 0, 1, 0x02, 0x20 }, { 0x3A, 0x00, 0, 1, 0x02, 0x20 },
+    { 0x3A, 0x00, 0, 1, 0x02, 0x20 }, { 0x3A, 0x00, 0, 1, 0x02, 0x20 }, { 0x51, 0x0E, 1, 1, 0x03, 0x03 },
+    { 0x51, 0x0E, 1, 1, 0x03, 0x03 }, { 0x51, 0x0E, 1, 1, 0x03, 0x03 }, { 0x51, 0x0E, 1, 1, 0x03, 0x03 },
+    { 0x3B, 0x00, 0, 1, 0x02, 0x02 }, { 0x3B, 0x00, 0, 1, 0x02, 0x02 }, { 0x3B, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x3B, 0x00, 0, 1, 0x02, 0x02 }, { 0x3B, 0x00, 0, 1, 0x02, 0x02 }, { 0x3B, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x3B, 0x00, 0, 1, 0x02, 0x02 }, { 0x3F, 0x00, 0, 1, 0x02, 0x26 }, { 0x3F, 0x00, 0, 1, 0x02, 0x26 },
+    { 0x3F, 0x00, 0, 1, 0x02, 0x26 }, { 0x3F, 0x00, 0, 1, 0x02, 0x26 }, { 0x43, 0x03, 0, 1, 0x02, 0x02 },
+    { 0x43, 0x03, 0, 1, 0x02, 0x02 }, { 0x43, 0x03, 0, 1, 0x02, 0x02 }, { 0x43, 0x03, 0, 1, 0x02, 0x02 },
+    { 0x43, 0x04, 0, 1, 0x02, 0x02 }, { 0x43, 0x04, 0, 1, 0x02, 0x02 }, { 0x43, 0x04, 0, 1, 0x02, 0x02 },
+    { 0x43, 0x04, 0, 1, 0x02, 0x02 }, { 0x58, 0x04, 0, 1, 0x2C, 0x2C }, { 0x58, 0x04, 0, 1, 0x2C, 0x2C },
+    { 0x58, 0x04, 0, 1, 0x2C, 0x2C }, { 0x58, 0x04, 0, 1, 0x2C, 0x2C }, { 0x1A, 0x02, 1, 1, 0x02, 0x02 },
+    { 0x1A, 0x02, 1, 1, 0x02, 0x02 }, { 0x1A, 0x02, 1, 1, 0x02, 0x02 }, { 0x1A, 0x02, 1, 1, 0x02, 0x02 },
+    { 0x1A, 0x03, 1, 1, 0x02, 0x02 }, { 0x1A, 0x03, 1, 1, 0x02, 0x02 }, { 0x1A, 0x03, 1, 1, 0x02, 0x02 },
+    { 0x1A, 0x03, 1, 1, 0x02, 0x02 }, { 0x1A, 0x04, 1, 1, 0x02, 0x02 }, { 0x1A, 0x04, 1, 1, 0x02, 0x02 },
+    { 0x1A, 0x04, 1, 1, 0x02, 0x02 }, { 0x1A, 0x04, 1, 1, 0x02, 0x02 }, { 0x55, 0x07, 0, 0, 0x04, 0x04 },
+    { 0x55, 0x07, 0, 0, 0x04, 0x04 }, { 0x55, 0x07, 0, 0, 0x04, 0x04 }, { 0x55, 0x07, 0, 0, 0x04, 0x04 },
+    { 0x55, 0x08, 0, 0, 0x04, 0x04 }, { 0x55, 0x08, 0, 0, 0x04, 0x04 }, { 0x55, 0x08, 0, 0, 0x04, 0x04 },
+    { 0x55, 0x08, 0, 0, 0x04, 0x04 }, { 0x5F, 0x02, 0, 1, 0x02, 0x02 }, { 0x5F, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x64, 0x02, 0, 1, 0x02, 0x02 }, { 0x64, 0x02, 0, 1, 0x02, 0x02 }, { 0x5F, 0x02, 0, 1, 0x00, 0x00 },
+    { 0x52, 0x05, 0, 1, 0x04, 0x02 }, { 0x52, 0x05, 0, 1, 0x04, 0x02 }, { 0x52, 0x05, 0, 1, 0x04, 0x02 },
+    { 0x52, 0x05, 0, 1, 0x04, 0x02 }, { 0x52, 0x06, 0, 1, 0x04, 0x02 }, { 0x52, 0x06, 0, 1, 0x04, 0x02 },
+    { 0x52, 0x06, 0, 1, 0x04, 0x02 }, { 0x52, 0x06, 0, 1, 0x04, 0x02 }, { 0x52, 0x07, 0, 1, 0x04, 0x02 },
+    { 0x52, 0x07, 0, 1, 0x04, 0x02 }, { 0x52, 0x07, 0, 1, 0x04, 0x02 }, { 0x52, 0x07, 0, 1, 0x04, 0x02 },
+    { 0x52, 0x08, 0, 1, 0x04, 0x02 }, { 0x52, 0x08, 0, 1, 0x04, 0x02 }, { 0x52, 0x08, 0, 1, 0x04, 0x02 },
+    { 0x52, 0x08, 0, 1, 0x04, 0x02 }, { 0x53, 0x02, 0, 1, 0x04, 0x02 }, { 0x53, 0x02, 0, 1, 0x04, 0x02 },
+    { 0x53, 0x02, 0, 1, 0x04, 0x02 }, { 0x53, 0x02, 0, 1, 0x04, 0x02 }, { 0x53, 0x03, 0, 1, 0x03, 0x03 },
+    { 0x53, 0x03, 0, 1, 0x03, 0x03 }, { 0x53, 0x03, 0, 1, 0x03, 0x03 }, { 0x53, 0x03, 0, 1, 0x03, 0x03 },
+    { 0x53, 0x04, 0, 1, 0x03, 0x03 }, { 0x53, 0x04, 0, 1, 0x03, 0x03 }, { 0x53, 0x04, 0, 1, 0x03, 0x03 },
+    { 0x53, 0x04, 0, 1, 0x03, 0x03 }, { 0x53, 0x05, 0, 1, 0x03, 0x03 }, { 0x53, 0x05, 0, 1, 0x03, 0x03 },
+    { 0x53, 0x05, 0, 1, 0x03, 0x03 }, { 0x53, 0x05, 0, 1, 0x03, 0x03 }, { 0x5E, 0x01, 1, 1, 0x0E, 0x0E },
+    { 0x5E, 0x01, 1, 1, 0x0E, 0x0E }, { 0x5E, 0x01, 1, 1, 0x0E, 0x0E }, { 0x5E, 0x01, 1, 1, 0x0E, 0x0E },
+    { 0x5E, 0x02, 0, 1, 0x0E, 0x0E }, { 0x5E, 0x02, 0, 1, 0x0E, 0x0E }, { 0x5E, 0x02, 0, 1, 0x0E, 0x0E },
+    { 0x5E, 0x02, 0, 1, 0x0E, 0x0E }, { 0x3C, 0x00, 0, 1, 0x03, 0x03 }, { 0x3C, 0x00, 0, 1, 0x03, 0x03 },
+    { 0x3C, 0x00, 0, 1, 0x03, 0x03 }, { 0x3C, 0x00, 0, 1, 0x03, 0x03 }, { 0x3D, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x3D, 0x00, 0, 1, 0x02, 0x02 }, { 0x3D, 0x00, 0, 1, 0x02, 0x02 }, { 0x3D, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x3D, 0x00, 0, 1, 0x02, 0x02 }, { 0x3D, 0x00, 0, 1, 0x02, 0x02 }, { 0x3D, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x63, 0x04, 0, 1, 0x04, 0x02 }, { 0x63, 0x04, 0, 1, 0x04, 0x02 }, { 0x63, 0x04, 0, 1, 0x04, 0x02 },
+    { 0x63, 0x04, 0, 1, 0x04, 0x02 }, { 0x2E, 0x00, 0, 1, 0x04, 0x20 }, { 0x2E, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x2E, 0x00, 0, 1, 0x04, 0x20 }, { 0x2E, 0x00, 0, 1, 0x04, 0x20 }, { 0x2F, 0x00, 0, 1, 0x04, 0x04 },
+    { 0x2F, 0x00, 0, 1, 0x04, 0x04 }, { 0x2F, 0x00, 0, 1, 0x04, 0x04 }, { 0x2F, 0x00, 0, 1, 0x04, 0x04 },
+    { 0x30, 0x00, 0, 0, 0x04, 0x20 }, { 0x30, 0x00, 0, 0, 0x04, 0x20 }, { 0x30, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x30, 0x00, 0, 1, 0x04, 0x20 }, { 0x31, 0x00, 0, 1, 0x04, 0x20 }, { 0x31, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x31, 0x00, 0, 1, 0x04, 0x20 }, { 0x31, 0x00, 0, 1, 0x04, 0x20 }, { 0x1E, 0x04, 0, 1, 0x04, 0x02 },
+    { 0x1F, 0x04, 0, 1, 0x04, 0x02 }, { 0x1E, 0x04, 0, 1, 0x04, 0x02 }, { 0x1F, 0x04, 0, 1, 0x04, 0x02 },
+    { 0x32, 0x00, 0, 1, 0x02, 0x02 }, { 0x32, 0x00, 0, 1, 0x02, 0x02 }, { 0x32, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x32, 0x00, 0, 1, 0x02, 0x02 }, { 0x59, 0x05, 0, 1, 0x03, 0x03 }, { 0x59, 0x05, 0, 1, 0x03, 0x03 },
+    { 0x59, 0x05, 0, 1, 0x03, 0x03 }, { 0x59, 0x05, 0, 1, 0x03, 0x03 }, { 0x35, 0x00, 0, 1, 0x04, 0x02 },
+    { 0x35, 0x00, 0, 1, 0x04, 0x02 }, { 0x35, 0x00, 0, 1, 0x04, 0x02 }, { 0x35, 0x00, 0, 1, 0x04, 0x02 },
+    { 0x37, 0x00, 0, 1, 0x04, 0x20 }, { 0x37, 0x00, 0, 1, 0x04, 0x20 }, { 0x37, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x37, 0x00, 0, 1, 0x04, 0x20 }, { 0x39, 0x00, 0, 1, 0x04, 0x04 }, { 0x39, 0x00, 0, 1, 0x04, 0x04 },
+    { 0x39, 0x00, 0, 1, 0x04, 0x04 }, { 0x39, 0x00, 0, 1, 0x04, 0x04 }, { 0x5D, 0x0D, 0, 1, 0x03, 0x03 },
+    { 0x5D, 0x0D, 0, 1, 0x02, 0x02 }, { 0x5D, 0x0D, 0, 1, 0x03, 0x03 }, { 0x5D, 0x0D, 0, 1, 0x02, 0x02 },
+    { 0x5D, 0x0E, 0, 1, 0x03, 0x05 }, { 0x5D, 0x0E, 0, 1, 0x02, 0x04 }, { 0x5D, 0x0E, 0, 1, 0x03, 0x05 },
+    { 0x5D, 0x0E, 0, 1, 0x02, 0x04 }, { 0x5D, 0x0F, 1, 1, 0x0F, 0x0F }, { 0x5D, 0x0F, 1, 1, 0x0F, 0x0F },
+    { 0x5D, 0x0F, 1, 1, 0x0F, 0x0F }, { 0x5D, 0x0F, 1, 1, 0x0F, 0x0F }, { 0x5D, 0x10, 0, 1, 0x02, 0x02 },
+    { 0x5D, 0x10, 0, 1, 0x02, 0x02 }, { 0x5D, 0x10, 0, 1, 0x02, 0x02 }, { 0x5D, 0x10, 0, 1, 0x02, 0x02 },
+    { 0x5D, 0x11, 0, 1, 0x02, 0x02 }, { 0x5D, 0x11, 0, 1, 0x02, 0x02 }, { 0x5D, 0x11, 0, 1, 0x02, 0x02 },
+    { 0x5D, 0x11, 0, 1, 0x02, 0x02 }, { 0x20, 0x06, 0, 1, 0x04, 0x02 }, { 0x21, 0x06, 0, 1, 0x04, 0x02 },
+    { 0x22, 0x06, 0, 1, 0x04, 0x02 }, { 0x22, 0x06, 0, 1, 0x04, 0x02 }, { 0x20, 0x07, 0, 1, 0x04, 0x02 },
+    { 0x21, 0x07, 0, 1, 0x04, 0x02 }, { 0x22, 0x07, 0, 1, 0x04, 0x02 }, { 0x22, 0x07, 0, 1, 0x04, 0x02 },
+    { 0x1E, 0x02, 0, 1, 0x04, 0x02 }, { 0x1F, 0x02, 0, 1, 0x04, 0x02 }, { 0x1E, 0x02, 0, 1, 0x03, 0x03 },
+    { 0x1F, 0x02, 0, 1, 0x02, 0x02 }, { 0x58, 0x02, 0, 1, 0x02, 0x02 }, { 0x58, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x58, 0x02, 0, 1, 0x02, 0x02 }, { 0x58, 0x02, 0, 1, 0x02, 0x02 }, { 0x57, 0x03, 0, 1, 0x03, 0x03 },
+    { 0x57, 0x03, 0, 1, 0x03, 0x03 }, { 0x57, 0x03, 0, 1, 0x03, 0x03 }, { 0x57, 0x03, 0, 1, 0x03, 0x03 },
+    { 0x57, 0x04, 0, 1, 0x04, 0x02 }, { 0x57, 0x04, 0, 1, 0x04, 0x02 }, { 0x57, 0x04, 0, 1, 0x04, 0x02 },
+    { 0x57, 0x04, 0, 1, 0x04, 0x02 }, { 0x5A, 0x04, 0, 1, 0x04, 0x02 }, { 0x5A, 0x04, 0, 1, 0x04, 0x02 },
+    { 0x5A, 0x04, 0, 1, 0x04, 0x02 }, { 0x5A, 0x04, 0, 1, 0x04, 0x02 }, { 0x59, 0x03, 0, 1, 0x03, 0x03 },
+    { 0x59, 0x03, 0, 1, 0x02, 0x02 }, { 0x59, 0x03, 0, 1, 0x03, 0x03 }, { 0x59, 0x03, 0, 1, 0x02, 0x02 },
+    { 0x59, 0x04, 0, 1, 0x02, 0x02 }, { 0x59, 0x04, 0, 1, 0x02, 0x02 }, { 0x59, 0x04, 0, 1, 0x02, 0x02 },
+    { 0x59, 0x04, 0, 1, 0x02, 0x02 }, { 0x0E, 0x04, 1, 1, 0x02, 0x02 }, { 0x0E, 0x04, 1, 1, 0x02, 0x02 },
+    { 0x0E, 0x04, 1, 1, 0x02, 0x02 }, { 0x0E, 0x04, 1, 1, 0x02, 0x02 }, { 0x0E, 0x05, 1, 1, 0x02, 0x02 },
+    { 0x0E, 0x05, 1, 1, 0x02, 0x02 }, { 0x0E, 0x05, 1, 1, 0x02, 0x02 }, { 0x0E, 0x05, 1, 1, 0x02, 0x02 },
+    { 0x0E, 0x06, 1, 1, 0x02, 0x02 }, { 0x0E, 0x06, 1, 1, 0x02, 0x02 }, { 0x0E, 0x06, 1, 1, 0x02, 0x02 },
+    { 0x0E, 0x06, 1, 1, 0x02, 0x02 }, { 0x30, 0x01, 0, 0, 0x04, 0x20 }, { 0x30, 0x01, 0, 0, 0x04, 0x20 },
+    { 0x30, 0x01, 0, 1, 0x04, 0x20 }, { 0x30, 0x01, 0, 1, 0x04, 0x20 }, { 0x30, 0x02, 0, 0, 0x04, 0x20 },
+    { 0x30, 0x02, 0, 0, 0x04, 0x20 }, { 0x30, 0x02, 0, 1, 0x04, 0x20 }, { 0x30, 0x02, 0, 1, 0x04, 0x20 },
+    { 0x06, 0x02, 0, 0, 0x02, 0x02 }, { 0x06, 0x02, 0, 0, 0x02, 0x02 }, { 0x06, 0x02, 0, 0, 0x02, 0x02 },
+    { 0x06, 0x02, 0, 0, 0x02, 0x02 }, { 0x06, 0x03, 0, 0, 0x02, 0x02 }, { 0x06, 0x03, 0, 0, 0x02, 0x02 },
+    { 0x06, 0x03, 0, 0, 0x02, 0x02 }, { 0x06, 0x03, 0, 0, 0x02, 0x02 }, { 0x06, 0x04, 0, 1, 0x02, 0x02 },
+    { 0x06, 0x04, 0, 1, 0x02, 0x02 }, { 0x06, 0x04, 0, 1, 0x02, 0x02 }, { 0x06, 0x04, 0, 1, 0x02, 0x02 },
+    { 0x62, 0x02, 0, 1, 0x04, 0x02 }, { 0x62, 0x02, 0, 1, 0x04, 0x02 }, { 0x62, 0x02, 0, 1, 0x04, 0x02 },
+    { 0x62, 0x02, 0, 1, 0x04, 0x02 }, { 0x4A, 0x00, 0, 1, 0x03, 0x03 }, { 0x4A, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x4A, 0x00, 0, 1, 0x03, 0x03 }, { 0x4A, 0x00, 0, 1, 0x02, 0x02 }, { 0x4A, 0x00, 0, 1, 0x03, 0x03 },
+    { 0x4A, 0x00, 0, 1, 0x03, 0x03 }, { 0x4A, 0x00, 0, 1, 0x03, 0x03 }, { 0x02, 0x01, 1, 1, 0x02, 0x02 },
+    { 0x02, 0x01, 1, 1, 0x02, 0x02 }, { 0x02, 0x01, 1, 1, 0x02, 0x02 }, { 0x02, 0x01, 1, 1, 0x02, 0x02 },
+    { 0x12, 0x00, 1, 0, 0x02, 0x02 }, { 0x12, 0x00, 1, 0, 0x02, 0x02 }, { 0x12, 0x00, 1, 0, 0x02, 0x02 },
+    { 0x12, 0x00, 1, 0, 0x02, 0x02 }, { 0x11, 0x00, 1, 0, 0x02, 0x02 }, { 0x11, 0x00, 1, 0, 0x02, 0x02 },
+    { 0x11, 0x00, 1, 0, 0x02, 0x02 }, { 0x11, 0x00, 1, 0, 0x02, 0x02 }, { 0x18, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x18, 0x00, 1, 1, 0x02, 0x02 }, { 0x18, 0x00, 1, 1, 0x02, 0x02 }, { 0x18, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x16, 0x00, 1, 1, 0x02, 0x02 }, { 0x16, 0x00, 1, 1, 0x02, 0x02 }, { 0x16, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x16, 0x00, 1, 1, 0x02, 0x02 }, { 0x0A, 0x00, 0, 1, 0x02, 0x02 }, { 0x0A, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x0A, 0x00, 0, 1, 0x02, 0x02 }, { 0x0A, 0x00, 0, 1, 0x02, 0x02 }, { 0x19, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x19, 0x00, 1, 1, 0x02, 0x02 }, { 0x19, 0x00, 1, 1, 0x02, 0x02 }, { 0x19, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x05, 0x01, 1, 1, 0x03, 0x02 }, { 0x05, 0x01, 1, 1, 0x02, 0x02 }, { 0x05, 0x01, 1, 1, 0x03, 0x02 },
+    { 0x05, 0x01, 1, 1, 0x02, 0x02 }, { 0x0A, 0x01, 1, 1, 0x02, 0x02 }, { 0x0A, 0x01, 1, 1, 0x02, 0x02 },
+    { 0x0A, 0x01, 1, 1, 0x02, 0x02 }, { 0x0A, 0x01, 1, 1, 0x02, 0x02 }, { 0x0A, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x0A, 0x02, 0, 1, 0x02, 0x02 }, { 0x0A, 0x02, 0, 1, 0x02, 0x02 }, { 0x0A, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x63, 0x05, 0, 1, 0x04, 0x02 }, { 0x63, 0x05, 0, 1, 0x04, 0x02 }, { 0x63, 0x05, 0, 1, 0x04, 0x02 },
+    { 0x63, 0x05, 0, 1, 0x04, 0x02 }, { 0x28, 0x00, 0, 1, 0x04, 0x04 }, { 0x28, 0x00, 0, 1, 0x04, 0x04 },
+    { 0x28, 0x00, 0, 1, 0x04, 0x04 }, { 0x28, 0x00, 0, 1, 0x04, 0x04 }, { 0x29, 0x00, 0, 1, 0x04, 0x04 },
+    { 0x29, 0x00, 0, 1, 0x04, 0x04 }, { 0x29, 0x00, 0, 1, 0x04, 0x04 }, { 0x29, 0x00, 0, 1, 0x04, 0x04 },
+    { 0x2B, 0x00, 0, 1, 0x04, 0x20 }, { 0x2B, 0x00, 0, 1, 0x04, 0x20 }, { 0x2B, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x2B, 0x00, 0, 1, 0x04, 0x20 }, { 0x1A, 0x00, 1, 1, 0x02, 0x02 }, { 0x1A, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x1A, 0x00, 1, 1, 0x02, 0x02 }, { 0x1A, 0x00, 1, 1, 0x02, 0x02 }, { 0x55, 0x09, 0, 0, 0x04, 0x04 },
+    { 0x55, 0x09, 0, 0, 0x04, 0x04 }, { 0x55, 0x09, 0, 0, 0x04, 0x04 }, { 0x55, 0x09, 0, 0, 0x04, 0x04 },
+    { 0x55, 0x0A, 0, 0, 0x04, 0x04 }, { 0x55, 0x0A, 0, 0, 0x04, 0x04 }, { 0x55, 0x0A, 0, 0, 0x04, 0x04 },
+    { 0x55, 0x0A, 0, 0, 0x04, 0x04 }, { 0x52, 0x09, 0, 1, 0x04, 0x04 }, { 0x52, 0x09, 0, 1, 0x04, 0x04 },
+    { 0x52, 0x09, 0, 1, 0x04, 0x04 }, { 0x52, 0x09, 0, 1, 0x04, 0x04 }, { 0x48, 0x00, 0, 1, 0x02, 0x26 },
+    { 0x48, 0x00, 0, 1, 0x02, 0x26 }, { 0x48, 0x00, 0, 1, 0x02, 0x26 }, { 0x48, 0x00, 0, 1, 0x02, 0x26 },
+    { 0x48, 0x01, 0, 1, 0x04, 0x20 }, { 0x48, 0x01, 0, 1, 0x04, 0x20 }, { 0x48, 0x01, 0, 1, 0x04, 0x20 },
+    { 0x48, 0x01, 0, 1, 0x04, 0x20 }, { 0x55, 0x0B, 0, 1, 0x04, 0x02 }, { 0x55, 0x0B, 0, 1, 0x04, 0x02 },
+    { 0x55, 0x0B, 0, 1, 0x04, 0x02 }, { 0x55, 0x0B, 0, 1, 0x04, 0x02 }, { 0x60, 0x04, 0, 1, 0x02, 0x02 },
+    { 0x60, 0x04, 0, 1, 0x02, 0x02 }, { 0x60, 0x04, 0, 1, 0x02, 0x02 }, { 0x60, 0x04, 0, 1, 0x02, 0x02 },
+    { 0x49, 0x00, 0, 1, 0x02, 0x20 }, { 0x49, 0x00, 0, 1, 0x02, 0x20 }, { 0x49, 0x00, 0, 1, 0x02, 0x20 },
+    { 0x49, 0x00, 0, 1, 0x02, 0x20 }, { 0x52, 0x0A, 0, 1, 0x04, 0x02 }, { 0x52, 0x0A, 0, 1, 0x04, 0x02 },
+    { 0x52, 0x0A, 0, 1, 0x04, 0x02 }, { 0x52, 0x0A, 0, 1, 0x04, 0x02 }, { 0x0D, 0x00, 0, 1, 0x04, 0x02 },
+    { 0x0D, 0x00, 0, 1, 0x04, 0x02 }, { 0x0D, 0x00, 0, 1, 0x04, 0x02 }, { 0x0D, 0x00, 0, 1, 0x04, 0x02 },
+    { 0x0D, 0x00, 0, 1, 0x04, 0x02 }, { 0x0D, 0x00, 0, 1, 0x04, 0x02 }, { 0x0D, 0x00, 0, 1, 0x04, 0x02 },
+    { 0x0D, 0x00, 0, 1, 0x04, 0x02 }, { 0x0D, 0x00, 0, 1, 0x04, 0x02 }, { 0x0D, 0x00, 0, 1, 0x04, 0x02 },
+    { 0x0D, 0x00, 0, 1, 0x04, 0x02 }, { 0x23, 0x01, 0, 1, 0x04, 0x02 }, { 0x24, 0x01, 0, 1, 0x04, 0x02 },
+    { 0x25, 0x01, 0, 1, 0x04, 0x02 }, { 0x25, 0x01, 0, 1, 0x04, 0x02 }, { 0x51, 0x0F, 0, 1, 0x05, 0x05 },
+    { 0x51, 0x0F, 0, 1, 0x04, 0x02 }, { 0x51, 0x0F, 0, 1, 0x05, 0x05 }, { 0x51, 0x0F, 0, 1, 0x04, 0x02 },
+    { 0x60, 0x05, 0, 1, 0x04, 0x02 }, { 0x60, 0x05, 0, 1, 0x04, 0x02 }, { 0x60, 0x05, 0, 1, 0x04, 0x02 },
+    { 0x60, 0x05, 0, 1, 0x04, 0x02 }, { 0x5F, 0x04, 0, 1, 0x03, 0x03 }, { 0x5F, 0x04, 0, 1, 0x02, 0x02 },
+    { 0x64, 0x04, 0, 1, 0x02, 0x02 }, { 0x64, 0x04, 0, 1, 0x02, 0x02 }, { 0x61, 0x03, 0, 1, 0x02, 0x02 },
+    { 0x61, 0x03, 0, 1, 0x02, 0x02 }, { 0x61, 0x03, 0, 1, 0x02, 0x02 }, { 0x61, 0x03, 0, 1, 0x02, 0x02 },
+    { 0x0C, 0x00, 0, 1, 0x02, 0x02 }, { 0x0C, 0x00, 0, 1, 0x02, 0x02 }, { 0x0C, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x0C, 0x00, 0, 1, 0x02, 0x02 }, { 0x0C, 0x01, 0, 1, 0x02, 0x02 }, { 0x0C, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x0C, 0x01, 0, 1, 0x02, 0x02 }, { 0x0C, 0x01, 0, 1, 0x02, 0x02 }, { 0x0C, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x0C, 0x02, 0, 1, 0x02, 0x02 }, { 0x0C, 0x02, 0, 1, 0x02, 0x02 }, { 0x0C, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x0C, 0x03, 0, 1, 0x02, 0x02 }, { 0x0C, 0x03, 0, 1, 0x02, 0x02 }, { 0x0C, 0x03, 0, 1, 0x02, 0x02 },
+    { 0x0C, 0x03, 0, 1, 0x02, 0x02 }, { 0x0C, 0x04, 0, 1, 0x02, 0x02 }, { 0x0C, 0x04, 0, 1, 0x02, 0x02 },
+    { 0x0C, 0x04, 0, 1, 0x02, 0x02 }, { 0x0C, 0x04, 0, 1, 0x02, 0x02 }, { 0x0C, 0x05, 0, 1, 0x02, 0x02 },
+    { 0x0C, 0x05, 0, 1, 0x02, 0x02 }, { 0x0C, 0x05, 0, 1, 0x02, 0x02 }, { 0x0C, 0x05, 0, 1, 0x02, 0x02 },
+    { 0x0C, 0x06, 0, 1, 0x02, 0x02 }, { 0x0C, 0x06, 0, 1, 0x02, 0x02 }, { 0x0C, 0x06, 0, 1, 0x02, 0x02 },
+    { 0x0C, 0x06, 0, 1, 0x02, 0x02 }, { 0x0C, 0x07, 0, 1, 0x02, 0x02 }, { 0x0C, 0x07, 0, 1, 0x02, 0x02 },
+    { 0x0C, 0x07, 0, 1, 0x02, 0x02 }, { 0x0C, 0x07, 0, 1, 0x02, 0x02 }, { 0x0C, 0x08, 0, 1, 0x02, 0x02 },
+    { 0x0C, 0x08, 0, 1, 0x02, 0x02 }, { 0x0C, 0x08, 0, 1, 0x02, 0x02 }, { 0x0C, 0x08, 0, 1, 0x02, 0x02 },
+    { 0x0C, 0x09, 0, 1, 0x02, 0x02 }, { 0x0C, 0x09, 0, 1, 0x02, 0x02 }, { 0x0C, 0x09, 0, 1, 0x02, 0x02 },
+    { 0x0C, 0x09, 0, 1, 0x02, 0x02 }, { 0x0C, 0x0A, 0, 1, 0x02, 0x02 }, { 0x0C, 0x0A, 0, 1, 0x02, 0x02 },
+    { 0x0C, 0x0A, 0, 1, 0x02, 0x02 }, { 0x0C, 0x0A, 0, 1, 0x02, 0x02 }, { 0x0C, 0x0B, 0, 1, 0x02, 0x02 },
+    { 0x0C, 0x0B, 0, 1, 0x02, 0x02 }, { 0x0C, 0x0B, 0, 1, 0x02, 0x02 }, { 0x0C, 0x0B, 0, 1, 0x02, 0x02 },
+    { 0x0E, 0x07, 1, 1, 0x02, 0x02 }, { 0x0E, 0x07, 1, 1, 0x02, 0x02 }, { 0x0E, 0x07, 1, 1, 0x02, 0x02 },
+    { 0x0E, 0x07, 1, 1, 0x02, 0x02 }, { 0x1A, 0x01, 1, 1, 0x02, 0x02 }, { 0x1A, 0x01, 1, 1, 0x02, 0x02 },
+    { 0x1A, 0x01, 1, 1, 0x02, 0x02 }, { 0x1A, 0x01, 1, 1, 0x02, 0x02 }, { 0x3B, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x3B, 0x01, 0, 1, 0x02, 0x02 }, { 0x3B, 0x01, 0, 1, 0x02, 0x02 }, { 0x3B, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x3B, 0x02, 0, 1, 0x02, 0x02 }, { 0x3B, 0x02, 0, 1, 0x02, 0x02 }, { 0x3B, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x3B, 0x02, 0, 1, 0x02, 0x02 }, { 0x5B, 0x04, 0, 1, 0x02, 0x02 }, { 0x5B, 0x04, 0, 1, 0x02, 0x02 },
+    { 0x5B, 0x04, 0, 1, 0x02, 0x02 }, { 0x5B, 0x04, 0, 1, 0x02, 0x02 }, { 0x63, 0x06, 0, 0, 0x02, 0x26 },
+    { 0x63, 0x06, 0, 0, 0x02, 0x26 }, { 0x63, 0x06, 0, 0, 0x02, 0x26 }, { 0x63, 0x06, 0, 0, 0x02, 0x26 },
+    { 0x63, 0x07, 0, 0, 0x2E, 0x2E }, { 0x63, 0x07, 0, 0, 0x2E, 0x2E }, { 0x63, 0x07, 0, 0, 0x2E, 0x2E },
+    { 0x63, 0x07, 0, 0, 0x2E, 0x2E }, { 0x5B, 0x05, 0, 1, 0x02, 0x02 }, { 0x5B, 0x05, 0, 1, 0x02, 0x02 },
+    { 0x5B, 0x05, 0, 1, 0x02, 0x02 }, { 0x5B, 0x05, 0, 1, 0x02, 0x02 }, { 0x5B, 0x06, 0, 1, 0x2C, 0x2C },
+    { 0x5B, 0x06, 0, 1, 0x2C, 0x2C }, { 0x5B, 0x06, 0, 1, 0x2C, 0x2C }, { 0x5B, 0x06, 0, 1, 0x2C, 0x2C },
+    { 0x5B, 0x07, 0, 1, 0x2C, 0x2C }, { 0x5B, 0x07, 0, 1, 0x2C, 0x2C }, { 0x5B, 0x07, 0, 1, 0x2C, 0x2C },
+    { 0x5B, 0x07, 0, 1, 0x2C, 0x2C }, { 0x5B, 0x08, 0, 0, 0x02, 0x02 }, { 0x5B, 0x08, 0, 0, 0x02, 0x02 },
+    { 0x5B, 0x08, 0, 0, 0x02, 0x02 }, { 0x5B, 0x08, 0, 0, 0x02, 0x02 }, { 0x62, 0x03, 0, 1, 0x2C, 0x2C },
+    { 0x62, 0x03, 0, 1, 0x2C, 0x2C }, { 0x62, 0x03, 0, 1, 0x2C, 0x2C }, { 0x62, 0x03, 0, 1, 0x2C, 0x2C },
+    { 0x57, 0x05, 0, 1, 0x02, 0x02 }, { 0x57, 0x05, 0, 1, 0x02, 0x02 }, { 0x57, 0x05, 0, 1, 0x02, 0x02 },
+    { 0x57, 0x05, 0, 1, 0x02, 0x02 }, { 0x07, 0x03, 0, 1, 0x02, 0x02 }, { 0x07, 0x03, 0, 1, 0x02, 0x02 },
+    { 0x07, 0x03, 0, 1, 0x02, 0x02 }, { 0x07, 0x03, 0, 1, 0x02, 0x02 }, { 0x52, 0x0B, 0, 1, 0x04, 0x02 },
+    { 0x52, 0x0B, 0, 1, 0x04, 0x02 }, { 0x52, 0x0B, 0, 1, 0x04, 0x02 }, { 0x52, 0x0B, 0, 1, 0x04, 0x02 },
+    { 0x3B, 0x03, 0, 1, 0x02, 0x02 }, { 0x3B, 0x03, 0, 1, 0x02, 0x02 }, { 0x3B, 0x03, 0, 1, 0x02, 0x02 },
+    { 0x3B, 0x03, 0, 1, 0x02, 0x02 }, { 0x61, 0x04, 0, 1, 0x02, 0x02 }, { 0x61, 0x04, 0, 1, 0x02, 0x02 },
+    { 0x61, 0x04, 0, 1, 0x02, 0x02 }, { 0x61, 0x04, 0, 1, 0x02, 0x02 }, { 0x5F, 0x03, 0, 1, 0x03, 0x03 },
+    { 0x5F, 0x03, 0, 1, 0x02, 0x02 }, { 0x64, 0x03, 0, 1, 0x02, 0x02 }, { 0x64, 0x03, 0, 1, 0x02, 0x02 },
+    { 0x5F, 0x03, 0, 1, 0x00, 0x00 }, { 0x52, 0x0C, 0, 1, 0x04, 0x02 }, { 0x52, 0x0C, 0, 1, 0x04, 0x02 },
+    { 0x52, 0x0C, 0, 1, 0x04, 0x02 }, { 0x52, 0x0C, 0, 1, 0x04, 0x02 }, { 0x48, 0x02, 1, 1, 0x04, 0x20 },
+    { 0x48, 0x02, 1, 1, 0x04, 0x20 }, { 0x48, 0x02, 1, 1, 0x04, 0x20 }, { 0x48, 0x02, 1, 1, 0x04, 0x20 },
+    { 0x4B, 0x00, 0, 1, 0x04, 0x20 }, { 0x4B, 0x00, 0, 1, 0x04, 0x20 }, { 0x4B, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x4B, 0x00, 0, 1, 0x04, 0x20 }, { 0x53, 0x06, 0, 1, 0x03, 0x03 }, { 0x53, 0x06, 0, 1, 0x03, 0x03 },
+    { 0x53, 0x06, 0, 1, 0x03, 0x03 }, { 0x53, 0x06, 0, 1, 0x03, 0x03 }, { 0x51, 0x10, 0, 1, 0x0B, 0x0B },
+    { 0x51, 0x10, 0, 1, 0x0B, 0x0B }, { 0x51, 0x10, 0, 1, 0x0B, 0x0B }, { 0x51, 0x10, 0, 1, 0x0B, 0x0B },
+    { 0x52, 0x0D, 0, 1, 0x03, 0x03 }, { 0x52, 0x0D, 0, 1, 0x02, 0x02 }, { 0x52, 0x0D, 0, 1, 0x03, 0x03 },
+    { 0x52, 0x0D, 0, 1, 0x02, 0x02 }, { 0x4F, 0x00, 0, 1, 0x03, 0x03 }, { 0x4F, 0x00, 0, 1, 0x03, 0x03 },
+    { 0x4F, 0x00, 0, 1, 0x03, 0x03 }, { 0x4F, 0x00, 0, 1, 0x03, 0x03 }, { 0x4F, 0x00, 0, 1, 0x03, 0x03 },
+    { 0x1A, 0x06, 1, 1, 0x02, 0x02 }, { 0x1A, 0x06, 1, 1, 0x02, 0x02 }, { 0x1A, 0x06, 1, 1, 0x02, 0x02 },
+    { 0x1A, 0x06, 1, 1, 0x02, 0x02 }, { 0x66, 0x00, 0, 1, 0x02, 0x02 }, { 0x66, 0x00, 0, 1, 0x02, 0x02 },
+    { 0x66, 0x00, 0, 1, 0x02, 0x02 }, { 0x66, 0x00, 0, 1, 0x02, 0x02 }, { 0x1A, 0x07, 1, 1, 0x02, 0x02 },
+    { 0x1A, 0x07, 1, 1, 0x02, 0x02 }, { 0x1A, 0x07, 1, 1, 0x02, 0x02 }, { 0x1A, 0x07, 1, 1, 0x02, 0x02 },
+    { 0x32, 0x01, 0, 1, 0x02, 0x02 }, { 0x32, 0x01, 0, 1, 0x02, 0x02 }, { 0x32, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x32, 0x01, 0, 1, 0x02, 0x02 }, { 0x2C, 0x01, 0, 1, 0x04, 0x20 }, { 0x2C, 0x01, 0, 1, 0x04, 0x20 },
+    { 0x2C, 0x01, 0, 1, 0x04, 0x20 }, { 0x2C, 0x01, 0, 1, 0x04, 0x20 }, { 0x33, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x33, 0x00, 0, 1, 0x04, 0x20 }, { 0x33, 0x00, 0, 1, 0x04, 0x20 }, { 0x33, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x0D, 0x01, 0, 0, 0x04, 0x02 }, { 0x0D, 0x01, 0, 0, 0x04, 0x02 }, { 0x0D, 0x01, 0, 0, 0x04, 0x02 },
+    { 0x0D, 0x01, 0, 0, 0x04, 0x02 }, { 0x0D, 0x02, 0, 1, 0x04, 0x02 }, { 0x0D, 0x02, 0, 1, 0x04, 0x02 },
+    { 0x0D, 0x02, 0, 1, 0x04, 0x02 }, { 0x0D, 0x02, 0, 1, 0x04, 0x02 }, { 0x0D, 0x03, 0, 1, 0x04, 0x02 },
+    { 0x0D, 0x03, 0, 1, 0x04, 0x02 }, { 0x0D, 0x03, 0, 1, 0x04, 0x02 }, { 0x0D, 0x03, 0, 1, 0x04, 0x02 },
+    { 0x0D, 0x04, 0, 1, 0x04, 0x02 }, { 0x0D, 0x04, 0, 1, 0x04, 0x02 }, { 0x0D, 0x04, 0, 1, 0x04, 0x02 },
+    { 0x0D, 0x04, 0, 1, 0x04, 0x02 }, { 0x0D, 0x05, 0, 1, 0x04, 0x02 }, { 0x0D, 0x05, 0, 1, 0x04, 0x02 },
+    { 0x0D, 0x05, 0, 1, 0x04, 0x02 }, { 0x0D, 0x05, 0, 1, 0x04, 0x02 }, { 0x0D, 0x06, 0, 1, 0x04, 0x02 },
+    { 0x0D, 0x06, 0, 1, 0x04, 0x02 }, { 0x0D, 0x06, 0, 1, 0x04, 0x02 }, { 0x0D, 0x06, 0, 1, 0x04, 0x02 },
+    { 0x0D, 0x07, 0, 1, 0x04, 0x02 }, { 0x0D, 0x07, 0, 1, 0x04, 0x02 }, { 0x0D, 0x07, 0, 1, 0x04, 0x02 },
+    { 0x0D, 0x07, 0, 1, 0x04, 0x02 }, { 0x50, 0x00, 0, 1, 0x04, 0x20 }, { 0x50, 0x00, 0, 1, 0x04, 0x20 },
+    { 0x50, 0x00, 0, 1, 0x04, 0x20 }, { 0x50, 0x00, 0, 1, 0x04, 0x20 }, { 0x52, 0x0E, 0, 1, 0x03, 0x03 },
+    { 0x52, 0x0E, 0, 1, 0x02, 0x02 }, { 0x52, 0x0E, 0, 1, 0x03, 0x03 }, { 0x52, 0x0E, 0, 1, 0x02, 0x02 },
+    { 0x63, 0x08, 0, 0, 0x20, 0x20 }, { 0x63, 0x08, 0, 0, 0x20, 0x20 }, { 0x63, 0x08, 0, 0, 0x20, 0x20 },
+    { 0x63, 0x08, 0, 0, 0x20, 0x20 }, { 0x63, 0x09, 0, 0, 0x02, 0x02 }, { 0x63, 0x09, 0, 0, 0x02, 0x02 },
+    { 0x63, 0x09, 0, 0, 0x02, 0x02 }, { 0x63, 0x09, 0, 0, 0x02, 0x02 }, { 0x57, 0x07, 0, 1, 0x2C, 0x2C },
+    { 0x57, 0x07, 0, 1, 0x2C, 0x2C }, { 0x57, 0x07, 0, 1, 0x2C, 0x2C }, { 0x57, 0x07, 0, 1, 0x2C, 0x2C },
+    { 0x61, 0x05, 0, 1, 0x02, 0x02 }, { 0x61, 0x05, 0, 1, 0x02, 0x02 }, { 0x61, 0x05, 0, 1, 0x02, 0x02 },
+    { 0x61, 0x05, 0, 1, 0x02, 0x02 }, { 0x53, 0x07, 0, 1, 0x03, 0x03 }, { 0x53, 0x07, 0, 1, 0x03, 0x03 },
+    { 0x53, 0x07, 0, 1, 0x03, 0x03 }, { 0x53, 0x07, 0, 1, 0x03, 0x03 }, { 0x0F, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x0F, 0x00, 1, 1, 0x02, 0x02 }, { 0x0F, 0x00, 1, 1, 0x02, 0x02 }, { 0x0F, 0x00, 1, 1, 0x02, 0x02 },
+    { 0x0C, 0x0C, 0, 1, 0x02, 0x02 }, { 0x0C, 0x0C, 0, 1, 0x02, 0x02 }, { 0x0C, 0x0C, 0, 1, 0x02, 0x02 },
+    { 0x0C, 0x0C, 0, 1, 0x02, 0x02 }, { 0x41, 0x01, 0, 1, 0x02, 0x02 }, { 0x41, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x41, 0x01, 0, 1, 0x02, 0x02 }, { 0x41, 0x01, 0, 1, 0x02, 0x02 }, { 0x3D, 0x01, 0, 1, 0x04, 0x04 },
+    { 0x3D, 0x01, 0, 1, 0x04, 0x04 }, { 0x3D, 0x01, 0, 1, 0x04, 0x04 }, { 0x3D, 0x01, 0, 1, 0x04, 0x04 },
+    { 0x5C, 0x07, 0, 1, 0x03, 0x03 }, { 0x5C, 0x07, 0, 1, 0x02, 0x02 }, { 0x5C, 0x07, 0, 1, 0x03, 0x03 },
+    { 0x5C, 0x07, 0, 1, 0x02, 0x02 }, { 0x53, 0x08, 0, 1, 0x03, 0x03 }, { 0x53, 0x08, 0, 1, 0x03, 0x03 },
+    { 0x53, 0x08, 0, 1, 0x03, 0x03 }, { 0x53, 0x08, 0, 1, 0x03, 0x03 }, { 0x03, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x03, 0x02, 0, 1, 0x02, 0x02 }, { 0x03, 0x02, 0, 1, 0x02, 0x02 }, { 0x03, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x3D, 0x02, 0, 1, 0x02, 0x02 }, { 0x3D, 0x02, 0, 1, 0x02, 0x02 }, { 0x3D, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x3D, 0x02, 0, 1, 0x02, 0x02 }, { 0x43, 0x05, 0, 1, 0x02, 0x02 }, { 0x43, 0x05, 0, 1, 0x02, 0x02 },
+    { 0x43, 0x05, 0, 1, 0x02, 0x02 }, { 0x43, 0x05, 0, 1, 0x02, 0x02 }, { 0x43, 0x06, 0, 1, 0x02, 0x02 },
+    { 0x43, 0x06, 0, 1, 0x02, 0x02 }, { 0x43, 0x06, 0, 1, 0x02, 0x02 }, { 0x43, 0x06, 0, 1, 0x02, 0x02 },
+    { 0x51, 0x11, 0, 1, 0x03, 0x03 }, { 0x51, 0x11, 0, 1, 0x02, 0x02 }, { 0x51, 0x11, 0, 1, 0x03, 0x03 },
+    { 0x51, 0x11, 0, 1, 0x02, 0x02 }, { 0x3E, 0x01, 0, 1, 0x02, 0x02 }, { 0x3E, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x3E, 0x01, 0, 1, 0x02, 0x02 }, { 0x3E, 0x01, 0, 1, 0x02, 0x02 }, { 0x3E, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x3E, 0x02, 0, 1, 0x02, 0x02 }, { 0x3E, 0x02, 0, 1, 0x02, 0x02 }, { 0x3E, 0x02, 0, 1, 0x02, 0x02 },
+    { 0x3E, 0x03, 0, 1, 0x02, 0x02 }, { 0x3E, 0x03, 0, 1, 0x02, 0x02 }, { 0x3E, 0x03, 0, 1, 0x02, 0x02 },
+    { 0x3E, 0x03, 0, 1, 0x02, 0x02 }, { 0x3E, 0x04, 0, 1, 0x02, 0x02 }, { 0x3E, 0x04, 0, 1, 0x02, 0x02 },
+    { 0x3E, 0x04, 0, 1, 0x02, 0x02 }, { 0x3E, 0x04, 0, 1, 0x02, 0x02 }, { 0x3E, 0x05, 0, 1, 0x02, 0x03 },
+    { 0x3E, 0x05, 0, 1, 0x02, 0x03 }, { 0x3E, 0x05, 0, 1, 0x02, 0x03 }, { 0x3E, 0x05, 0, 1, 0x02, 0x03 },
+    { 0x3E, 0x06, 0, 1, 0x02, 0x02 }, { 0x3E, 0x06, 0, 1, 0x02, 0x02 }, { 0x3E, 0x06, 0, 1, 0x02, 0x02 },
+    { 0x3E, 0x06, 0, 1, 0x02, 0x02 }, { 0x3E, 0x07, 0, 1, 0x02, 0x02 }, { 0x3E, 0x07, 0, 1, 0x02, 0x02 },
+    { 0x3E, 0x07, 0, 1, 0x02, 0x02 }, { 0x3E, 0x07, 0, 1, 0x02, 0x02 }, { 0x3E, 0x08, 0, 1, 0x02, 0x02 },
+    { 0x3E, 0x08, 0, 1, 0x02, 0x02 }, { 0x3E, 0x08, 0, 1, 0x02, 0x02 }, { 0x3E, 0x08, 0, 1, 0x02, 0x02 },
+    { 0x3E, 0x09, 0, 1, 0x02, 0x02 }, { 0x3E, 0x09, 0, 1, 0x02, 0x02 }, { 0x3E, 0x09, 0, 1, 0x02, 0x02 },
+    { 0x3E, 0x09, 0, 1, 0x02, 0x02 }, { 0x3E, 0x0A, 0, 1, 0x02, 0x02 }, { 0x3E, 0x0A, 0, 1, 0x02, 0x02 },
+    { 0x3E, 0x0A, 0, 1, 0x02, 0x02 }, { 0x3E, 0x0A, 0, 1, 0x02, 0x02 }, { 0x3E, 0x0B, 0, 1, 0x02, 0x02 },
+    { 0x3E, 0x0B, 0, 1, 0x02, 0x02 }, { 0x3E, 0x0B, 0, 1, 0x02, 0x02 }, { 0x3E, 0x0B, 0, 1, 0x02, 0x02 },
+    { 0x3E, 0x0C, 0, 1, 0x02, 0x02 }, { 0x3E, 0x0C, 0, 1, 0x02, 0x02 }, { 0x3E, 0x0C, 0, 1, 0x02, 0x02 },
+    { 0x3E, 0x0C, 0, 1, 0x02, 0x02 }, { 0x37, 0x01, 0, 1, 0x04, 0x20 }, { 0x37, 0x01, 0, 1, 0x04, 0x20 },
+    { 0x37, 0x01, 0, 1, 0x04, 0x20 }, { 0x37, 0x01, 0, 1, 0x04, 0x20 }, { 0x08, 0x01, 0, 1, 0x04, 0x04 },
+    { 0x08, 0x01, 0, 1, 0x04, 0x04 }, { 0x08, 0x01, 0, 1, 0x04, 0x04 }, { 0x08, 0x01, 0, 1, 0x04, 0x04 },
+    { 0x4C, 0x01, 0, 1, 0x04, 0x20 }, { 0x4C, 0x01, 0, 1, 0x04, 0x20 }, { 0x4C, 0x01, 0, 1, 0x04, 0x20 },
+    { 0x4C, 0x01, 0, 1, 0x04, 0x20 }, { 0x63, 0x0A, 0, 1, 0x04, 0x02 }, { 0x63, 0x0A, 0, 1, 0x04, 0x02 },
+    { 0x63, 0x0A, 0, 1, 0x04, 0x02 }, { 0x63, 0x0A, 0, 1, 0x04, 0x02 }, { 0x09, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x09, 0x01, 0, 1, 0x02, 0x02 }, { 0x09, 0x01, 0, 1, 0x02, 0x02 }, { 0x09, 0x01, 0, 1, 0x02, 0x02 },
+    { 0x52, 0x0F, 0, 1, 0x03, 0x03 }, { 0x52, 0x0F, 0, 1, 0x02, 0x02 }, { 0x52, 0x0F, 0, 1, 0x03, 0x03 },
+    { 0x52, 0x0F, 0, 1, 0x02, 0x02 }, { 0x5B, 0x09, 0, 0, 0x02, 0x02 }, { 0x5B, 0x09, 0, 0, 0x02, 0x02 },
+    { 0x5B, 0x09, 0, 0, 0x02, 0x02 }, { 0x5B, 0x09, 0, 0, 0x02, 0x02 }, { 0x4C, 0x02, 0, 1, 0x04, 0x20 },
+    { 0x4C, 0x02, 0, 1, 0x04, 0x20 }, { 0x4C, 0x02, 0, 1, 0x04, 0x20 }, { 0x4C, 0x02, 0, 1, 0x04, 0x20 },
+    { 0x55, 0x0C, 0, 1, 0x04, 0x02 }, { 0x55, 0x0C, 0, 1, 0x04, 0x02 }, { 0x55, 0x0C, 0, 1, 0x04, 0x02 },
+    { 0x55, 0x0C, 0, 1, 0x04, 0x02 }, { 0x17, 0x02, 1, 1, 0x02, 0x02 }, { 0x17, 0x02, 1, 1, 0x02, 0x02 },
+    { 0x17, 0x02, 1, 1, 0x02, 0x02 }, { 0x17, 0x02, 1, 1, 0x02, 0x02 }, { 0x4A, 0x01, 0, 0, 0x03, 0x03 },
+    { 0x4A, 0x01, 0, 0, 0x02, 0x02 }, { 0x4A, 0x01, 0, 0, 0x03, 0x03 }, { 0x4A, 0x01, 0, 0, 0x02, 0x02 },
+    { 0x43, 0x07, 0, 1, 0x02, 0x02 }, { 0x43, 0x07, 0, 1, 0x02, 0x02 }, { 0x43, 0x07, 0, 1, 0x02, 0x02 },
+    { 0x43, 0x07, 0, 1, 0x02, 0x02 }, { 0x5D, 0x12, 0, 1, 0x02, 0x02 }, { 0x5D, 0x12, 0, 1, 0x02, 0x02 },
+    { 0x5D, 0x12, 0, 1, 0x02, 0x02 }, { 0x5D, 0x12, 0, 1, 0x02, 0x02 }, { 0x3E, 0x0D, 0, 1, 0x02, 0x02 },
+    { 0x3E, 0x0D, 0, 1, 0x02, 0x02 }, { 0x3E, 0x0D, 0, 1, 0x02, 0x02 }, { 0x3E, 0x0D, 0, 1, 0x02, 0x02 },
+    { 0x56, 0x02, 0, 1, 0x12, 0x12 }, { 0x56, 0x02, 0, 1, 0x02, 0x02 }, { 0x56, 0x02, 0, 1, 0x12, 0x12 },
+    { 0x56, 0x02, 0, 1, 0x02, 0x02 }, { 0x57, 0x08, 0, 1, 0x02, 0x02 }, { 0x57, 0x08, 0, 1, 0x02, 0x02 },
+    { 0x57, 0x08, 0, 1, 0x02, 0x02 }, { 0x57, 0x08, 0, 1, 0x02, 0x02 }, { 0x56, 0x03, 0, 1, 0x03, 0x03 },
+    { 0x56, 0x03, 0, 1, 0x03, 0x03 }, { 0x56, 0x03, 0, 1, 0x03, 0x03 }, { 0x56, 0x03, 0, 1, 0x03, 0x03 },
+    { 0x57, 0x09, 0, 1, 0x03, 0x03 }, { 0x57, 0x09, 0, 1, 0x03, 0x03 }, { 0x57, 0x09, 0, 1, 0x03, 0x03 },
+    { 0x57, 0x09, 0, 1, 0x03, 0x03 }, { 0x5C, 0x08, 0, 1, 0x03, 0x03 }, { 0x5C, 0x08, 0, 1, 0x03, 0x03 },
+    { 0x5C, 0x08, 0, 1, 0x03, 0x03 }, { 0x5C, 0x08, 0, 1, 0x03, 0x03 },
 };
 
-#define TITLED_SCENE(name, title, unk_10, config, unk_12) \
-{                                                                 \
-    (u32)_##name##SegmentRomStart, (u32)_##name##SegmentRomEnd,   \
-    (u32)_##title##SegmentRomStart, (u32)_##title##SegmentRomEnd, \
-    unk_10, config, unk_12                                        \
-}
+#define TITLED_SCENE(name, title, unk_10, config, unk_12)                                            \
+    {                                                                                                \
+        (u32) _##name##SegmentRomStart, (u32)_##name##SegmentRomEnd, (u32)_##title##SegmentRomStart, \
+            (u32)_##title##SegmentRomEnd, unk_10, config, unk_12                                     \
+    }
 
 #define UNTITLED_SCENE(name, unk_10, config, unk_12) \
-{                                                               \
-    (u32)_##name##SegmentRomStart, (u32)_##name##SegmentRomEnd, \
-    0, 0,                                                       \
-    unk_10, config, unk_12                                      \
-}
+    { (u32) _##name##SegmentRomStart, (u32)_##name##SegmentRomEnd, 0, 0, unk_10, config, unk_12 }
 
-Scene gSceneTable[] =
-{
+Scene gSceneTable[] = {
     TITLED_SCENE(ydan_scene, g_pn_06, 1, 19, 2),
     TITLED_SCENE(ddan_scene, g_pn_08, 1, 20, 3),
     TITLED_SCENE(bdan_scene, g_pn_07, 1, 21, 4),
@@ -1689,14 +645,13 @@ Scene gSceneTable[] =
     UNTITLED_SCENE(testroom_scene, 0, 0, 0),
 };
 
-Gfx sDefaultDisplayList[] =
-{
-    gsSPSegment(0x08, D_80127098),
-    gsSPSegment(0x09, D_80127098),
-    gsSPSegment(0x0A, D_80127098),
-    gsSPSegment(0x0B, D_80127098),
-    gsSPSegment(0x0C, D_80127098),
-    gsSPSegment(0x0D, D_80127098),
+Gfx sDefaultDisplayList[] = {
+    gsSPSegment(0x08, gEmptyDL),
+    gsSPSegment(0x09, gEmptyDL),
+    gsSPSegment(0x0A, gEmptyDL),
+    gsSPSegment(0x0B, gEmptyDL),
+    gsSPSegment(0x0C, gEmptyDL),
+    gsSPSegment(0x0D, gEmptyDL),
     gsDPPipeSync(),
     gsDPSetPrimColor(0, 0, 0x80, 0x80, 0x80, 0x80),
     gsDPSetEnvColor(0x80, 0x80, 0x80, 0x80),
@@ -1704,60 +659,55 @@ Gfx sDefaultDisplayList[] =
 };
 
 // Computes next entrance index based on age and day time to set the fade out transition
-void func_800994A0(GlobalContext* globalCtx)
-{
+void func_800994A0(GlobalContext* globalCtx) {
     s16 computedEntranceIndex;
 
-    if (gSaveContext.night_flag)
-    {
-        if (LINK_IS_CHILD)
+    if (gSaveContext.night_flag) {
+        if (LINK_IS_CHILD) {
             computedEntranceIndex = globalCtx->nextEntranceIndex + 1;
-        else
+        } else {
             computedEntranceIndex = globalCtx->nextEntranceIndex + 3;
-    }
-    else
-    {
-        if (LINK_IS_CHILD)
+        }
+    } else {
+        if (LINK_IS_CHILD) {
             computedEntranceIndex = globalCtx->nextEntranceIndex;
-        else
+        } else {
             computedEntranceIndex = globalCtx->nextEntranceIndex + 2;
+        }
     }
 
     globalCtx->fadeOutTransition = gEntranceTable[computedEntranceIndex].fadeOutTransition;
 }
 
 // Scene Draw Config 0
-void func_80099550(GlobalContext* globalCtx)
-{
+void func_80099550(GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4725);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 4725);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, sDefaultDisplayList);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDefaultDisplayList);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4735);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 4735);
 }
 
 u32 D_8012A2F8[] = { 0x0200BA18, 0x0200CA18 };
 
 // Scene Draw Config 19
-void func_800995DC(GlobalContext* globalCtx)
-{
+void func_800995DC(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gameplayFrames = globalCtx->gameplayFrames;
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4763);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 4763);
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - (gameplayFrames % 128), (gameplayFrames * 1) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - (gameplayFrames % 128), (gameplayFrames * 1) % 128,
+                                32, 32, 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
 
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
@@ -1766,59 +716,54 @@ void func_800995DC(GlobalContext* globalCtx)
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A2F8[gSaveContext.night_flag]));
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4783);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 4783);
 }
 
 // Scene Draw Config 28
-void func_80099760(GlobalContext* globalCtx)
-{
+void func_80099760(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4845);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 4845);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, (gameplayFrames * 2) % 256, 0, 64, 32,
-                                 1, 0, (gameplayFrames * 2) % 128, 64, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, (gameplayFrames * 2) % 256, 0, 64, 32, 1, 0,
+                                (gameplayFrames * 2) % 128, 64, 32));
 
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4859);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 4859);
 }
 
 u32 D_8012A300[] = { 0x02012378, 0x02013378 };
 u32 D_8012A308[] = { 0x02011F78, 0x02014778, 0x02014378, 0x02013F78, 0x02014B78, 0x02013B78, 0x02012F78, 0x02012B78 };
 
 // Scene Draw Config 20
-void func_80099878(GlobalContext* globalCtx)
-{
+void func_80099878(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     s32 pad;
     Gfx* displayListHead;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     displayListHead = Graph_Alloc(globalCtx->state.gfxCtx, 6 * sizeof(Gfx));
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4905);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 4905);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A300[gSaveContext.night_flag]));
     gSPSegment(gfxCtx->polyOpa.p++, 0x09, SEGMENTED_TO_VIRTUAL(D_8012A308[(s32)(gameplayFrames & 14) >> 1]));
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, (gameplayFrames * 1) % 256, 0, 64, 32,
-                                 1, 0, (gameplayFrames * 1) % 128, 64, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, (gameplayFrames * 1) % 256, 0, 64, 32, 1, 0,
+                                (gameplayFrames * 1) % 128, 64, 32));
     gSPSegment(gfxCtx->polyOpa.p++, 0x0A,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, (gameplayFrames * 1) % 128, 32, 32,
-                                 1, 0, (gameplayFrames * 2) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, (gameplayFrames * 1) % 128, 32, 32, 1, 0,
+                                (gameplayFrames * 2) % 128, 32, 32));
 
     { s32 pad2[2]; } // Necessary to match stack usage
 
@@ -1837,35 +782,32 @@ void func_80099878(GlobalContext* globalCtx)
     gDPSetEnvColor(displayListHead++, 0xFF, 0xFF, 0xFF, globalCtx->unk_11D30[1]);
     gSPEndDisplayList(displayListHead);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4956);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 4956);
 }
 
 // Scene Draw Config 30
-void func_80099BD8(GlobalContext* globalCtx)
-{
+void func_80099BD8(GlobalContext* globalCtx) {
     f32 temp;
     Gfx* displayListHead;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     displayListHead = Graph_Alloc(globalCtx->state.gfxCtx, 18 * sizeof(Gfx));
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5069);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5069);
 
     temp = globalCtx->unk_11D30[0] / 255.0f;
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, displayListHead);
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, displayListHead);
-    gDPSetPrimColor(displayListHead++, 0, 0,
-                    0xFF - (u8)(185.0f * temp), 0xFF - (u8)(145.0f * temp),
+    gDPSetPrimColor(displayListHead++, 0, 0, 0xFF - (u8)(185.0f * temp), 0xFF - (u8)(145.0f * temp),
                     0xFF - (u8)(105.0f * temp), 0xFF);
     gSPEndDisplayList(displayListHead++);
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x09, displayListHead);
     gSPSegment(gfxCtx->polyOpa.p++, 0x09, displayListHead);
-    gDPSetPrimColor(displayListHead++, 0, 0,
-                    0x4C + (u8)(6.0f * temp), 0x4C + (u8)(34.0f * temp),
+    gDPSetPrimColor(displayListHead++, 0, 0, 0x4C + (u8)(6.0f * temp), 0x4C + (u8)(34.0f * temp),
                     0x4C + (u8)(74.0f * temp), 0xFF);
     gSPEndDisplayList(displayListHead++);
 
@@ -1877,8 +819,7 @@ void func_80099BD8(GlobalContext* globalCtx)
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x0B, displayListHead);
     gSPSegment(gfxCtx->polyXlu.p++, 0x0B, displayListHead);
-    gDPSetPrimColor(displayListHead++, 0, 0,
-                    0x59 + (u8)(166.0f * temp), 0x59 + (u8)(166.0f * temp),
+    gDPSetPrimColor(displayListHead++, 0, 0, 0x59 + (u8)(166.0f * temp), 0x59 + (u8)(166.0f * temp),
                     0x59 + (u8)(166.0f * temp), 0xFF);
     gDPPipeSync(displayListHead++);
     gDPSetEnvColor(displayListHead++, 0, 0, 0, globalCtx->unk_11D30[0]);
@@ -1886,8 +827,7 @@ void func_80099BD8(GlobalContext* globalCtx)
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x0C, displayListHead);
     gSPSegment(gfxCtx->polyXlu.p++, 0x0C, displayListHead);
-    gDPSetPrimColor(displayListHead++, 0, 0,
-                    0xFF + (u8)(179.0f * temp), 0xFF + (u8)(179.0f * temp),
+    gDPSetPrimColor(displayListHead++, 0, 0, 0xFF + (u8)(179.0f * temp), 0xFF + (u8)(179.0f * temp),
                     0xFF + (u8)(179.0f * temp), 0xFF);
     gDPPipeSync(displayListHead++);
     gDPSetEnvColor(displayListHead++, 0, 0, 0, globalCtx->unk_11D30[0]);
@@ -1899,10 +839,9 @@ void func_80099BD8(GlobalContext* globalCtx)
     gDPSetEnvColor(displayListHead++, 0, 0, 0, globalCtx->unk_11D30[1]);
     gSPEndDisplayList(displayListHead);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5145);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5145);
 
-    if (gSaveContext.scene_setup_index == 5)
-    {
+    if (gSaveContext.scene_setup_index == 5) {
         D_8015FCF0 = 1;
         D_8015FCF8.x = -20.0f;
         D_8015FCF8.y = 1220.0f;
@@ -1914,38 +853,30 @@ void func_80099BD8(GlobalContext* globalCtx)
 }
 
 // Scene Draw Config 31
-void func_8009A45C(GlobalContext* globalCtx)
-{
+void func_8009A45C(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5171);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5171);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TexScroll(globalCtx->state.gfxCtx,
-                              0, (gameplayFrames * 1) % 64, 256, 16));
+               Gfx_TexScroll(globalCtx->state.gfxCtx, 0, (gameplayFrames * 1) % 64, 256, 16));
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - (gameplayFrames % 128), (gameplayFrames * 1) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
-    gSPSegment(gfxCtx->polyOpa.p++, 0x0A,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, 0, 32, 32,
-                                 1, 0, 127 - (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - (gameplayFrames % 128), (gameplayFrames * 1) % 128,
+                                32, 32, 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
+    gSPSegment(
+        gfxCtx->polyOpa.p++, 0x0A,
+        Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, 0, 32, 32, 1, 0, 127 - (gameplayFrames * 1) % 128, 32, 32));
     gSPSegment(gfxCtx->polyOpa.p++, 0x0B,
-               Draw_TexScroll(globalCtx->state.gfxCtx,
-                              0, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TexScroll(globalCtx->state.gfxCtx, 0, (gameplayFrames * 1) % 128, 32, 32));
     gSPSegment(gfxCtx->polyXlu.p++, 0x0C,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, (gameplayFrames * 50) % 2048, 8, 512,
-                                 1, 0, (gameplayFrames * 60) % 2048, 8, 512));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, (gameplayFrames * 50) % 2048, 8, 512, 1, 0,
+                                (gameplayFrames * 60) % 2048, 8, 512));
     gSPSegment(gfxCtx->polyOpa.p++, 0x0D,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, 0, 32, 64,
-                                 1, 0, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, 0, 32, 64, 1, 0, (gameplayFrames * 1) % 128, 32, 32));
 
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
@@ -1953,35 +884,31 @@ void func_8009A45C(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5212);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5212);
 }
 
 // Scene Draw Config 32
-void func_8009A798(GlobalContext* globalCtx)
-{
+void func_8009A798(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5226);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5226);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TexScroll(globalCtx->state.gfxCtx,
-                              0, (gameplayFrames * 2) % 256, 64, 64));
+               Gfx_TexScroll(globalCtx->state.gfxCtx, 0, (gameplayFrames * 2) % 256, 64, 64));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x0A,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - (gameplayFrames * 1) % 128, (gameplayFrames * 1) % 256, 32, 64,
-                                 1, 0, 0, 32, 128));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - (gameplayFrames * 1) % 128,
+                                (gameplayFrames * 1) % 256, 32, 64, 1, 0, 0, 32, 128));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -1989,28 +916,25 @@ void func_8009A798(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5264);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5264);
 }
 
 // Scene Draw Config 33
-void func_8009A9DC(GlobalContext* globalCtx)
-{
+void func_8009A9DC(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5278);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5278);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 3) % 256, 32, 64,
-                                 1, gameplayFrames % 128, (gameplayFrames * 3) % 256, 32, 64));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 3) % 256, 32,
+                                64, 1, gameplayFrames % 128, (gameplayFrames * 3) % 256, 32, 64));
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 3) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 3) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 3) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 3) % 128, 32, 32));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -2018,23 +942,20 @@ void func_8009A9DC(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5301);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5301);
 }
 
 // Scene Draw Config 48
-void func_8009AB98(GlobalContext* globalCtx)
-{
+void func_8009AB98(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5317);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5317);
 
     gameplayFrames = globalCtx->gameplayFrames;
-    gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TexScroll(globalCtx->state.gfxCtx,
-                              0, gameplayFrames % 64, 256, 16));
+    gSPSegment(gfxCtx->polyXlu.p++, 0x08, Gfx_TexScroll(globalCtx->state.gfxCtx, 0, gameplayFrames % 64, 256, 16));
 
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
@@ -2042,27 +963,23 @@ void func_8009AB98(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5330);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5330);
 }
 
 // Scene Draw Config 39
-void func_8009ACA8(GlobalContext* globalCtx)
-{
+void func_8009ACA8(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5346);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5346);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 3) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 3) % 128, 32, 32));
-    gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TexScroll(globalCtx->state.gfxCtx,
-                              0, gameplayFrames % 64, 256, 16));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 3) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 3) % 128, 32, 32));
+    gSPSegment(gfxCtx->polyXlu.p++, 0x09, Gfx_TexScroll(globalCtx->state.gfxCtx, 0, gameplayFrames % 64, 256, 16));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -2070,31 +987,29 @@ void func_8009ACA8(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5367);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5367);
 }
 
 // Scene Draw Config 24
-void func_8009AE30(GlobalContext* globalCtx)
-{
+void func_8009AE30(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5384);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5384);
 
     gameplayFrames = globalCtx->gameplayFrames;
 
-    if (globalCtx->sceneNum == SCENE_HAKADAN_BS)
+    if (globalCtx->sceneNum == SCENE_HAKADAN_BS) {
         gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-                   Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                     0, (gameplayFrames * 2) % 128, 0, 32, 32,
-                                     1, (gameplayFrames * 2) % 128, 0, 32, 32));
-    else
+                   Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, (gameplayFrames * 2) % 128, 0, 32, 32, 1,
+                                    (gameplayFrames * 2) % 128, 0, 32, 32));
+    } else {
         gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-                   Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                     0, (gameplayFrames * 2) % 128, 0, 32, 32,
-                                     1, (gameplayFrames * 2) % 128, 0, 32, 32));
+                   Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, (gameplayFrames * 2) % 128, 0, 32, 32, 1,
+                                    (gameplayFrames * 2) % 128, 0, 32, 32));
+    }
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -2102,48 +1017,45 @@ void func_8009AE30(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5416);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5416);
 }
 
 u32 D_8012A328[] = { 0x0200BD20, 0x0200B920 };
 
 // Scene Draw Config 40
-void func_8009AFE0(GlobalContext* globalCtx)
-{
+void func_8009AFE0(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5490);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5490);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x09,
-               Draw_TexScroll(globalCtx->state.gfxCtx,
-                              0, (gameplayFrames * 3) % 128, 32, 32));
+               Gfx_TexScroll(globalCtx->state.gfxCtx, 0, (gameplayFrames * 3) % 128, 32, 32));
 
     { s32 pad[2]; } // Necessary to match stack usage
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A328[gSaveContext.night_flag]));
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5507);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5507);
 }
 
 u32 D_8012A330[] = { 0x02014C30, 0x02015830 };
 
 // Scene Draw Config 23
-void func_8009B0FC(GlobalContext* globalCtx)
-{
+void func_8009B0FC(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     s32 spB0;
     s32 spAC;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5535);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5535);
 
-    if (1) ; // Necessary to match
+    if (1) {} // Necessary to match
 
     spB0 = (globalCtx->unk_11D30[1] >> 8) & 0xFF;
     spAC = globalCtx->unk_11D30[1] & 0xFF;
@@ -2151,102 +1063,74 @@ void func_8009B0FC(GlobalContext* globalCtx)
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A330[gSaveContext.night_flag]));
 
-    if (spB0 == 1)
+    if (spB0 == 1) {
         gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-                   Draw_TwoTexScrollEnvColor(globalCtx->state.gfxCtx,
-                                             0, gameplayFrames * 1, 0, 32, 32,
-                                             1, 0, 0, 32, 32,
-                                             0, 0, 0, spAC));
-    else if (spB0 < 1)
+                   Gfx_TwoTexScrollEnvColor(globalCtx->state.gfxCtx, 0, gameplayFrames * 1, 0, 32, 32, 1, 0, 0, 32, 32,
+                                            0, 0, 0, spAC));
+    } else if (spB0 < 1) {
         gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-                   Draw_TwoTexScrollEnvColor(globalCtx->state.gfxCtx,
-                                             0, gameplayFrames * 1, 0, 32, 32,
-                                             1, 0, 0, 32, 32,
-                                             0, 0, 0, 0xFF));
-    else
+                   Gfx_TwoTexScrollEnvColor(globalCtx->state.gfxCtx, 0, gameplayFrames * 1, 0, 32, 32, 1, 0, 0, 32, 32,
+                                            0, 0, 0, 0xFF));
+    } else {
         gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-                   Draw_TwoTexScrollEnvColor(globalCtx->state.gfxCtx,
-                                             0, gameplayFrames * 1, 0, 32, 32,
-                                             1, 0, 0, 32, 32,
-                                             0, 0, 0, 0xA0));
+                   Gfx_TwoTexScrollEnvColor(globalCtx->state.gfxCtx, 0, gameplayFrames * 1, 0, 32, 32, 1, 0, 0, 32, 32,
+                                            0, 0, 0, 0xA0));
+    }
 
-    if (spB0 == 2)
+    if (spB0 == 2) {
         gSPSegment(gfxCtx->polyOpa.p++, 0x09,
-                   Draw_TwoTexScrollEnvColor(globalCtx->state.gfxCtx,
-                                             0, gameplayFrames * 1, 0, 32, 32,
-                                             1, 0, 0, 32, 32,
-                                             0, 0, 0, spAC));
-    else if (spB0 < 2)
+                   Gfx_TwoTexScrollEnvColor(globalCtx->state.gfxCtx, 0, gameplayFrames * 1, 0, 32, 32, 1, 0, 0, 32, 32,
+                                            0, 0, 0, spAC));
+    } else if (spB0 < 2) {
         gSPSegment(gfxCtx->polyOpa.p++, 0x09,
-                   Draw_TwoTexScrollEnvColor(globalCtx->state.gfxCtx,
-                                             0, gameplayFrames * 1, 0, 32, 32,
-                                             1, 0, 0, 32, 32,
-                                             0, 0, 0, 0xFF));
-    else
+                   Gfx_TwoTexScrollEnvColor(globalCtx->state.gfxCtx, 0, gameplayFrames * 1, 0, 32, 32, 1, 0, 0, 32, 32,
+                                            0, 0, 0, 0xFF));
+    } else {
         gSPSegment(gfxCtx->polyOpa.p++, 0x09,
-                   Draw_TwoTexScrollEnvColor(globalCtx->state.gfxCtx,
-                                             0, gameplayFrames * 1, 0, 32, 32,
-                                             1, 0, 0, 32, 32,
-                                             0, 0, 0, 0xA0));
+                   Gfx_TwoTexScrollEnvColor(globalCtx->state.gfxCtx, 0, gameplayFrames * 1, 0, 32, 32, 1, 0, 0, 32, 32,
+                                            0, 0, 0, 0xA0));
+    }
 
-    if (spB0 != 0)
-    {
+    if (spB0 != 0) {
         gSPSegment(gfxCtx->polyOpa.p++, 0x0A,
-                   Draw_TwoTexScrollEnvColor(globalCtx->state.gfxCtx,
-                                             0, gameplayFrames * 1, 0, 32, 32,
-                                             1, 0, 0, 32, 32,
-                                             0, 0, 0, 0xA0));
+                   Gfx_TwoTexScrollEnvColor(globalCtx->state.gfxCtx, 0, gameplayFrames * 1, 0, 32, 32, 1, 0, 0, 32, 32,
+                                            0, 0, 0, 0xA0));
         gSPSegment(gfxCtx->polyOpa.p++, 0x0B,
-                   Draw_TwoTexScrollEnvColor(globalCtx->state.gfxCtx,
-                                             0, gameplayFrames * 3, 0, 32, 32,
-                                             1, 0, 0, 32, 32,
-                                             0, 0, 0, 0xB4));
-    }
-    else
-    {
+                   Gfx_TwoTexScrollEnvColor(globalCtx->state.gfxCtx, 0, gameplayFrames * 3, 0, 32, 32, 1, 0, 0, 32, 32,
+                                            0, 0, 0, 0xB4));
+    } else {
         gSPSegment(gfxCtx->polyOpa.p++, 0x0A,
-                   Draw_TwoTexScrollEnvColor(globalCtx->state.gfxCtx,
-                                             0, (gameplayFrames * 1) % 128, 0, 32, 32,
-                                             1, 0, 0, 32, 32,
-                                             0, 0, 0, 0xA0 + (s32)((spAC / 200.0f) * 95.0f)));
+                   Gfx_TwoTexScrollEnvColor(globalCtx->state.gfxCtx, 0, (gameplayFrames * 1) % 128, 0, 32, 32, 1, 0, 0,
+                                            32, 32, 0, 0, 0, 0xA0 + (s32)((spAC / 200.0f) * 95.0f)));
         gSPSegment(gfxCtx->polyOpa.p++, 0x0B,
-                   Draw_TwoTexScrollEnvColor(globalCtx->state.gfxCtx,
-                                             0, gameplayFrames * 3, 0, 32, 32,
-                                             1, 0, 0, 32, 32,
-                                             0, 0, 0, 0xB9 + (s32)((spAC / 200.0f) * 70.0f)));
+                   Gfx_TwoTexScrollEnvColor(globalCtx->state.gfxCtx, 0, gameplayFrames * 3, 0, 32, 32, 1, 0, 0, 32, 32,
+                                            0, 0, 0, 0xB9 + (s32)((spAC / 200.0f) * 70.0f)));
     }
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x0C,
-               Draw_TwoTexScrollEnvColor(globalCtx->state.gfxCtx,
-                                         0, gameplayFrames * 1, gameplayFrames * 1, 32, 32,
-                                         1, 0, 127 - (gameplayFrames * 1), 32, 32,
-                                         0, 0, 0, 0x80));
+               Gfx_TwoTexScrollEnvColor(globalCtx->state.gfxCtx, 0, gameplayFrames * 1, gameplayFrames * 1, 32, 32, 1,
+                                        0, 127 - (gameplayFrames * 1), 32, 32, 0, 0, 0, 0x80));
     gSPSegment(gfxCtx->polyXlu.p++, 0x0D,
-               Draw_TwoTexScrollEnvColor(globalCtx->state.gfxCtx,
-                                         0, gameplayFrames * 4, 0, 32, 32,
-                                         1, gameplayFrames * 4, 0, 32, 32,
-                                         0, 0, 0, 0x80));
+               Gfx_TwoTexScrollEnvColor(globalCtx->state.gfxCtx, 0, gameplayFrames * 4, 0, 32, 32, 1,
+                                        gameplayFrames * 4, 0, 32, 32, 0, 0, 0, 0x80));
 
     { s32 pad[2]; } // Necessary to match stack usage
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5644);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5644);
 }
 
 // Scene Draw Config 29
-void func_8009B86C(GlobalContext* globalCtx)
-{
+void func_8009B86C(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5791);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5791);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, gameplayFrames * 1, 0, 32, 32,
-                                 1, 0, 0, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, gameplayFrames * 1, 0, 32, 32, 1, 0, 0, 32, 32));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, globalCtx->unk_11D30[0]);
@@ -2254,50 +1138,45 @@ void func_8009B86C(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x91);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5808);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5808);
 }
 
 // Scene Draw Config 34
-void func_8009B9BC(GlobalContext* globalCtx)
-{
+void func_8009B9BC(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5822);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5822);
 
     gameplayFrames = globalCtx->gameplayFrames;
-    gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-               Draw_TexScroll(globalCtx->state.gfxCtx,
-                              0, gameplayFrames % 64, 4, 16));
+    gSPSegment(gfxCtx->polyOpa.p++, 0x08, Gfx_TexScroll(globalCtx->state.gfxCtx, 0, gameplayFrames % 64, 4, 16));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5836);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5836);
 }
 
 // Scene Draw Config 35
-void func_8009BAA4(GlobalContext* globalCtx)
-{
+void func_8009BAA4(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5850);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5850);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 3) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 3) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 3) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 3) % 128, 32, 32));
 
-    if (globalCtx->sceneNum == SCENE_HAIRAL_NIWA)
+    if (globalCtx->sceneNum == SCENE_HAIRAL_NIWA) {
         gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-                   Draw_TexScroll(globalCtx->state.gfxCtx,
-                                  0, (gameplayFrames * 10) % 256, 32, 64));
+                   Gfx_TexScroll(globalCtx->state.gfxCtx, 0, (gameplayFrames * 10) % 256, 32, 64));
+    }
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -2305,41 +1184,37 @@ void func_8009BAA4(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5876);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5876);
 }
 
 // Scene Draw Config 36
-void func_8009BC44(GlobalContext* globalCtx)
-{
+void func_8009BC44(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     s8 sp83;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    if (1) ; // Necessary to match
+    if (1) {} // Necessary to match
 
     sp83 = coss((globalCtx->gameplayFrames * 1500) & 0xFFFF) >> 8;
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5894);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5894);
 
     gameplayFrames = globalCtx->gameplayFrames;
 
-    if (globalCtx->sceneNum == SCENE_GANON_TOU)
-    {
+    if (globalCtx->sceneNum == SCENE_GANON_TOU) {
         gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-                   Draw_TexScroll(globalCtx->state.gfxCtx,
-                                  0, (gameplayFrames * 1) % 256, 64, 64));
+                   Gfx_TexScroll(globalCtx->state.gfxCtx, 0, (gameplayFrames * 1) % 256, 64, 64));
         gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-                   Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                     0, 0, 255 - (gameplayFrames * 1) % 256, 64, 64,
-                                     1, 0, (gameplayFrames * 1) % 256, 64, 64));
+                   Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, 255 - (gameplayFrames * 1) % 256, 64, 64, 1, 0,
+                                    (gameplayFrames * 1) % 256, 64, 64));
     }
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x0B,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 255 - (gameplayFrames * 1) % 128, (gameplayFrames * 1) % 128, 32, 32,
-                                 1, (gameplayFrames * 1) % 128, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 255 - (gameplayFrames * 1) % 128,
+                                (gameplayFrames * 1) % 128, 32, 32, 1, (gameplayFrames * 1) % 128,
+                                (gameplayFrames * 1) % 128, 32, 32));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -2351,30 +1226,27 @@ void func_8009BC44(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, sp83, sp83, sp83, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5930);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5930);
 }
 
 // Screen Shake for Ganon's Tower Collapse
 #ifdef NON_MATCHING
 // regalloc differences
-void func_8009BEEC(GlobalContext* globalCtx)
-{
+void func_8009BEEC(GlobalContext* globalCtx) {
     s32 var;
 
-    if (globalCtx->gameplayFrames % 128 == 13)
-    {
-        var = func_80092F88(globalCtx->cameraCtx.activeCameraPtrs[globalCtx->cameraCtx.unk_5C0], 2);
-        func_80092DAC(var, 10000);
-        func_80092E70(var, 4, 0, 0, 0);
-        func_80092DF0(var, 127);
+    if (globalCtx->gameplayFrames % 128 == 13) {
+        var = Quake_Add(globalCtx->cameraCtx.activeCameraPtrs[globalCtx->cameraCtx.unk_5C0], 2);
+        Quake_SetSpeed(var, 10000);
+        Quake_SetQuakeValues(var, 4, 0, 0, 0);
+        Quake_SetCountdown(var, 127);
     }
 
-    if ((globalCtx->gameplayFrames % 64 == 0) && (Math_Rand_ZeroOne() > 0.6f))
-    {
-        var = func_80092F88(globalCtx->cameraCtx.activeCameraPtrs[globalCtx->cameraCtx.unk_5C0], 3);
-        func_80092DAC(var, 32000.0f + (Math_Rand_ZeroOne() * 3000.0f));
-        func_80092E70(var, 10.0f - (Math_Rand_ZeroOne() * 9.0f), 0, 0, 0);
-        func_80092DF0(var, 48.0f - (Math_Rand_ZeroOne() * 15.0f));
+    if ((globalCtx->gameplayFrames % 64 == 0) && (Math_Rand_ZeroOne() > 0.6f)) {
+        var = Quake_Add(globalCtx->cameraCtx.activeCameraPtrs[globalCtx->cameraCtx.unk_5C0], 3);
+        Quake_SetSpeed(var, 32000.0f + (Math_Rand_ZeroOne() * 3000.0f));
+        Quake_SetQuakeValues(var, 10.0f - (Math_Rand_ZeroOne() * 9.0f), 0, 0, 0);
+        Quake_SetCountdown(var, 48.0f - (Math_Rand_ZeroOne() * 15.0f));
     }
 }
 #else
@@ -2383,33 +1255,29 @@ void func_8009BEEC(GlobalContext* globalCtx);
 #endif
 
 // Scene Draw Config 38
-void func_8009C0AC(GlobalContext* globalCtx)
-{
+void func_8009C0AC(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     s8 sp7B;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    if (1) ; // Necessary to match
+    if (1) {} // Necessary to match
 
     sp7B = coss((globalCtx->gameplayFrames * 1500) & 0xFFFF) >> 8;
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5968);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5968);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, (gameplayFrames * 1) % 512, 64, 128,
-                                 1, 0, 511 - (gameplayFrames * 1) % 512, 64, 128));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, (gameplayFrames * 1) % 512, 64, 128, 1, 0,
+                                511 - (gameplayFrames * 1) % 512, 64, 128));
     gSPSegment(gfxCtx->polyOpa.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, (gameplayFrames * 1) % 256, 32, 64,
-                                 1, 0, 255 - (gameplayFrames * 1) % 256, 32, 64));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, (gameplayFrames * 1) % 256, 32, 64, 1, 0,
+                                255 - (gameplayFrames * 1) % 256, 32, 64));
     gSPSegment(gfxCtx->polyXlu.p++, 0x0A,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, (gameplayFrames * 20) % 2048, 16, 512,
-                                 1, 0, (gameplayFrames * 30) % 2048, 16, 512));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, (gameplayFrames * 20) % 2048, 16, 512, 1, 0,
+                                (gameplayFrames * 30) % 2048, 16, 512));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -2421,15 +1289,11 @@ void func_8009C0AC(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, sp7B, sp7B, sp7B, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6004);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6004);
 
-    if (Flags_GetSwitch(globalCtx, 0x37))
-    {
-        if ((globalCtx->sceneNum == SCENE_GANON_DEMO) ||
-            (globalCtx->sceneNum == SCENE_GANON_FINAL) ||
-            (globalCtx->sceneNum == SCENE_GANON_SONOGO) ||
-            (globalCtx->sceneNum == SCENE_GANONTIKA_SONOGO))
-        {
+    if (Flags_GetSwitch(globalCtx, 0x37)) {
+        if ((globalCtx->sceneNum == SCENE_GANON_DEMO) || (globalCtx->sceneNum == SCENE_GANON_FINAL) ||
+            (globalCtx->sceneNum == SCENE_GANON_SONOGO) || (globalCtx->sceneNum == SCENE_GANONTIKA_SONOGO)) {
             func_8009BEEC(globalCtx);
         }
     }
@@ -2438,27 +1302,24 @@ void func_8009C0AC(GlobalContext* globalCtx)
 u32 D_8012A338[] = { 0x0200FAC0, 0x0200F8C0 };
 
 // Scene Draw Config 37
-void func_8009C3EC(GlobalContext* globalCtx)
-{
+void func_8009C3EC(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    if (0) ; // Necessary to match
+    if (0) {} // Necessary to match
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6042);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6042);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A338[gSaveContext.night_flag]));
     gSPSegment(gfxCtx->polyOpa.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
     gSPSegment(gfxCtx->polyXlu.p++, 0x0A,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
 
     { s32 pad[2]; } // Necessary to match stack usage
 
@@ -2468,35 +1329,30 @@ void func_8009C3EC(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6076);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6076);
 }
 
 // Scene Draw Config 42
-void func_8009C608(GlobalContext* globalCtx)
-{
+void func_8009C608(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6151);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6151);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TexScroll(globalCtx->state.gfxCtx,
-                              0, (gameplayFrames * 1) % 64, 256, 16));
+               Gfx_TexScroll(globalCtx->state.gfxCtx, 0, (gameplayFrames * 1) % 64, 256, 16));
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, (gameplayFrames * 60) % 2048, 8, 512,
-                                 1, 0, (gameplayFrames * 50) % 2048, 8, 512));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, (gameplayFrames * 60) % 2048, 8, 512, 1, 0,
+                                (gameplayFrames * 50) % 2048, 8, 512));
     gSPSegment(gfxCtx->polyOpa.p++, 0x0A,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - (gameplayFrames * 1) % 128, 0, 32, 32,
-                                 1, (gameplayFrames * 1) % 128, 0, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - (gameplayFrames * 1) % 128, 0, 32, 32, 1,
+                                (gameplayFrames * 1) % 128, 0, 32, 32));
     gSPSegment(gfxCtx->polyXlu.p++, 0x0B,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, 1023 - (gameplayFrames * 6) % 1024, 16, 256,
-                                 1, 0, 1023 - (gameplayFrames * 3) % 1024, 16, 256));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, 1023 - (gameplayFrames * 6) % 1024, 16, 256, 1, 0,
+                                1023 - (gameplayFrames * 3) % 1024, 16, 256));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -2504,31 +1360,26 @@ void func_8009C608(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6187);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6187);
 }
 
 // Scene Draw Config 43
-void func_8009C8B8(GlobalContext* globalCtx)
-{
+void func_8009C8B8(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6201);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6201);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, 0, 32, 32,
-                                 1, 0, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, 0, 32, 32, 1, 0, (gameplayFrames * 1) % 128, 32, 32));
     gSPSegment(gfxCtx->polyXlu.p++, 0x0A,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TexScroll(globalCtx->state.gfxCtx,
-                              0, 255 - (gameplayFrames * 10) % 256, 32, 64));
+               Gfx_TexScroll(globalCtx->state.gfxCtx, 0, 255 - (gameplayFrames * 10) % 256, 32, 64));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -2536,24 +1387,22 @@ void func_8009C8B8(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6232);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6232);
 }
 
 // Scene Draw Config 47
-void func_8009CAC0(GlobalContext* globalCtx)
-{
+void func_8009CAC0(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6249);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6249);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                             0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32,
-                             1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -2561,33 +1410,30 @@ void func_8009CAC0(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6264);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6264);
 }
 
 u32 D_8012A340[] = { 0x0200F8C0, 0x020100C0 };
 
 // Scene Draw Config 27
-void func_8009CC00(GlobalContext* globalCtx)
-{
+void func_8009CC00(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    if (0) ; // Necessary to match
+    if (0) {} // Necessary to match
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6290);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6290);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A340[gSaveContext.night_flag]));
     gSPSegment(gfxCtx->polyOpa.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
     gSPSegment(gfxCtx->polyXlu.p++, 0x0A,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
 
     { s32 pad[2]; } // Necessary to match stack usage
 
@@ -2597,13 +1443,11 @@ void func_8009CC00(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6320);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6320);
 }
 
-Gfx* Draw_TwoTexScrollPrimColor(GraphicsContext* gfxCtx, s32 tile1, u32 x1, u32 y1, s32 width1, s32 height1,
-                                s32 tile2, u32 x2, u32 y2, s32 width2, s32 height2,
-                                s32 red, s32 green, s32 blue, s32 alpha)
-{
+Gfx* Gfx_TwoTexScrollPrimColor(GraphicsContext* gfxCtx, s32 tile1, u32 x1, u32 y1, s32 width1, s32 height1, s32 tile2,
+                               u32 x2, u32 y2, s32 width2, s32 height2, s32 r, s32 g, s32 b, s32 a) {
     Gfx* displayList = Graph_Alloc(gfxCtx, 10 * sizeof(Gfx));
 
     x1 %= 2048;
@@ -2612,33 +1456,30 @@ Gfx* Draw_TwoTexScrollPrimColor(GraphicsContext* gfxCtx, s32 tile1, u32 x1, u32
     y2 %= 2048;
 
     gDPTileSync(displayList);
-    gDPSetTileSize(displayList+1, tile1, x1, y1,
-                   (x1+((width1-1)<<2)), (y1+((height1-1)<<2)));
-    gDPTileSync(displayList+2);
-    gDPSetTileSize(displayList+3, tile2, x2, y2,
-                   (x2+((width2-1)<<2)), (y2+((height2-1)<<2)));
-    gDPSetPrimColor(displayList+4, 0, 0, red, green, blue, alpha);
-    gSPEndDisplayList(displayList+5);
+    gDPSetTileSize(displayList + 1, tile1, x1, y1, (x1 + ((width1 - 1) << 2)), (y1 + ((height1 - 1) << 2)));
+    gDPTileSync(displayList + 2);
+    gDPSetTileSize(displayList + 3, tile2, x2, y2, (x2 + ((width2 - 1) << 2)), (y2 + ((height2 - 1) << 2)));
+    gDPSetPrimColor(displayList + 4, 0, 0, r, g, b, a);
+    gSPEndDisplayList(displayList + 5);
 
     return displayList;
 }
 
 // Scene Draw Config 50
-void func_8009CF84(GlobalContext* globalCtx)
-{
+void func_8009CF84(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6433);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6433);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScrollPrimColor(globalCtx->state.gfxCtx,
-                                          0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32,
-                                          1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32,
-                                          0xFF, 0xFF, 0xFF, globalCtx->unk_11D30[0] + 127));
+               Gfx_TwoTexScrollPrimColor(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128,
+                                         (gameplayFrames * 1) % 128, 32, 32, 1, gameplayFrames % 128,
+                                         (gameplayFrames * 1) % 128, 32, 32, 0xFF, 0xFF, 0xFF,
+                                         globalCtx->unk_11D30[0] + 127));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -2646,33 +1487,27 @@ void func_8009CF84(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6449);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6449);
 }
 
 // Scene Draw Config 41
-void func_8009D0E8(GlobalContext* globalCtx)
-{
+void func_8009D0E8(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6463);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6463);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TexScroll(globalCtx->state.gfxCtx,
-                              127 - (gameplayFrames * 4) % 128, 0, 32, 32));
-    gSPSegment(gfxCtx->polyOpa.p++, 0x09,
-               Draw_TexScroll(globalCtx->state.gfxCtx,
-                              0, (gameplayFrames * 5) % 64, 16, 16));
+               Gfx_TexScroll(globalCtx->state.gfxCtx, 127 - (gameplayFrames * 4) % 128, 0, 32, 32));
+    gSPSegment(gfxCtx->polyOpa.p++, 0x09, Gfx_TexScroll(globalCtx->state.gfxCtx, 0, (gameplayFrames * 5) % 64, 16, 16));
     gSPSegment(gfxCtx->polyOpa.p++, 0x0A,
-               Draw_TexScroll(globalCtx->state.gfxCtx,
-                              0, 63 - (gameplayFrames * 2) % 64, 16, 16));
-    gSPSegment(gfxCtx->polyXlu.p++, 0x0B,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, 127 - (gameplayFrames * 3) % 128, 32, 32,
-                                 1, 0, 0, 32, 32));
+               Gfx_TexScroll(globalCtx->state.gfxCtx, 0, 63 - (gameplayFrames * 2) % 64, 16, 16));
+    gSPSegment(
+        gfxCtx->polyXlu.p++, 0x0B,
+        Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, 127 - (gameplayFrames * 3) % 128, 32, 32, 1, 0, 0, 32, 32));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -2680,20 +1515,19 @@ void func_8009D0E8(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6491);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6491);
 }
 
 u32 D_8012A348[] = { 0x02005210, 0x02005010 };
 
 // Scene Draw Config 44
-void func_8009D31C(GlobalContext* globalCtx)
-{
+void func_8009D31C(GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
     s32 pad[2];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6515);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6515);
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A348[gSaveContext.night_flag]));
 
@@ -2703,26 +1537,26 @@ void func_8009D31C(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6528);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6528);
 }
 
 u32 D_8012A350[] = { 0x02006550, 0x02003550 };
 u32 D_8012A358[] = { 0x02002350, 0x02001350 };
 
 // Scene Draw Config 45
-void func_8009D438(GlobalContext* globalCtx)
-{
+void func_8009D438(GlobalContext* globalCtx) {
     s32 var;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6560);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6560);
 
-    if (LINK_IS_ADULT)
+    if (LINK_IS_ADULT) {
         var = 1;
-    else
+    } else {
         var = gSaveContext.night_flag;
+    }
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A358[var]));
     gSPSegment(gfxCtx->polyOpa.p++, 0x09, SEGMENTED_TO_VIRTUAL(D_8012A350[var]));
@@ -2733,27 +1567,24 @@ void func_8009D438(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6581);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6581);
 }
 
 // Scene Draw Config 46
-void func_8009D5B4(GlobalContext* globalCtx)
-{
+void func_8009D5B4(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6595);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6595);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-               Draw_TexScroll(globalCtx->state.gfxCtx,
-                              0, (gameplayFrames * 3) % 128, 32, 32));
+               Gfx_TexScroll(globalCtx->state.gfxCtx, 0, (gameplayFrames * 3) % 128, 32, 32));
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, 1023 - (gameplayFrames * 3) % 1024, 16, 256,
-                                 1, 0, 1023 - (gameplayFrames * 6) % 1024, 16, 256));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, 1023 - (gameplayFrames * 3) % 1024, 16, 256, 1, 0,
+                                1023 - (gameplayFrames * 6) % 1024, 16, 256));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -2761,33 +1592,30 @@ void func_8009D5B4(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6615);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6615);
 }
 
 u32 D_8012A360[] = { 0x02014D90, 0x02014590 };
 
 // Scene Draw Config 22
-void func_8009D758(GlobalContext* globalCtx)
-{
+void func_8009D758(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    if (0) ; // Necessary to match
+    if (0) {} // Necessary to match
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6640);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6640);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A360[gSaveContext.night_flag]));
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
     gSPSegment(gfxCtx->polyOpa.p++, 0x0A,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
 
     { s32 pad[2]; } // Necessary to match stack usage
 
@@ -2797,48 +1625,44 @@ void func_8009D758(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6671);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6671);
 }
 
 u32 D_8012A368[] = { 0x02018920, 0x02018020 };
 
 // Scene Draw Config 25
-void func_8009D974(GlobalContext* globalCtx)
-{
+void func_8009D974(GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
     s32 pad[2];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6752);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6752);
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A368[gSaveContext.night_flag]));
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6762);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6762);
 }
 
 // Scene Draw Config 1
-void func_8009DA30(GlobalContext* globalCtx)
-{
+void func_8009DA30(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     Gfx* displayListHead;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     displayListHead = Graph_Alloc(globalCtx->state.gfxCtx, 3 * sizeof(Gfx));
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6814);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6814);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 3) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 3) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 3) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 3) % 128, 32, 32));
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 10) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 10) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 10) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 10) % 128, 32, 32));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -2848,21 +1672,17 @@ void func_8009DA30(GlobalContext* globalCtx)
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x0A, displayListHead);
 
-    if ((gSaveContext.day_time >= 0x4AAC) && (gSaveContext.day_time <= 0xC555))
-    {
+    if ((gSaveContext.day_time >= 0x4AAC) && (gSaveContext.day_time <= 0xC555)) {
         gSPEndDisplayList(displayListHead);
-    }
-    else
-    {
-        if (gSaveContext.day_time > 0xC555)
-        {
-            if (globalCtx->unk_11D30[0] != 255)
+    } else {
+        if (gSaveContext.day_time > 0xC555) {
+            if (globalCtx->unk_11D30[0] != 255) {
                 Math_ApproxS(&globalCtx->unk_11D30[0], 255, 5);
-        }
-        else if (gSaveContext.day_time >= 0x4000)
-        {
-            if (globalCtx->unk_11D30[0] != 0)
+            }
+        } else if (gSaveContext.day_time >= 0x4000) {
+            if (globalCtx->unk_11D30[0] != 0) {
                 Math_ApproxS(&globalCtx->unk_11D30[0], 0, 10);
+            }
         }
 
         gDPSetPrimColor(displayListHead++, 0, 0, 0xFF, 0xFF, 0xFF, globalCtx->unk_11D30[0]);
@@ -2870,20 +1690,19 @@ void func_8009DA30(GlobalContext* globalCtx)
         gSPEndDisplayList(displayListHead);
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6866);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6866);
 }
 
 u32 D_8012A370[] = { 0x02015B50, 0x02016B50 };
 
 // Scene Draw Config 2
-void func_8009DD5C(GlobalContext* globalCtx)
-{
+void func_8009DD5C(GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
     s32 pad[2];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6890);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6890);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A370[gSaveContext.night_flag]));
 
@@ -2893,32 +1712,28 @@ void func_8009DD5C(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6903);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6903);
 }
 
 // Scene Draw Config 3
-void func_8009DE78(GlobalContext* globalCtx)
-{
+void func_8009DE78(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6917);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6917);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 6) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 6) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 6) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 6) % 128, 32, 32));
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 3) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 3) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 3) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 3) % 128, 32, 32));
     gSPSegment(gfxCtx->polyXlu.p++, 0x0A,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -2926,18 +1741,17 @@ void func_8009DE78(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6948);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6948);
 }
 
 // Scene Draw Config 4
-void func_8009E0B8(GlobalContext* globalCtx)
-{
+void func_8009E0B8(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     u8 spA3;
     u16 spA0;
     Gfx* displayListHead;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     spA3 = 128;
     spA0 = 500;
@@ -2945,17 +1759,15 @@ void func_8009E0B8(GlobalContext* globalCtx)
     displayListHead = Graph_Alloc(globalCtx->state.gfxCtx, 6 * sizeof(Gfx));
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6965);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6965);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 10) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 10) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 10) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 10) % 128, 32, 32));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -2963,12 +1775,13 @@ void func_8009E0B8(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    if (gSaveContext.scene_setup_index == 4)
+    if (gSaveContext.scene_setup_index == 4) {
         spA3 = 255 - (u8)globalCtx->unk_11D30[0];
-    else if (gSaveContext.scene_setup_index == 6)
+    } else if (gSaveContext.scene_setup_index == 6) {
         spA0 = globalCtx->unk_11D30[0] + 500;
-    else if (((gSaveContext.scene_setup_index < 4) || LINK_IS_ADULT) && (gSaveContext.event_chk_inf[0] & 0x80))
+    } else if (((gSaveContext.scene_setup_index < 4) || LINK_IS_ADULT) && (gSaveContext.event_chk_inf[0] & 0x80)) {
         spA0 = 2150;
+    }
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x0A, displayListHead);
     gDPPipeSync(displayListHead++);
@@ -2982,66 +1795,58 @@ void func_8009E0B8(GlobalContext* globalCtx)
     gSPEndDisplayList(displayListHead);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x0C,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, (s16)(-globalCtx->unk_11D30[0] * 0.02f), 32, 16,
-                                 1, 0, (s16)(-globalCtx->unk_11D30[0] * 0.02f), 32, 16));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, (s16)(-globalCtx->unk_11D30[0] * 0.02f), 32, 16, 1, 0,
+                                (s16)(-globalCtx->unk_11D30[0] * 0.02f), 32, 16));
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7044);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7044);
 }
 
 // Scene Draw Config 5
-void func_8009E54C(GlobalContext* globalCtx)
-{
+void func_8009E54C(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7058);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7058);
 
-    if ((gSaveContext.scene_setup_index > 3) ||
-        (LINK_IS_ADULT && !(gSaveContext.event_chk_inf[6] & 0x200)))
+    if ((gSaveContext.scene_setup_index > 3) || (LINK_IS_ADULT && !(gSaveContext.event_chk_inf[6] & 0x200))) {
         globalCtx->unk_11D30[0] = 87;
+    }
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-               Draw_TwoTexScrollEnvColor(globalCtx->state.gfxCtx,
-                                         0, gameplayFrames, gameplayFrames, 32, 32,
-                                         1, 0, 0, 32, 32,
-                                         0, 0, 0, globalCtx->unk_11D30[0] + 0xA8));
+               Gfx_TwoTexScrollEnvColor(globalCtx->state.gfxCtx, 0, gameplayFrames, gameplayFrames, 32, 32, 1, 0, 0, 32,
+                                        32, 0, 0, 0, globalCtx->unk_11D30[0] + 0xA8));
     gSPSegment(gfxCtx->polyOpa.p++, 0x09,
-               Draw_TwoTexScrollEnvColor(globalCtx->state.gfxCtx,
-                                         0, -gameplayFrames, -gameplayFrames, 32, 32,
-                                         1, 0, 0, 16, 64,
-                                         0, 0, 0, globalCtx->unk_11D30[0] + 0xA8));
+               Gfx_TwoTexScrollEnvColor(globalCtx->state.gfxCtx, 0, -gameplayFrames, -gameplayFrames, 32, 32, 1, 0, 0,
+                                        16, 64, 0, 0, 0, globalCtx->unk_11D30[0] + 0xA8));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0xFF, 0xFF, 0xFF, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7097);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7097);
 }
 
 u32 D_8012A378[] = { 0x02008F98, 0x02008FD8 };
 
 // Scene Draw Config 6
-void func_8009E730(GlobalContext* globalCtx)
-{
+void func_8009E730(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     u32 var;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7123);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7123);
 
     gameplayFrames = globalCtx->gameplayFrames;
     var = 127 - (gameplayFrames * 1) % 128;
-    if (LINK_IS_ADULT)
+    if (LINK_IS_ADULT) {
         var = 0;
+    }
     gSPSegment(gfxCtx->polyOpa.p++, 0x0C,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, 0, 64, 32,
-                                 1, 0, var, 64, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, 0, 64, 32, 1, 0, var, 64, 32));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -3050,32 +1855,27 @@ void func_8009E730(GlobalContext* globalCtx)
 
     { s32 pad[2]; } // Necessary to match stack usage
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7147);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7147);
 }
 
 // Scene Draw Config 7
-void func_8009E8C0(GlobalContext* globalCtx)
-{
+void func_8009E8C0(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7161);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7161);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, (gameplayFrames * 1) % 128, 0, 32, 32,
-                                 1, 0, 0, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, (gameplayFrames * 1) % 128, 0, 32, 32, 1, 0, 0, 32, 32));
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, 255 - (gameplayFrames * 2) % 256, 64, 64,
-                                 1, 0, 255 - (gameplayFrames * 2) % 256, 64, 64));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, 255 - (gameplayFrames * 2) % 256, 64, 64, 1, 0,
+                                255 - (gameplayFrames * 2) % 256, 64, 64));
     gSPSegment(gfxCtx->polyXlu.p++, 0x0A,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, (gameplayFrames * 1) % 128, 32, 32,
-                                 1, 0, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, (gameplayFrames * 1) % 128, 32, 32, 1, 0,
+                                (gameplayFrames * 1) % 128, 32, 32));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -3083,44 +1883,37 @@ void func_8009E8C0(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7192);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7192);
 }
 
 // Scene Draw Config 8
-void func_8009EAD8(GlobalContext* globalCtx)
-{
+void func_8009EAD8(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7206);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7206);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, (gameplayFrames * 3) % 1024, 32, 256,
-                                 1, 0, (gameplayFrames * 3) % 1024, 32, 256));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, (gameplayFrames * 3) % 1024, 32, 256, 1, 0,
+                                (gameplayFrames * 3) % 1024, 32, 256));
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, (gameplayFrames * 1) % 256, 64, 64,
-                                 1, 0, (gameplayFrames * 1) % 256, 64, 64));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, (gameplayFrames * 1) % 256, 64, 64, 1, 0,
+                                (gameplayFrames * 1) % 256, 64, 64));
     gSPSegment(gfxCtx->polyXlu.p++, 0x0A,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, (gameplayFrames * 2) % 128, 32, 32,
-                                 1, 0, (gameplayFrames * 2) % 128, 32, 32));
-    gSPSegment(gfxCtx->polyOpa.p++, 0x0B,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, 0, 32, 32,
-                                 1, 0, 127 - (gameplayFrames * 3) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, (gameplayFrames * 2) % 128, 32, 32, 1, 0,
+                                (gameplayFrames * 2) % 128, 32, 32));
+    gSPSegment(
+        gfxCtx->polyOpa.p++, 0x0B,
+        Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, 0, 32, 32, 1, 0, 127 - (gameplayFrames * 3) % 128, 32, 32));
     gSPSegment(gfxCtx->polyXlu.p++, 0x0C,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, (gameplayFrames * 1) % 128, 32, 32,
-                                 1, 0, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, (gameplayFrames * 1) % 128, 32, 32, 1, 0,
+                                (gameplayFrames * 1) % 128, 32, 32));
     gSPSegment(gfxCtx->polyXlu.p++, 0x0D,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, (gameplayFrames * 1) % 64, 16, 16,
-                                 1, 0, (gameplayFrames * 1) % 64, 16, 16));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, (gameplayFrames * 1) % 64, 16, 16, 1, 0,
+                                (gameplayFrames * 1) % 64, 16, 16));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -3128,30 +1921,27 @@ void func_8009EAD8(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7260);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7260);
 }
 
 // Scene Draw Config 9
-void func_8009EE44(GlobalContext* globalCtx)
-{
+void func_8009EE44(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    if (0) ; // Necessary to match
+    if (0) {} // Necessary to match
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7274);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7274);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, gameplayFrames % 128, 0, 32, 16,
-                                 1, gameplayFrames % 128, 0, 32, 16));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, gameplayFrames % 128, 0, 32, 16, 1, gameplayFrames % 128, 0,
+                                32, 16));
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, gameplayFrames % 128, 32, 32,
-                                 1, gameplayFrames % 128, gameplayFrames % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, gameplayFrames % 128, 32, 32, 1,
+                                gameplayFrames % 128, gameplayFrames % 128, 32, 32));
 
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
@@ -3159,34 +1949,29 @@ void func_8009EE44(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
 
-    if ((globalCtx->unk_11D30[0] == 0) && (INV_CONTENT(ITEM_COJIRO) == ITEM_COJIRO))
-    {
-        if (globalCtx->unk_11D30[1] == 50)
-        {
+    if ((globalCtx->unk_11D30[0] == 0) && (INV_CONTENT(ITEM_COJIRO) == ITEM_COJIRO)) {
+        if (globalCtx->unk_11D30[1] == 50) {
             func_8002F7DC(&PLAYER->actor, NA_SE_EV_CHICKEN_CRY_M);
             globalCtx->unk_11D30[0] = 1;
         }
         globalCtx->unk_11D30[1]++;
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7309);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7309);
 }
 
 // Scene Draw Config 10
-void func_8009F074(GlobalContext* globalCtx)
-{
+void func_8009F074(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7323);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7323);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, 0, 32, 32,
-                                 1, 0, 127 - gameplayFrames % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, 0, 32, 32, 1, 0, 127 - gameplayFrames % 128, 32, 32));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -3194,45 +1979,41 @@ void func_8009F074(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7339);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7339);
 }
 
 u32 D_8012A380[] = { 0x02009678, 0x0200DE78 };
 
 // Scene Draw Config 11
-void func_8009F1B4(GlobalContext* globalCtx)
-{
+void func_8009F1B4(GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
     s32 pad[2];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7363);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7363);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A380[gSaveContext.night_flag]));
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7371);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7371);
 }
 
 // Scene Draw Config 12
-void func_8009F270(GlobalContext* globalCtx)
-{
+void func_8009F270(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7385);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7385);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, gameplayFrames % 128, 32, 32,
-                                 1, 0, gameplayFrames % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, gameplayFrames % 128, 32, 32, 1, 0, gameplayFrames % 128,
+                                32, 32));
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, gameplayFrames % 128, 32, 32,
-                                 1, 0, gameplayFrames % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, gameplayFrames % 128, 32, 32, 1, 0, gameplayFrames % 128,
+                                32, 32));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -3240,28 +2021,25 @@ void func_8009F270(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7409);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7409);
 }
 
 // Scene Draw Config 13
-void func_8009F40C(GlobalContext* globalCtx)
-{
+void func_8009F40C(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7423);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7423);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 10) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 10) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 10) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 10) % 128, 32, 32));
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 3) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 3) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 3) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 3) % 128, 32, 32));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -3269,38 +2047,33 @@ void func_8009F40C(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7443);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7443);
 }
 
 // Scene Draw Config 14
-void func_8009F5D4(GlobalContext* globalCtx)
-{
+void func_8009F5D4(GlobalContext* globalCtx) {
     Gfx* displayListHead;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     displayListHead = Graph_Alloc(globalCtx->state.gfxCtx, 3 * sizeof(Gfx));
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7461);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7461);
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, displayListHead);
 
-    if ((gSaveContext.day_time >= 0x4AAC) && (gSaveContext.day_time <= 0xC000))
-    {
+    if ((gSaveContext.day_time >= 0x4AAC) && (gSaveContext.day_time <= 0xC000)) {
         gSPEndDisplayList(displayListHead);
-    }
-    else
-    {
-        if (gSaveContext.day_time > 0xC000)
-        {
-            if (globalCtx->unk_11D30[0] != 255)
+    } else {
+        if (gSaveContext.day_time > 0xC000) {
+            if (globalCtx->unk_11D30[0] != 255) {
                 Math_ApproxS(&globalCtx->unk_11D30[0], 255, 5);
-        }
-        else if (gSaveContext.day_time >= 0x4000)
-        {
-            if (globalCtx->unk_11D30[0] != 0)
+            }
+        } else if (gSaveContext.day_time >= 0x4000) {
+            if (globalCtx->unk_11D30[0] != 0) {
                 Math_ApproxS(&globalCtx->unk_11D30[0], 0, 10);
+            }
         }
 
         gDPSetPrimColor(displayListHead++, 0, 0, 0xFF, 0xFF, 0xFF, globalCtx->unk_11D30[0]);
@@ -3314,32 +2087,30 @@ void func_8009F5D4(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7495);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7495);
 }
 
 // Scene Draw Config 15
-void func_8009F7D4(GlobalContext* globalCtx)
-{
+void func_8009F7D4(GlobalContext* globalCtx) {
     s8 sp6F;
     s8 sp6E;
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     sp6F = coss((globalCtx->gameplayFrames * 1500) & 0xFFFF) >> 8;
     sp6E = coss((globalCtx->gameplayFrames * 1500) & 0xFFFF) >> 8;
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7512);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7512);
 
     gameplayFrames = globalCtx->gameplayFrames;
     sp6F = (sp6F >> 1) + 192;
     sp6E = (sp6E >> 1) + 192;
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, gameplayFrames % 128, 32, 32,
-                                 1, 0, gameplayFrames % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, gameplayFrames % 128, 32, 32, 1, 0, gameplayFrames % 128,
+                                32, 32));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, sp6F, sp6E, 0xFF, 0x80);
@@ -3347,26 +2118,24 @@ void func_8009F7D4(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7530);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7530);
 }
 
 u32 D_8012A388[] = { 0x02009808, 0x02008FC8 };
 
 // Scene Draw Config 16
-void func_8009F9D0(GlobalContext* globalCtx)
-{
+void func_8009F9D0(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7555);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7555);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, 127 - gameplayFrames % 128, 32, 32,
-                                 1, gameplayFrames % 128, 0, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, 127 - gameplayFrames % 128, 32, 32, 1,
+                                gameplayFrames % 128, 0, 32, 32));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -3378,20 +2147,19 @@ void func_8009F9D0(GlobalContext* globalCtx)
 
     { s32 pad[2]; } // Necessary to match stack usage
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7578);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7578);
 }
 
 u32 D_8012A390[] = { 0x020081E0, 0x0200FBE0 };
 
 // Scene Draw Config 17
-void func_8009FB74(GlobalContext* globalCtx)
-{
+void func_8009FB74(GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
     s32 pad[2];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7602);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7602);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A390[gSaveContext.night_flag]));
 
@@ -3401,28 +2169,26 @@ void func_8009FB74(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7615);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7615);
 }
 
 // Scene Draw Config 18
-void func_8009FC90(GlobalContext* globalCtx)
-{
+void func_8009FC90(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7630);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7630);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 0, 127 - gameplayFrames % 128, 32, 32,
-                                 1, 127 - gameplayFrames % 128, 0, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, 127 - gameplayFrames % 128, 32, 32, 1,
+                                127 - gameplayFrames % 128, 0, 32, 32));
     gSPSegment(gfxCtx->polyOpa.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, (gameplayFrames * 3) % 128, 127 - (gameplayFrames * 6) % 128, 32, 32,
-                                 1, (gameplayFrames * 6) % 128, 127 - (gameplayFrames * 3) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, (gameplayFrames * 3) % 128,
+                                127 - (gameplayFrames * 6) % 128, 32, 32, 1, (gameplayFrames * 6) % 128,
+                                127 - (gameplayFrames * 3) % 128, 32, 32));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x40);
@@ -3430,7 +2196,7 @@ void func_8009FC90(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x40);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7653);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7653);
 }
 
 f32 D_8012A398 = 0.0f;
@@ -3438,35 +2204,29 @@ f32 D_8012A398 = 0.0f;
 // Scene Draw Config 21
 #ifdef NON_MATCHING
 // regalloc differences and single equivalent instruction difference
-void func_8009FE58(GlobalContext* globalCtx)
-{
+void func_8009FE58(GlobalContext* globalCtx) {
     static s16 D_8012A39C = 538;
     static s16 D_8012A3A0 = 4272;
     u32 gameplayFrames;
     f32 temp;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7712);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7712);
 
     gameplayFrames = globalCtx->gameplayFrames;
-    if (globalCtx->sceneNum == SCENE_BDAN)
-    {
+    if (globalCtx->sceneNum == SCENE_BDAN) {
         gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-                   Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                     0, gameplayFrames % 128, (gameplayFrames * 2) % 128, 32, 32,
-                                     1, 127 - gameplayFrames % 128, (gameplayFrames * 2) % 128, 32, 32));
+                   Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, gameplayFrames % 128, (gameplayFrames * 2) % 128, 32,
+                                    32, 1, 127 - gameplayFrames % 128, (gameplayFrames * 2) % 128, 32, 32));
         gSPSegment(gfxCtx->polyOpa.p++, 0x0B,
-                   Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                     0, 0, 255 - (gameplayFrames * 4) % 256, 32, 64,
-                                     1, 0, 255 - (gameplayFrames * 4) % 256, 32, 64));
-    }
-    else
-    {
+                   Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, 255 - (gameplayFrames * 4) % 256, 32, 64, 1, 0,
+                                    255 - (gameplayFrames * 4) % 256, 32, 64));
+    } else {
         gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-                   Draw_TexScroll(globalCtx->state.gfxCtx,
-                                  (127 - (gameplayFrames * 1)) % 128, (gameplayFrames * 1) % 128, 32, 32));
+                   Gfx_TexScroll(globalCtx->state.gfxCtx, (127 - (gameplayFrames * 1)) % 128,
+                                 (gameplayFrames * 1) % 128, 32, 32));
     }
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
@@ -3475,43 +2235,32 @@ void func_8009FE58(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    if (func_800C0D28(globalCtx) != 1)
-    {
+    if (func_800C0D28(globalCtx) != 1) {
         D_8012A39C += 1820;
         D_8012A3A0 += 1820;
 
         temp = 0.020000001f;
-        func_800AA76C(&globalCtx->view,
-                      Math_Coss(D_8012A39C) * (0.00009587531f * temp),
-                      Math_Sins(D_8012A39C) * (0.00009587531f * temp),
-                      Math_Sins(D_8012A3A0) * (0.00009587531f * temp));
-        func_800AA78C(&globalCtx->view,
-                      1.0f + (Math_Sins(D_8012A3A0) * (0.79999995f * temp)),
+        func_800AA76C(&globalCtx->view, Math_Coss(D_8012A39C) * (0.00009587531f * temp),
+                      Math_Sins(D_8012A39C) * (0.00009587531f * temp), Math_Sins(D_8012A3A0) * (0.00009587531f * temp));
+        func_800AA78C(&globalCtx->view, 1.0f + (Math_Sins(D_8012A3A0) * (0.79999995f * temp)),
                       1.0f + (Math_Coss(D_8012A3A0) * (0.39999998f * temp)),
                       1.0f + (Math_Coss(D_8012A39C) * (1 * temp)));
         func_800AA7AC(&globalCtx->view, 0.95f);
 
-        switch (globalCtx->unk_11D30[0])
-        {
+        switch (globalCtx->unk_11D30[0]) {
             case 0:
                 break;
             case 1:
-                if (globalCtx->unk_11D30[1] < 1200)
-                {
+                if (globalCtx->unk_11D30[1] < 1200) {
                     globalCtx->unk_11D30[1] += 200;
-                }
-                else
-                {
+                } else {
                     globalCtx->unk_11D30[0]++;
                 }
                 break;
             case 2:
-                if (globalCtx->unk_11D30[1] > 0)
-                {
+                if (globalCtx->unk_11D30[1] > 0) {
                     globalCtx->unk_11D30[1] -= 30;
-                }
-                else
-                {
+                } else {
                     globalCtx->unk_11D30[1] = 0;
                     globalCtx->unk_11D30[0] = 0;
                 }
@@ -3521,14 +2270,15 @@ void func_8009FE58(GlobalContext* globalCtx)
         D_8012A398 += 0.15f + (globalCtx->unk_11D30[1] * 0.001f);
     }
 
-    if (globalCtx->roomCtx.curRoom.num == 2)
+    if (globalCtx->roomCtx.curRoom.num == 2) {
         Matrix_Scale(1, sinf(D_8012A398) * 0.8f, 1, MTXMODE_NEW);
-    else
+    } else {
         Matrix_Scale(1.005f, sinf(D_8012A398) * 0.8f, 1.005f, MTXMODE_NEW);
+    }
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x0D, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_scene_table.c", 7809));
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7811);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7811);
 }
 #else
 s16 D_8012A39C = 538;
@@ -3538,28 +2288,24 @@ void func_8009FE58(GlobalContext* globalCtx);
 #endif
 
 // Scene Draw Config 26
-void func_800A0334(GlobalContext* globalCtx)
-{
+void func_800A0334(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7825);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7825);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 512, 32, 128,
-                                 1, gameplayFrames % 128, (gameplayFrames * 1) % 512, 32, 128));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 512, 32,
+                                128, 1, gameplayFrames % 128, (gameplayFrames * 1) % 512, 32, 128));
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
     gSPSegment(gfxCtx->polyOpa.p++, 0x0A,
-               Draw_TwoTexScroll(globalCtx->state.gfxCtx,
-                                 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32,
-                                 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
+               Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - gameplayFrames % 128, (gameplayFrames * 1) % 128, 32,
+                                32, 1, gameplayFrames % 128, (gameplayFrames * 1) % 128, 32, 32));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -3567,38 +2313,33 @@ void func_800A0334(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7852);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7852);
 }
 
 // Scene Draw Config 52
-void func_800A055C(GlobalContext* globalCtx)
-{
+void func_800A055C(GlobalContext* globalCtx) {
     func_8009BEEC(globalCtx);
 }
 
 // Scene Draw Config 51
-void func_800A057C(GlobalContext* globalCtx)
-{
+void func_800A057C(GlobalContext* globalCtx) {
     func_8009BEEC(globalCtx);
 }
 
 // Scene Draw Config 49
-void func_800A059C(GlobalContext* globalCtx)
-{
+void func_800A059C(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7893);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7893);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
-               Draw_TexScroll(globalCtx->state.gfxCtx,
-                              127 - (gameplayFrames * 2) % 128, 0, 32, 64));
+               Gfx_TexScroll(globalCtx->state.gfxCtx, 127 - (gameplayFrames * 2) % 128, 0, 32, 64));
     gSPSegment(gfxCtx->polyOpa.p++, 0x09,
-               Draw_TexScroll(globalCtx->state.gfxCtx,
-                              0, (gameplayFrames * 2) % 512, 128, 128));
+               Gfx_TexScroll(globalCtx->state.gfxCtx, 0, (gameplayFrames * 2) % 512, 128, 128));
 
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
@@ -3606,75 +2347,26 @@ void func_800A059C(GlobalContext* globalCtx)
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7910);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7910);
 }
 
-void (*sSceneDrawHandlers[])(GlobalContext*) =
-{
-    func_80099550,
-    func_8009DA30,
-    func_8009DD5C,
-    func_8009DE78,
-    func_8009E0B8,
-    func_8009E54C,
-    func_8009E730,
-    func_8009E8C0,
-    func_8009EAD8,
-    func_8009EE44,
-    func_8009F074,
-    func_8009F1B4,
-    func_8009F270,
-    func_8009F40C,
-    func_8009F5D4,
-    func_8009F7D4,
-    func_8009F9D0,
-    func_8009FB74,
-    func_8009FC90,
-    func_800995DC,
-    func_80099878,
-    func_8009FE58,
-    func_8009D758,
-    func_8009B0FC,
-    func_8009AE30,
-    func_8009D974,
-    func_800A0334,
-    func_8009CC00,
-    func_80099760,
-    func_8009B86C,
-    func_80099BD8,
-    func_8009A45C,
-    func_8009A798,
-    func_8009A9DC,
-    func_8009B9BC,
-    func_8009BAA4,
-    func_8009BC44,
-    func_8009C3EC,
-    func_8009C0AC,
-    func_8009ACA8,
-    func_8009AFE0,
-    func_8009D0E8,
-    func_8009C608,
-    func_8009C8B8,
-    func_8009D31C,
-    func_8009D438,
-    func_8009D5B4,
-    func_8009CAC0,
-    func_8009AB98,
-    func_800A059C,
-    func_8009CF84,
-    func_800A057C,
-    func_800A055C,
+void (*sSceneDrawHandlers[])(GlobalContext*) = {
+    func_80099550, func_8009DA30, func_8009DD5C, func_8009DE78, func_8009E0B8, func_8009E54C, func_8009E730,
+    func_8009E8C0, func_8009EAD8, func_8009EE44, func_8009F074, func_8009F1B4, func_8009F270, func_8009F40C,
+    func_8009F5D4, func_8009F7D4, func_8009F9D0, func_8009FB74, func_8009FC90, func_800995DC, func_80099878,
+    func_8009FE58, func_8009D758, func_8009B0FC, func_8009AE30, func_8009D974, func_800A0334, func_8009CC00,
+    func_80099760, func_8009B86C, func_80099BD8, func_8009A45C, func_8009A798, func_8009A9DC, func_8009B9BC,
+    func_8009BAA4, func_8009BC44, func_8009C3EC, func_8009C0AC, func_8009ACA8, func_8009AFE0, func_8009D0E8,
+    func_8009C608, func_8009C8B8, func_8009D31C, func_8009D438, func_8009D5B4, func_8009CAC0, func_8009AB98,
+    func_800A059C, func_8009CF84, func_800A057C, func_800A055C,
 };
 
-void Scene_Draw(GlobalContext* globalCtx)
-{
+void Scene_Draw(GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    if (HREG(80) == 0x11)
-    {
-        if (HREG(95) != 0x11)
-        {
+    if (HREG(80) == 0x11) {
+        if (HREG(95) != 0x11) {
             HREG(95) = 0x11;
             HREG(81) = 1;
             HREG(82) = 1;
@@ -3692,19 +2384,19 @@ void Scene_Draw(GlobalContext* globalCtx)
         }
 
         gfxCtx = globalCtx->state.gfxCtx;
-        func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 8104);
+        Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 8104);
 
-        if (HREG(81) == 1)
-        {
+        if (HREG(81) == 1) {
             gSPDisplayList(gfxCtx->polyOpa.p++, sDefaultDisplayList);
             gSPDisplayList(gfxCtx->polyXlu.p++, sDefaultDisplayList);
         }
 
-        func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 8109);
+        Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 8109);
 
-        if (HREG(82) == 1)
+        if (HREG(82) == 1) {
             sSceneDrawHandlers[globalCtx->sceneConfig](globalCtx);
-    }
-    else
+        }
+    } else {
         sSceneDrawHandlers[globalCtx->sceneConfig](globalCtx);
+    }
 }
diff --git a/src/code/z_skelanime.c b/src/code/z_skelanime.c
index 9b51b29cb..099fa122e 100644
--- a/src/code/z_skelanime.c
+++ b/src/code/z_skelanime.c
@@ -1,177 +1,1760 @@
 #include <ultra64.h>
 #include <global.h>
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A08A0.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A0B40.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A0D94.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A106C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A1344.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/SkelAnime_Draw.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A180C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A1AC8.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A1D8C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A1FC8.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/SkelAnime_GetFrameCount.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A2044.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A2288.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A24A0.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A273C.s")
-
+#include <vt.h>
+
+s32 func_800A3D70(GlobalContext*, SkelAnime*);
+s32 func_800A3E0C(GlobalContext*, SkelAnime*);
+s32 func_800A4D9C(SkelAnime* skelAnime);
+s32 func_800A4EE0(SkelAnime* skelAnime);
+s32 func_800A4E38(SkelAnime* skelAnime);
+void SkelAnime_CopyVec3s(SkelAnime* skelAnime, Vec3s* dst, Vec3s* src);
+void SkelAnime_LinkAnimetionLoaded(GlobalContext* globalCtx, AnimationEntryType0* entry);
+void SkelAnime_AnimationType1Loaded(GlobalContext* globalCtx, AnimationEntryType1* entry);
+void SkelAnime_AnimationType2Loaded(GlobalContext* globalCtx, AnimationEntryType2* entry);
+void SkelAnime_AnimationType3Loaded(GlobalContext* globalCtx, AnimationEntryType3* entry);
+void SkelAnime_AnimationType4Loaded(GlobalContext* globalCtx, AnimationEntryType4* entry);
+void SkelAnime_AnimationType5Loaded(GlobalContext* globalCtx, AnimationEntryType5* entry);
+
+//.data
+u32 D_8012A480 = 0;
+static AnimationEntryCallback sAnimationLoadDone[] = {
+    &SkelAnime_LinkAnimetionLoaded,  &SkelAnime_AnimationType1Loaded, &SkelAnime_AnimationType2Loaded,
+    &SkelAnime_AnimationType3Loaded, &SkelAnime_AnimationType4Loaded, &SkelAnime_AnimationType5Loaded,
+};
+
+//.bss
+u32 D_801600B0;
+
+/*
+ * Draws the limb at `limbIndex` with a level of detail display lists index by `dListIndex`
+ */
+void SkelAnime_LodDrawLimb(GlobalContext* globalCtx, s32 limbIndex, Skeleton* skeleton, Vec3s* actorDrawTable,
+                           SkelAnime_LimbUpdateMatrix updateMtxFunc, SkelAnime_LimbAppendDlist appendDlistFunc,
+                           Actor* actor, s32 dListIndex) {
+    SkelLimbEntry* limbEntry;
+    Gfx* dList;
+    Vec3f pos;
+    Vec3s rot;
+    GraphicsContext* gfxCtx;
+    Gfx* dispRefs[4];
+
+    gfxCtx = globalCtx->state.gfxCtx;
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 773);
+    Matrix_Push();
+    limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[limbIndex]);
+    limbIndex++;
+    rot = actorDrawTable[limbIndex];
+
+    pos.x = limbEntry->translation.x;
+    pos.y = limbEntry->translation.y;
+    pos.z = limbEntry->translation.z;
+
+    dList = limbEntry->displayLists[dListIndex];
+    if ((updateMtxFunc == NULL) || (updateMtxFunc(globalCtx, limbIndex, &dList, &pos, &rot, actor) == 0)) {
+        Matrix_TranslateThenRotateZYX(&pos, &rot);
+        if (dList != NULL) {
+            do {
+                if (1) {
+                    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_skelanime.c", 805),
+                              G_MTX_LOAD);
+
+                    gSPDisplayList(gfxCtx->polyOpa.p++, dList);
+                }
+            } while (0);
+        }
+    }
+
+    if (appendDlistFunc != NULL) {
+        appendDlistFunc(globalCtx, limbIndex, &dList, &rot, actor);
+    }
+
+    if (limbEntry->firstChildIndex != LIMB_DONE) {
+        SkelAnime_LodDrawLimb(globalCtx, limbEntry->firstChildIndex, skeleton, actorDrawTable, updateMtxFunc,
+                              appendDlistFunc, actor, dListIndex);
+    }
+
+    Matrix_Pull();
+
+    if (limbEntry->nextLimbIndex != LIMB_DONE) {
+        SkelAnime_LodDrawLimb(globalCtx, limbEntry->nextLimbIndex, skeleton, actorDrawTable, updateMtxFunc,
+                              appendDlistFunc, actor, dListIndex);
+    }
+
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 821);
+}
+
+/*
+ * Draws the Skeleton described by `skeleton` with a level of detail display list indexed by `dListIndex`
+ */
+void SkelAnime_LodDraw(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actorDrawTable,
+                       SkelAnime_LimbUpdateMatrix updateMtxFunc, SkelAnime_LimbAppendDlist appendDlistFunc,
+                       Actor* actor, s32 dListIndex) {
+    SkelLimbEntry* limbEntry;
+    char pad[4];
+    Gfx* dList;
+    Vec3f pos;
+    Vec3s rot;
+    GraphicsContext* gfxCtx;
+    Gfx* dispRefs[4];
+
+    if (skeleton == NULL) {
+        osSyncPrintf(VT_FGCOL(RED));
+        osSyncPrintf("Si2_Lod_draw():skelがNULLです。\n"); // Si2_Lod_draw (): skel is NULL.
+        osSyncPrintf(VT_RST);
+        return;
+    }
+    gfxCtx = globalCtx->state.gfxCtx;
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 849);
+    Matrix_Push();
+
+    limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[0]);
+    pos.x = actorDrawTable->x;
+    pos.y = actorDrawTable->y;
+    pos.z = actorDrawTable->z;
+
+    rot = actorDrawTable[1];
+    dList = limbEntry->displayLists[dListIndex];
+
+    if ((updateMtxFunc == NULL) || (updateMtxFunc(globalCtx, 1, &dList, &pos, &rot, actor) == 0)) {
+        Matrix_TranslateThenRotateZYX(&pos, &rot);
+        if (dList != NULL) {
+            gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_skelanime.c", 881), G_MTX_LOAD);
+
+            gSPDisplayList(gfxCtx->polyOpa.p++, dList);
+        }
+    }
+    if (appendDlistFunc != NULL) {
+        appendDlistFunc(globalCtx, 1, &dList, &rot, actor);
+    }
+
+    if (limbEntry->firstChildIndex != 0xFF) {
+        SkelAnime_LodDrawLimb(globalCtx, limbEntry->firstChildIndex, skeleton, actorDrawTable, updateMtxFunc,
+                              appendDlistFunc, actor, dListIndex);
+    }
+
+    Matrix_Pull();
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 894);
+}
+
+/*
+ * Draws the limb at `limbIndex` with a level of detail display lists index by `dListIndex`, Limb matrices come
+ * from a dynamic allocation from the graph arena.
+ */
+void SkelAnime_LodDrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, Skeleton* skeleton, Vec3s* actorDrawTable,
+                             SkelAnime_LimbUpdateMatrix updateMtxFunc, SkelAnime_LimbAppendDlist appendDlistFunc,
+                             Actor* actor, s32 dListIndex, Mtx** mtx) {
+    SkelLimbEntry* limbEntry;
+    Gfx* dList[2];
+    Vec3f pos;
+    Vec3s rot;
+    GraphicsContext* gfxCtx;
+    Gfx* dispRefs[4];
+
+    Matrix_Push();
+
+    limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[limbIndex]);
+    limbIndex++;
+
+    rot = actorDrawTable[limbIndex];
+
+    pos.x = limbEntry->translation.x;
+    pos.y = limbEntry->translation.y;
+    pos.z = limbEntry->translation.z;
+    // Double assignment here would not work.
+    dList[0] = limbEntry->displayLists[dListIndex];
+    dList[1] = dList[0];
+
+    if ((updateMtxFunc == NULL) || (updateMtxFunc(globalCtx, limbIndex, &dList[1], &pos, &rot, actor) == 0)) {
+        Matrix_TranslateThenRotateZYX(&pos, &rot);
+        if (dList[1] != NULL) {
+            Matrix_ToMtx(*mtx, "../z_skelanime.c", 945);
+            gfxCtx = globalCtx->state.gfxCtx;
+            Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 946);
+            gSPMatrix(gfxCtx->polyOpa.p++, *mtx, G_MTX_LOAD);
+            gSPDisplayList(gfxCtx->polyOpa.p++, dList[1]);
+            Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 949);
+            (*mtx)++;
+        } else if (dList[0] != NULL) {
+            Matrix_ToMtx(*mtx, "../z_skelanime.c", 954);
+            (*mtx)++;
+        }
+    }
+    if (appendDlistFunc != NULL) {
+        appendDlistFunc(globalCtx, limbIndex, &dList[0], &rot, actor);
+    }
+    if (limbEntry->firstChildIndex != LIMB_DONE) {
+        SkelAnime_LodDrawLimbSV(globalCtx, limbEntry->firstChildIndex, skeleton, actorDrawTable, updateMtxFunc,
+                                appendDlistFunc, actor, dListIndex, mtx);
+    }
+
+    Matrix_Pull();
+
+    if (limbEntry->nextLimbIndex != LIMB_DONE) {
+        SkelAnime_LodDrawLimbSV(globalCtx, limbEntry->nextLimbIndex, skeleton, actorDrawTable, updateMtxFunc,
+                                appendDlistFunc, actor, dListIndex, mtx);
+    }
+}
+
+/*
+ * Draws the Skeleton described by `skeleton` with a level of detail display list indexed by `dListIndex`
+ * Matricies for the limbs are dynamically allocted from the graph arena.  The dynamic allocation occurs
+ * because the Skeleton is too large to be supported by the normal matrix stack.
+ */
+void SkelAnime_LodDrawSV(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actorDrawTable, s32 dListCount,
+                         SkelAnime_LimbUpdateMatrix updateMtxFunc, SkelAnime_LimbAppendDlist appendDlistFunc,
+                         Actor* actor, s32 dListIndex) {
+    SkelLimbEntry* limbEntry;
+    char pad[4];
+    Gfx* dList[2];
+    Vec3f pos;
+    Vec3s rot;
+    Mtx* mtx;
+    GraphicsContext* gfxCtx;
+    Gfx* dispRefs[4];
+
+    mtx = Graph_Alloc(globalCtx->state.gfxCtx, dListCount * sizeof(Mtx));
+
+    if (skeleton == NULL) {
+        osSyncPrintf(VT_FGCOL(RED));
+        osSyncPrintf("Si2_Lod_draw_SV():skelがNULLです。\n"); // Si2_Lod_draw_SV (): skel is NULL.
+        osSyncPrintf(VT_RST);
+        return;
+    }
+    gfxCtx = globalCtx->state.gfxCtx;
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1000);
+    gSPSegment(gfxCtx->polyOpa.p++, 0xD, mtx);
+    Matrix_Push();
+
+    limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[0]);
+    pos.x = actorDrawTable->x;
+    pos.y = actorDrawTable->y;
+    pos.z = actorDrawTable->z;
+
+    rot = actorDrawTable[1];
+
+    dList[0] = limbEntry->displayLists[dListIndex];
+    dList[1] = dList[0];
+
+    if ((updateMtxFunc == 0) || (updateMtxFunc(globalCtx, 1, &dList[1], &pos, &rot, actor) == 0)) {
+        Matrix_TranslateThenRotateZYX(&pos, &rot);
+        if (dList[1] != NULL) {
+            Matrix_ToMtx(mtx, "../z_skelanime.c", 1033);
+            gSPMatrix(gfxCtx->polyOpa.p++, mtx, G_MTX_LOAD);
+            gSPDisplayList(gfxCtx->polyOpa.p++, dList[1]);
+            mtx++;
+        } else if (dList[0] != NULL) {
+            Matrix_ToMtx(mtx, "../z_skelanime.c", 1040);
+            mtx++;
+        }
+    }
+
+    if (appendDlistFunc != NULL) {
+        appendDlistFunc(globalCtx, 1, &dList[0], &rot, actor);
+    }
+    if (limbEntry->firstChildIndex != LIMB_DONE) {
+        SkelAnime_LodDrawLimbSV(globalCtx, limbEntry->firstChildIndex, skeleton, actorDrawTable, updateMtxFunc,
+                                appendDlistFunc, actor, dListIndex, &mtx);
+    }
+
+    Matrix_Pull();
+
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1053);
+}
+
+/*
+ * Draws the limb of the Skeleton `skeleton` at `limbIndex`
+ */
+void SkelAnime_DrawLimb(GlobalContext* globalCtx, s32 limbIndex, Skeleton* skeleton, Vec3s* actorDrawTable,
+                        SkelAnime_LimbUpdateMatrix updateMtxFunc, SkelAnime_LimbAppendDlist appendDlistFunc,
+                        Actor* actor) {
+    SkelLimbEntry* limbEntry;
+    Gfx* dList;
+    Vec3f pos;
+    Vec3s rot;
+    GraphicsContext* gfxCtx;
+    Gfx* dispRefs[4];
+
+    gfxCtx = globalCtx->state.gfxCtx;
+
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1076);
+    Matrix_Push();
+
+    limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[limbIndex]);
+    limbIndex++;
+    rot = actorDrawTable[limbIndex];
+    pos.x = limbEntry->translation.x;
+    pos.y = limbEntry->translation.y;
+    pos.z = limbEntry->translation.z;
+    dList = limbEntry->displayLists[0];
+
+    if ((updateMtxFunc == NULL) || (updateMtxFunc(globalCtx, limbIndex, &dList, &pos, &rot, actor) == 0)) {
+        Matrix_TranslateThenRotateZYX(&pos, &rot);
+        if (dList != NULL) {
+            do {
+                if (1) {
+                    gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_skelanime.c", 1103),
+                              G_MTX_LOAD);
+                    gSPDisplayList(gfxCtx->polyOpa.p++, dList);
+                }
+            } while (0);
+        }
+    }
+
+    if (appendDlistFunc != NULL) {
+        appendDlistFunc(globalCtx, limbIndex, &dList, &rot, actor);
+    }
+
+    if (limbEntry->firstChildIndex != LIMB_DONE) {
+        SkelAnime_DrawLimb(globalCtx, limbEntry->firstChildIndex, skeleton, actorDrawTable, updateMtxFunc,
+                           appendDlistFunc, actor);
+    }
+
+    Matrix_Pull();
+
+    if (limbEntry->nextLimbIndex != LIMB_DONE) {
+        SkelAnime_DrawLimb(globalCtx, limbEntry->nextLimbIndex, skeleton, actorDrawTable, updateMtxFunc,
+                           appendDlistFunc, actor);
+    }
+
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1121);
+}
+
+void SkelAnime_Draw(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actorDrawTable,
+                    SkelAnime_LimbUpdateMatrix updateMtxFunc, SkelAnime_LimbAppendDlist appendDlistFunc, Actor* actor) {
+    SkelLimbEntry* rootLimb;
+    char pad[4];
+    Gfx* dList;
+    Vec3f pos;
+    Vec3s rot;
+    GraphicsContext* gfxCtx;
+    Gfx* dispRefs[4];
+
+    if (skeleton == NULL) {
+        osSyncPrintf(VT_FGCOL(RED));
+        osSyncPrintf("Si2_draw():skelがNULLです。\n"); // Si2_draw (): skel is NULL.
+        osSyncPrintf(VT_RST);
+        return;
+    }
+
+    gfxCtx = globalCtx->state.gfxCtx;
+
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1148);
+    Matrix_Push();
+    rootLimb = SEGMENTED_TO_VIRTUAL(skeleton->limbs[0]);
+
+    pos.x = actorDrawTable[0].x;
+    pos.y = actorDrawTable[0].y;
+    pos.z = actorDrawTable[0].z;
+
+    rot = actorDrawTable[1];
+    dList = rootLimb->displayLists[0];
+
+    if ((updateMtxFunc == NULL) || (updateMtxFunc(globalCtx, 1, &dList, &pos, &rot, actor) == 0)) {
+        Matrix_TranslateThenRotateZYX(&pos, &rot);
+        if (dList != NULL) {
+            gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_skelanime.c", 1176),
+                      G_MTX_LOAD);
+            gSPDisplayList(gfxCtx->polyOpa.p++, dList);
+        }
+    }
+
+    if (appendDlistFunc != NULL) {
+        appendDlistFunc(globalCtx, 1, &dList, &rot, actor);
+    }
+
+    if (rootLimb->firstChildIndex != LIMB_DONE) {
+        SkelAnime_DrawLimb(globalCtx, rootLimb->firstChildIndex, skeleton, actorDrawTable, updateMtxFunc,
+                           appendDlistFunc, actor);
+    }
+
+    Matrix_Pull();
+
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1190);
+}
+
+void SkelAnime_DrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, Skeleton* skeleton, Vec3s* actorDrawTable,
+                          SkelAnime_LimbUpdateMatrix updateMtxFunc, SkelAnime_LimbAppendDlist appendDlistFunc,
+                          Actor* actor, Mtx** limbMatricies) {
+    SkelLimbEntry* limbEntry;
+    Gfx* dList[2];
+    Vec3f pos;
+    Vec3s rot;
+    GraphicsContext* gfxCtx;
+    Gfx* dispRefs[4];
+
+    gfxCtx = globalCtx->state.gfxCtx;
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1214);
+    Matrix_Push();
+
+    limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[limbIndex]);
+    limbIndex++;
+    rot = actorDrawTable[limbIndex];
+
+    pos.x = limbEntry->translation.x;
+    pos.y = limbEntry->translation.y;
+    pos.z = limbEntry->translation.z;
+
+    dList[0] = limbEntry->displayLists[0];
+    dList[1] = dList[0];
+
+    if ((updateMtxFunc == NULL) || (updateMtxFunc(globalCtx, limbIndex, &dList[1], &pos, &rot, actor) == 0)) {
+        Matrix_TranslateThenRotateZYX(&pos, &rot);
+        if (dList[1] != NULL) {
+            Matrix_ToMtx(*limbMatricies, "../z_skelanime.c", 1242);
+            gSPMatrix(gfxCtx->polyOpa.p++, *limbMatricies, G_MTX_LOAD);
+            gSPDisplayList(gfxCtx->polyOpa.p++, dList[1]);
+            (*limbMatricies)++;
+        } else if (dList[0] != NULL) {
+            Matrix_ToMtx(*limbMatricies, "../z_skelanime.c", 1249);
+            (*limbMatricies)++;
+        }
+    }
+
+    if (appendDlistFunc != NULL) {
+        appendDlistFunc(globalCtx, limbIndex, &dList[0], &rot, actor);
+    }
+
+    if (limbEntry->firstChildIndex != LIMB_DONE) {
+        SkelAnime_DrawLimbSV(globalCtx, limbEntry->firstChildIndex, skeleton, actorDrawTable, updateMtxFunc,
+                             appendDlistFunc, actor, limbMatricies);
+    }
+
+    Matrix_Pull();
+
+    if (limbEntry->nextLimbIndex != LIMB_DONE) {
+        SkelAnime_DrawLimbSV(globalCtx, limbEntry->nextLimbIndex, skeleton, actorDrawTable, updateMtxFunc,
+                             appendDlistFunc, actor, limbMatricies);
+    }
+
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1265);
+}
+
+void SkelAnime_DrawSV(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actorDrawTable, s32 dListCount,
+                      SkelAnime_LimbUpdateMatrix updateMtxFunc, SkelAnime_LimbAppendDlist appendDlistFunc,
+                      Actor* actor) {
+    SkelLimbEntry* limbEntry;
+    char pad[4];
+    Gfx* dList[2];
+    Vec3f pos;
+    Vec3s rot;
+    Mtx* mtx;
+    GraphicsContext* gfxCtx;
+    Gfx* dispRefs[4];
+
+    mtx = Graph_Alloc(globalCtx->state.gfxCtx, dListCount * sizeof(Mtx));
+
+    if (skeleton == NULL) {
+        osSyncPrintf(VT_FGCOL(RED));
+        osSyncPrintf("Si2_draw_SV():skelがNULLです。\n"); // Si2_draw_SV (): skel is NULL.
+        osSyncPrintf(VT_RST);
+        return;
+    }
+
+    gfxCtx = globalCtx->state.gfxCtx;
+
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1294);
+
+    gSPSegment(gfxCtx->polyOpa.p++, 0xD, mtx);
+
+    Matrix_Push();
+
+    limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[0]);
+
+    pos.x = actorDrawTable->x;
+    pos.y = actorDrawTable->y;
+    pos.z = actorDrawTable->z;
+
+    rot = actorDrawTable[1];
+
+    dList[0] = limbEntry->displayLists[0];
+    dList[1] = dList[0];
+
+    if ((updateMtxFunc == NULL) || (updateMtxFunc(globalCtx, 1, &dList[1], &pos, &rot, actor) == 0)) {
+        Matrix_TranslateThenRotateZYX(&pos, &rot);
+        if (dList[1] != NULL) {
+            Matrix_ToMtx(mtx, "../z_skelanime.c", 1327);
+            gSPMatrix(gfxCtx->polyOpa.p++, mtx, G_MTX_LOAD);
+            gSPDisplayList(gfxCtx->polyOpa.p++, dList[1]);
+            mtx++;
+        } else {
+            if (dList[0] != NULL) {
+                Matrix_ToMtx(mtx, "../z_skelanime.c", 1334);
+                mtx++;
+            }
+        }
+    }
+
+    if (appendDlistFunc != NULL) {
+        appendDlistFunc(globalCtx, 1, &dList[0], &rot, actor);
+    }
+
+    if (limbEntry->firstChildIndex != LIMB_DONE) {
+        SkelAnime_DrawLimbSV(globalCtx, limbEntry->firstChildIndex, skeleton, actorDrawTable, updateMtxFunc,
+                             appendDlistFunc, actor, &mtx);
+    }
+
+    Matrix_Pull();
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1347);
+}
+
+/*
+ * Copies the rotation values from the rotation value table, indexed by the rotation index table
+ * When a rotation index is >= the animation limit, the output rotation value is copied from the frame's
+ * rotation value list, otherwise it is copied from the initial rotation value list
+ */
+void SkelAnime_AnimateFrame(AnimationHeader* animationSeg, s32 currentFrame, s32 limbCount, Vec3s* dst) {
+    AnimationRotationIndex* index;
+    AnimationRotationValue* rotationValueTable;
+    AnimationRotationValue* frameRotationValueTable;
+    AnimationHeader* animationHeader;
+
+    s32 i;
+    u16 limit;
+
+    animationHeader = SEGMENTED_TO_VIRTUAL(animationSeg);
+    index = SEGMENTED_TO_VIRTUAL(animationHeader->rotationIndexSeg);
+    rotationValueTable = SEGMENTED_TO_VIRTUAL(animationHeader->rotationValueSeg);
+    frameRotationValueTable = &rotationValueTable[currentFrame];
+    limit = animationHeader->limit;
+
+    for (i = 0; i < limbCount; i++, dst++, index++) {
+        if ((dst == NULL) || (index == NULL) || (frameRotationValueTable == NULL) || (rotationValueTable == NULL)) {
+            if (1) {} // Necessary to match.
+            LOG_ADDRESS("out", dst, "../z_skelanime.c", 1392);
+            LOG_ADDRESS("ref_tbl", index, "../z_skelanime.c", 1393);
+            LOG_ADDRESS("frame_tbl", frameRotationValueTable, "../z_skelanime.c", 1394);
+            LOG_ADDRESS("tbl", rotationValueTable, "../z_skelanime.c", 1395);
+        }
+
+        dst->x = index->x >= limit ? frameRotationValueTable[index->x] : rotationValueTable[index->x];
+        dst->y = index->y >= limit ? frameRotationValueTable[index->y] : rotationValueTable[index->y];
+        dst->z = index->z >= limit ? frameRotationValueTable[index->z] : rotationValueTable[index->z];
+    }
+}
+
+s16 SkelAnime_GetTotalFrames(GenericAnimationHeader* animationSeg) {
+    GenericAnimationHeader* animation = SEGMENTED_TO_VIRTUAL(animationSeg);
+    return animation->frameCount;
+}
+
+s16 SkelAnime_GetFrameCount(GenericAnimationHeader* animationSeg) {
+    GenericAnimationHeader* animation = SEGMENTED_TO_VIRTUAL(animationSeg);
+    // Loads an unsigned half for some reason.
+    return (u16)animation->frameCount - 1;
+}
+
+/*
+ * Draws the Skeleton `skeleton`'s limb at index `limbIndex`.  Appends all generated graphics commands to
+ * `gfx`.  Returns a pointer to the next gfx to be appended to.
+ */
+Gfx* SkelAnime_Draw2Limb(GlobalContext* globalCtx, s32 limbIndex, Skeleton* skeleton, Vec3s* actorDrawTable,
+                         SkelAnime_LimbUpdateMatrix2 updateMtxFunc, SkelAnime_LimbAppendDlist2 appendDlistFunc,
+                         Actor* actor, Gfx* gfx) {
+    SkelLimbEntry* limbEntry;
+    Gfx* dList;
+    Vec3f pos;
+    Vec3s rot;
+
+    Matrix_Push();
+
+    limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[limbIndex]);
+    limbIndex++;
+
+    rot = actorDrawTable[limbIndex];
+
+    pos.x = limbEntry->translation.x;
+    pos.y = limbEntry->translation.y;
+    pos.z = limbEntry->translation.z;
+
+    dList = limbEntry->displayLists[0];
+
+    if ((updateMtxFunc == NULL) || (updateMtxFunc(globalCtx, limbIndex, &dList, &pos, &rot, actor, &gfx) == 0)) {
+        Matrix_TranslateThenRotateZYX(&pos, &rot);
+        if (dList != NULL) {
+            gSPMatrix(gfx++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_skelanime.c", 1489), G_MTX_LOAD);
+            gSPDisplayList(gfx++, dList);
+        }
+    }
+
+    if (appendDlistFunc != NULL) {
+        appendDlistFunc(globalCtx, limbIndex, &dList, &rot, actor, &gfx);
+    }
+
+    if (limbEntry->firstChildIndex != LIMB_DONE) {
+        gfx = SkelAnime_Draw2Limb(globalCtx, limbEntry->firstChildIndex, skeleton, actorDrawTable, updateMtxFunc,
+                                  appendDlistFunc, actor, gfx);
+    }
+
+    Matrix_Pull();
+
+    if (limbEntry->nextLimbIndex != LIMB_DONE) {
+        gfx = SkelAnime_Draw2Limb(globalCtx, limbEntry->nextLimbIndex, skeleton, actorDrawTable, updateMtxFunc,
+                                  appendDlistFunc, actor, gfx);
+    }
+
+    return gfx;
+}
+
+/*
+ * Draws the Skeleton `skeleton`  Appends all generated graphics to `gfx`, and returns a pointer to the
+ * next gfx to be appended to.
+ */
+Gfx* SkelAnime_Draw2(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actorDrawTable,
+                     SkelAnime_LimbUpdateMatrix2 updateMtxFunc, SkelAnime_LimbAppendDlist2 appendDlistFunc,
+                     Actor* actor, Gfx* gfx) {
+    SkelLimbEntry* limbEntry;
+    char pad[4];
+    Gfx* dList;
+    Vec3f pos;
+    Vec3s rot;
+
+    if (skeleton == NULL) {
+        osSyncPrintf(VT_FGCOL(RED));
+        osSyncPrintf("Si2_draw2():skelがNULLです。NULLを返します。\n"); // Si2_draw2 (): skel is NULL. Returns NULL.
+        osSyncPrintf(VT_RST);
+        return NULL;
+    }
+
+    Matrix_Push();
+
+    limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[0]);
+
+    pos.x = actorDrawTable->x;
+    pos.y = actorDrawTable->y;
+    pos.z = actorDrawTable->z;
+
+    rot = actorDrawTable[1];
+
+    dList = limbEntry->displayLists[0];
+
+    if ((updateMtxFunc == NULL) || (updateMtxFunc(globalCtx, 1, &dList, &pos, &rot, actor, &gfx) == 0)) {
+        Matrix_TranslateThenRotateZYX(&pos, &rot);
+        if (dList != NULL) {
+            gSPMatrix(gfx++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_skelanime.c", 1558), G_MTX_LOAD);
+            gSPDisplayList(gfx++, dList);
+        }
+    }
+
+    if (appendDlistFunc != NULL) {
+        appendDlistFunc(globalCtx, 1, &dList, &rot, actor, &gfx);
+    }
+
+    if (limbEntry->firstChildIndex != LIMB_DONE) {
+        gfx = SkelAnime_Draw2Limb(globalCtx, limbEntry->firstChildIndex, skeleton, actorDrawTable, updateMtxFunc,
+                                  appendDlistFunc, actor, gfx);
+    }
+
+    Matrix_Pull();
+
+    return gfx;
+}
+
+Gfx* SkelAnime_DrawLimbSV2(GlobalContext* globalCtx, s32 limbIndex, Skeleton* skeleton, Vec3s* actorDrawTable,
+                           SkelAnime_LimbUpdateMatrix2 updateMtxFunc, SkelAnime_LimbAppendDlist2 appendDlistFunc,
+                           Actor* actor, Mtx** mtx, Gfx* gfx) {
+    SkelLimbEntry* limbEntry;
+    Gfx* dList1;
+    Gfx* dList2;
+    Vec3f pos;
+    Vec3s rot;
+    char pad[4];
+
+    Matrix_Push();
+
+    limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[limbIndex]);
+    limbIndex++;
+    rot = actorDrawTable[limbIndex];
+
+    pos.x = limbEntry->translation.x;
+    pos.y = limbEntry->translation.y;
+    pos.z = limbEntry->translation.z;
+
+    dList1 = dList2 = limbEntry->displayLists[0];
+    if ((updateMtxFunc == NULL) || (updateMtxFunc(globalCtx, limbIndex, &dList1, &pos, &rot, actor, &gfx) == 0)) {
+        Matrix_TranslateThenRotateZYX(&pos, &rot);
+        if (dList1 != NULL) {
+            Matrix_ToMtx(*mtx, "../z_skelanime.c", 1623);
+            gSPMatrix(gfx++, *mtx, G_MTX_LOAD);
+            gSPDisplayList(gfx++, dList1);
+            (*mtx)++;
+        } else {
+            if (dList2 != NULL) {
+                Matrix_ToMtx(*mtx, "../z_skelanime.c", 1630);
+                (*mtx)++;
+            }
+        }
+    }
+    if (appendDlistFunc != NULL) {
+        appendDlistFunc(globalCtx, limbIndex, &dList2, &rot, actor, &gfx);
+    }
+    if (limbEntry->firstChildIndex != LIMB_DONE) {
+        gfx = SkelAnime_DrawLimbSV2(globalCtx, limbEntry->firstChildIndex, skeleton, actorDrawTable, updateMtxFunc,
+                                    appendDlistFunc, actor, mtx, gfx);
+    }
+
+    Matrix_Pull();
+
+    if (limbEntry->nextLimbIndex != LIMB_DONE) {
+        gfx = SkelAnime_DrawLimbSV2(globalCtx, limbEntry->nextLimbIndex, skeleton, actorDrawTable, updateMtxFunc,
+                                    appendDlistFunc, actor, mtx, gfx);
+    }
+
+    return gfx;
+}
+
+/*
+ * Draws the Skeleton `skeleton`  Appends all generated graphics to `gfx`, and returns a pointer to the
+ * next gfx to be appended to.  Allocates matricies for display lists on the graph heap.
+ */
+Gfx* SkelAnime_DrawSV2(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actorDrawTable, s32 dListCount,
+                       SkelAnime_LimbUpdateMatrix2 updateMtxFunc, SkelAnime_LimbAppendDlist2 appendDlistFunc,
+                       Actor* actor, Gfx* gfx) {
+    SkelLimbEntry* limbEntry;
+    char pad[4];
+    Gfx* dList1;
+    Gfx* dList2;
+    Vec3f pos;
+    Vec3s rot;
+    Mtx* mtx;
+
+    mtx = Graph_Alloc(globalCtx->state.gfxCtx, dListCount * sizeof(*mtx));
+    if (skeleton == NULL) {
+        osSyncPrintf(VT_FGCOL(RED));
+        osSyncPrintf(
+            "Si2_draw2_SV():skelがNULLです。NULLを返します。\n"); // Si2_draw2_SV (): skel is NULL. Returns NULL.
+        osSyncPrintf(VT_RST);
+        return NULL;
+    }
+
+    gSPSegment(gfx++, 0xD, mtx);
+    Matrix_Push();
+    limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[0]);
+
+    pos.x = actorDrawTable->x;
+    pos.y = actorDrawTable->y;
+    pos.z = actorDrawTable->z;
+
+    rot = actorDrawTable[1];
+
+    dList1 = dList2 = limbEntry->displayLists[0];
+
+    if ((updateMtxFunc == NULL) || (updateMtxFunc(globalCtx, 1, &dList1, &pos, &rot, actor, &gfx) == 0)) {
+        Matrix_TranslateThenRotateZYX(&pos, &rot);
+        if (dList1 != NULL) {
+            Matrix_ToMtx(mtx, "../z_skelanime.c", 1710);
+            gSPMatrix(gfx++, mtx, G_MTX_LOAD);
+            gSPDisplayList(gfx++, dList1);
+            mtx++;
+        } else {
+            if (dList2 != NULL) {
+                Matrix_ToMtx(mtx, "../z_skelanime.c", 1717);
+                mtx++;
+            }
+        }
+    }
+    if (appendDlistFunc != NULL) {
+        appendDlistFunc(globalCtx, 1, &dList2, &rot, actor, &gfx);
+    }
+    if (limbEntry->firstChildIndex != LIMB_DONE) {
+        gfx = SkelAnime_DrawLimbSV2(globalCtx, limbEntry->firstChildIndex, skeleton, actorDrawTable, updateMtxFunc,
+                                    appendDlistFunc, actor, &mtx, gfx);
+    }
+
+    Matrix_Pull();
+
+    return gfx;
+}
+
+#ifdef NON_MATCHING
+// Function is unused.  This is functionally equivilent, misplace andi which caused regalloc
+s32 func_800A29BC(s32 arg0, s32 arg1, Vec3s* arg2) {
+    s16* temp_t1;
+    s16* temp_a3;
+    AnimationHeader* temp_v0;
+    s32 phi_v0;
+    s32 t;
+
+    temp_v0 = SEGMENTED_TO_VIRTUAL(arg0);
+    t = temp_v0->genericHeader.unk_02;
+    temp_a3 = SEGMENTED_TO_VIRTUAL(temp_v0->rotationIndexSeg);
+    temp_t1 = SEGMENTED_TO_VIRTUAL(temp_v0->rotationValueSeg);
+
+    arg2->x = arg1 < temp_a3[0] ? ((s16*)((arg1 * 2) + (u32)temp_t1))[temp_a3[1]] : temp_t1[temp_a3[1]];
+    arg2->y = arg1 < temp_a3[2] ? ((s16*)((arg1 * 2) + (u32)temp_t1))[temp_a3[3]] : temp_t1[temp_a3[3]];
+    arg2->z = arg1 < temp_a3[4] ? ((s16*)((arg1 * 2) + (u32)temp_t1))[temp_a3[5]] : temp_t1[temp_a3[5]];
+
+    phi_v0 = 1;
+    arg2++;
+    temp_a3 += 6;
+
+    if (t > 0) {
+        if (t & 1) {
+            phi_v0++;
+            arg2->x = arg1 < temp_a3[0] ? ((s16*)((arg1 * 2) + (u32)temp_t1))[temp_a3[1]] : temp_t1[temp_a3[1]];
+            arg2->y = arg1 < temp_a3[2] ? ((s16*)((arg1 * 2) + (u32)temp_t1))[temp_a3[3]] : temp_t1[temp_a3[3]];
+            arg2->z = arg1 < temp_a3[4] ? ((s16*)((arg1 * 2) + (u32)temp_t1))[temp_a3[5]] : temp_t1[temp_a3[5]];
+            temp_a3 += 6;
+            arg2++;
+            if (t + 1 == phi_v0) {
+                goto ret;
+            }
+        }
+        do {
+            phi_v0 += 2;
+            arg2->x = arg1 < temp_a3[0] ? ((s16*)((arg1 * 2) + (u32)temp_t1))[temp_a3[1]] : temp_t1[temp_a3[1]];
+            arg2->y = arg1 < temp_a3[2] ? ((s16*)((arg1 * 2) + (u32)temp_t1))[temp_a3[3]] : temp_t1[temp_a3[3]];
+            arg2->z = arg1 < temp_a3[4] ? ((s16*)((arg1 * 2) + (u32)temp_t1))[temp_a3[5]] : temp_t1[temp_a3[5]];
+            temp_a3 += 6;
+            arg2++;
+            arg2->x = arg1 < temp_a3[0] ? ((s16*)((arg1 * 2) + (u32)temp_t1))[temp_a3[1]] : temp_t1[temp_a3[1]];
+            arg2->y = arg1 < temp_a3[2] ? ((s16*)((arg1 * 2) + (u32)temp_t1))[temp_a3[3]] : temp_t1[temp_a3[3]];
+            arg2->z = arg1 < temp_a3[4] ? ((s16*)((arg1 * 2) + (u32)temp_t1))[temp_a3[5]] : temp_t1[temp_a3[5]];
+            temp_a3 += 6;
+            arg2++;
+        } while (phi_v0 != t + 1);
+    }
+ret:
+    return t;
+}
+#else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A29BC.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A2DBC.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A2DF4.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A2E2C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A2E70.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A32EC.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A32F4.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A3310.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A3334.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A336C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A3478.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A34DC.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A3548.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A35B4.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A3620.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A3678.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A36A4.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A3714.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A3770.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A37F0.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A3874.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A390C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A39AC.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A3B8C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A3BC0.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A3BE4.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A3C9C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A3D70.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A3E0C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A3EE8.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A3F08.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A407C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A40DC.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A4140.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A419C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A41FC.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A422C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A425C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A42A0.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A42E4.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A431C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A43B8.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A4454.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A4478.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A4530.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/SkelAnime_Init.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A46F8.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A487C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A49B0.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/SkelAnime_FrameUpdateMatrix.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A4A20.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A4AD8.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A4C58.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A4D9C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A4E38.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A4EE0.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A4FE4.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/SkelAnime_ChangeAnimation.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A51E8.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A5240.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A529C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A52F8.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A534C.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A5384.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A53DC.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A5408.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A5428.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A5490.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A54FC.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A56C8.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A56F0.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_800A5774.s")
-
+#endif
+
+s16 func_800A2DBC(GenericAnimationHeader* animationSeg) {
+    GenericAnimationHeader* animation = SEGMENTED_TO_VIRTUAL(animationSeg);
+
+    return animation->unk_02;
+}
+
+/*
+ * Appears to be unused anywhere in the game.  Appears to be a clone of
+ * SkelAnime_GetTotalFrames
+ */
+s16 SkelAnime_GetTotalFrames2(GenericAnimationHeader* animationSeg) {
+    GenericAnimationHeader* animation = SEGMENTED_TO_VIRTUAL(animationSeg);
+
+    return animation->frameCount;
+}
+
+/*
+ * Appears to be unused anywhere in the game.  Appears to be a clone of
+ * SkelAnime_GetFrameCount
+ */
+s16 SkelAnime_GetFrameCount2(GenericAnimationHeader* animationSeg) {
+    GenericAnimationHeader* animation = SEGMENTED_TO_VIRTUAL(animationSeg);
+
+    return animation->frameCount - 1;
+}
+
+void SkelAnime_InterpolateVec3s(s32 limbCount, Vec3s* dst, Vec3s* vec2, Vec3s* vec3, f32 unkf) {
+    s32 i;
+    s16 dist;
+    s16 temp2;
+
+    if (unkf < 1.0f) {
+        for (i = 0; i < limbCount; i++, dst++, vec2++, vec3++) {
+            temp2 = vec2->x;
+            dist = vec3->x - temp2;
+            dst->x = (s16)(dist * unkf) + temp2;
+            temp2 = vec2->y;
+            dist = vec3->y - temp2;
+            dst->y = (s16)(dist * unkf) + temp2;
+            temp2 = vec2->z;
+            dist = vec3->z - temp2;
+            dst->z = (s16)(dist * unkf) + temp2;
+        }
+    } else {
+        for (i = 0; i < limbCount; i++, dst++, vec3++) {
+            dst->x = vec3->x;
+            dst->y = vec3->y;
+            dst->z = vec3->z;
+        }
+    }
+}
+
+void SkelAnime_AnimationCtxReset(AnimationContext* animationCtx) {
+    animationCtx->animationCount = 0;
+}
+
+void func_800A32F4(GlobalContext* globalCtx) {
+    D_801600B0 <<= 1;
+}
+
+void func_800A3310(GlobalContext* globalCtx) {
+    u32* D_8012A480Ptr = &D_8012A480;
+
+    *D_8012A480Ptr |= D_801600B0;
+}
+
+AnimationEntry* SkelAnime_NextEntry(AnimationContext* animationCtx, AnimationType type) {
+    AnimationEntry* entry;
+    s16 index = animationCtx->animationCount;
+
+    if (index >= ANIMATION_ENTRY_MAX) {
+        return NULL;
+    }
+    animationCtx->animationCount = index + 1;
+    entry = &animationCtx->entries[index];
+    entry->type = type;
+    return entry;
+}
+
+/*
+ * The next 6 functions are coordinate with the AnimationType enum
+ */
+
+void SkelAnime_LoadLinkAnimetion(GlobalContext* globalCtx, LinkAnimetionEntry* linkAnimetionSeg, s32 frame,
+                                 s32 limbCount, void* ram) {
+    AnimationEntry* entry;
+    LinkAnimetionEntry* linkAnimetionEntry;
+    char pad[4];
+
+    entry = SkelAnime_NextEntry(&globalCtx->animationCtx, ANIMATION_LINKANIMETION);
+
+    if (entry != NULL) {
+        linkAnimetionEntry = SEGMENTED_TO_VIRTUAL(linkAnimetionSeg);
+        osCreateMesgQueue(&entry->types.type0.msgQueue, &entry->types.type0.msg, 1);
+        DmaMgr_SendRequest2(
+            &entry->types.type0.req, ram,
+            LINK_ANIMETION_OFFSET(linkAnimetionEntry->animationSegAddress, ((sizeof(Vec3s) * limbCount + 2) * frame)),
+            sizeof(Vec3s) * limbCount + 2, 0, &entry->types.type0.msgQueue, NULL, "../z_skelanime.c", 2004);
+    }
+}
+
+void SkelAnime_LoadAnimationType1(GlobalContext* globalCtx, s32 vecCount, Vec3s* dst, Vec3s* src) {
+    AnimationEntry* entry = SkelAnime_NextEntry(&globalCtx->animationCtx, ANIMATION_TYPE1);
+    if (entry != NULL) {
+        entry->types.type1.unk_00 = D_801600B0;
+        entry->types.type1.vecCount = vecCount;
+        entry->types.type1.dst = dst;
+        entry->types.type1.src = src;
+    }
+}
+
+void SkelAnime_LoadAnimationType2(GlobalContext* globalCtx, s32 limbCount, Vec3s* arg2, Vec3s* arg3, f32 arg4) {
+    AnimationEntry* entry = SkelAnime_NextEntry(&globalCtx->animationCtx, ANIMATION_TYPE2);
+    if (entry != NULL) {
+        entry->types.type2.unk_00 = D_801600B0;
+        entry->types.type2.limbCount = limbCount;
+        entry->types.type2.unk_04 = arg2;
+        entry->types.type2.unk_08 = arg3;
+        entry->types.type2.unk_0C = arg4;
+    }
+}
+
+void SkelAnime_LoadAnimationType3(GlobalContext* globalCtx, s32 vecCount, Vec3s* dst, Vec3s* src, u8* index) {
+    AnimationEntry* entry = SkelAnime_NextEntry(&globalCtx->animationCtx, ANIMATION_TYPE3);
+    if (entry != NULL) {
+        entry->types.type3.unk_00 = D_801600B0;
+        entry->types.type3.vecCount = vecCount;
+        entry->types.type3.dst = dst;
+        entry->types.type3.src = src;
+        entry->types.type3.index = index;
+    }
+}
+
+void SkelAnime_LoadAnimationType4(GlobalContext* globalCtx, s32 vecCount, Vec3s* dst, Vec3s* src, u8* index) {
+    AnimationEntry* entry = SkelAnime_NextEntry(&globalCtx->animationCtx, ANIMATION_TYPE4);
+    if (entry != NULL) {
+        entry->types.type4.unk_00 = D_801600B0;
+        entry->types.type4.vecCount = vecCount;
+        entry->types.type4.dst = dst;
+        entry->types.type4.src = src;
+        entry->types.type4.index = index;
+    }
+}
+
+void SkelAnime_LoadAnimationType5(GlobalContext* globalCtx, Actor* actor, SkelAnime* skelAnime, f32 arg3) {
+    AnimationEntry* entry = SkelAnime_NextEntry(&globalCtx->animationCtx, ANIMATION_TYPE5);
+    if (entry != NULL) {
+        entry->types.type5.actor = actor;
+        entry->types.type5.skelAnime = skelAnime;
+        entry->types.type5.unk_08 = arg3;
+    }
+}
+
+/* The next functions are callbacks to loading animations */
+
+void SkelAnime_LinkAnimetionLoaded(GlobalContext* globalCtx, AnimationEntryType0* entry) {
+    osRecvMesg(&entry->msgQueue, NULL, OS_MESG_BLOCK);
+}
+
+void SkelAnime_AnimationType1Loaded(GlobalContext* globalCtx, AnimationEntryType1* entry) {
+    s32 i;
+    Vec3s* dst;
+    Vec3s* src;
+    AnimationEntryRaw* genericEntry = (AnimationEntryRaw*)entry;
+
+    if ((genericEntry->raw[0] & D_8012A480) != 0) {
+        return;
+    }
+
+    for (dst = entry->dst, src = entry->src, i = 0; i < genericEntry->raw[1]; i++) {
+        *dst++ = *src++;
+    }
+}
+
+void SkelAnime_AnimationType2Loaded(GlobalContext* globalCtx, AnimationEntryType2* entry) {
+    if ((entry->unk_00 & D_8012A480) == 0) {
+        SkelAnime_InterpolateVec3s(entry->limbCount, entry->unk_04, entry->unk_04, entry->unk_08, entry->unk_0C);
+    }
+}
+
+void SkelAnime_AnimationType3Loaded(GlobalContext* globalCtx, AnimationEntryType3* entry) {
+    s32 i;
+    Vec3s* dst;
+    Vec3s* src;
+    u8* index;
+    AnimationEntryRaw* rawEntry = (AnimationEntryRaw*)entry;
+
+    if ((rawEntry->raw[0] & D_8012A480) == 0) {
+        for (dst = entry->dst, src = entry->src, index = entry->index, i = 0; i < rawEntry->raw[1]; i++, dst++, src++) {
+            if (*index++) {
+                *dst = *src;
+            }
+        }
+    }
+}
+
+void SkelAnime_AnimationType4Loaded(GlobalContext* globalCtx, AnimationEntryType4* entry) {
+    s32 i;
+    Vec3s* dst;
+    Vec3s* src;
+    u8* index;
+    AnimationEntryRaw* rawEntry = (AnimationEntryRaw*)entry;
+
+    if ((rawEntry->raw[0] & D_8012A480) == 0) {
+        for (dst = entry->dst, src = entry->src, index = entry->index, i = 0; i < rawEntry->raw[1]; i++, dst++, src++) {
+            if (*index++ < 1U) {
+                *dst = *src;
+            }
+        }
+    }
+}
+
+void SkelAnime_AnimationType5Loaded(GlobalContext* globalCtx, AnimationEntryType5* entry) {
+    char pad[4];
+    Actor* actor = entry->actor;
+    Vec3f pos;
+
+    func_800A54FC(entry->skelAnime, &pos, actor->shape.rot.y);
+    actor->posRot.pos.x += pos.x * actor->scale.x;
+    actor->posRot.pos.y += pos.y * actor->scale.y * entry->unk_08;
+    actor->posRot.pos.z += pos.z * actor->scale.z;
+}
+
+void func_800A390C(GlobalContext* globalCtx, AnimationContext* animationCtx) {
+    AnimationEntry* entry;
+
+    for (entry = animationCtx->entries; animationCtx->animationCount != 0; entry++, animationCtx->animationCount--) {
+        sAnimationLoadDone[entry->type](globalCtx, &entry->types);
+    }
+
+    D_801600B0 = 1;
+    D_8012A480 = 0;
+}
+
+void SkelAnime_InitLinkAnimetion(GlobalContext* globalCtx, SkelAnime* skelAnime, SkeletonHeader* skeletonHeaderSeg,
+                                 LinkAnimetionEntry* linkAnimetionEntrySeg, s32 flags, Vec3s* actorDrawTbl,
+                                 Vec3s* transitionDrawTbl, s32 limbBufCount) {
+    char pad[8];
+    SkeletonHeader* skeletonHeader;
+    size_t allocSize;
+    s32 limbCount;
+    s32 headerCount;
+
+    skeletonHeader = SEGMENTED_TO_VIRTUAL(skeletonHeaderSeg);
+    headerCount = skeletonHeader->limbCount;
+    skelAnime->initFlags = flags;
+    limbCount = (flags & 2) ? headerCount : 1;
+
+    if (flags & 1) {
+        limbCount += headerCount;
+    }
+    if (flags & 4) {
+        limbCount += headerCount;
+    }
+
+    skelAnime->limbCount = limbCount;
+    skelAnime->dListCount = skeletonHeader->dListCount;
+
+    allocSize = limbCount * sizeof(Vec3s);
+    skelAnime->skeleton = SEGMENTED_TO_VIRTUAL(skeletonHeader->skeletonSeg);
+
+    if (flags & 8) {
+        allocSize += 2;
+    }
+
+    if (actorDrawTbl == NULL) {
+        skelAnime->actorDrawTbl = ZeldaArena_MallocDebug(allocSize, "../z_skelanime.c", 2364);
+        skelAnime->transitionDrawTbl = ZeldaArena_MallocDebug(allocSize, "../z_skelanime.c", 2365);
+    } else {
+        if (limbBufCount != limbCount) {
+            __assert("joint_buff_num == joint_num", "../z_skelanime.c", 2369);
+        }
+
+        skelAnime->actorDrawTbl = (Vec3s*)ALIGN16((u32)actorDrawTbl);
+        skelAnime->transitionDrawTbl = (Vec3s*)ALIGN16((u32)transitionDrawTbl);
+    }
+
+    if ((skelAnime->actorDrawTbl == NULL) || (skelAnime->transitionDrawTbl == NULL)) {
+        osSyncPrintf(VT_FGCOL(RED));
+        osSyncPrintf(
+            "Skeleton_Info_Rom_SV_ct メモリアロケーションエラー\n"); // Skeleton_Info_Rom_SV_ct Memory allocation error
+        osSyncPrintf(VT_RST);
+    }
+
+    SkelAnime_ChangeLinkAnim(globalCtx, skelAnime, linkAnimetionEntrySeg, 1.0f, 0.0f, 0.0f, 0, 0.0f);
+}
+
+void func_800A3B8C(SkelAnime* skelAnime) {
+    if (skelAnime->mode < 2) {
+        skelAnime->animUpdate = &func_800A3D70;
+    } else {
+        skelAnime->animUpdate = &func_800A3E0C;
+    }
+    skelAnime->transCurrentFrame = 0.0f;
+}
+
+s32 func_800A3BC0(GlobalContext* globalCtx, SkelAnime* skelAnime) {
+    return skelAnime->animUpdate(globalCtx, skelAnime);
+}
+
+s32 func_800A3BE4(GlobalContext* globalCtx, SkelAnime* skelAnime) {
+    f32 prevUnk28 = skelAnime->transCurrentFrame;
+    f32 updateRate = R_UPDATE_RATE * 0.5f;
+
+    skelAnime->transCurrentFrame -= skelAnime->transitionStep * updateRate;
+
+    if (skelAnime->transCurrentFrame <= 0.0f) {
+        func_800A3B8C(skelAnime);
+    }
+
+    SkelAnime_LoadAnimationType2(globalCtx, skelAnime->limbCount, skelAnime->actorDrawTbl, skelAnime->transitionDrawTbl,
+                                 1.0f - (skelAnime->transCurrentFrame / prevUnk28));
+    return 0;
+}
+
+void func_800A3C9C(GlobalContext* globalCtx, SkelAnime* skelAnime) {
+    f32 updateRate;
+
+    SkelAnime_LoadLinkAnimetion(globalCtx, skelAnime->linkAnimetionSeg, skelAnime->animCurrentFrame,
+                                skelAnime->limbCount, skelAnime->actorDrawTbl);
+    if (skelAnime->transCurrentFrame != 0) {
+        updateRate = R_UPDATE_RATE * 0.5f;
+        skelAnime->transCurrentFrame -= skelAnime->transitionStep * updateRate;
+        if (skelAnime->transCurrentFrame <= 0.0f) {
+            skelAnime->transCurrentFrame = 0.0f;
+            return;
+        }
+        SkelAnime_LoadAnimationType2(globalCtx, skelAnime->limbCount, skelAnime->actorDrawTbl,
+                                     skelAnime->transitionDrawTbl, skelAnime->transCurrentFrame);
+    }
+}
+
+s32 func_800A3D70(GlobalContext* globalCtx, SkelAnime* skelAnime) {
+    f32 updateRate = R_UPDATE_RATE * 0.5f;
+
+    skelAnime->animCurrentFrame += skelAnime->animPlaybackSpeed * updateRate;
+    if (skelAnime->animCurrentFrame < 0.0f) {
+        skelAnime->animCurrentFrame += skelAnime->totalFrames;
+    } else if (skelAnime->totalFrames <= skelAnime->animCurrentFrame) {
+        skelAnime->animCurrentFrame -= skelAnime->totalFrames;
+    }
+    func_800A3C9C(globalCtx, skelAnime);
+    return 0;
+}
+
+s32 func_800A3E0C(GlobalContext* globalCtx, SkelAnime* skelAnime) {
+    f32 updateRate = R_UPDATE_RATE * 0.5f;
+
+    if (skelAnime->animCurrentFrame == skelAnime->animFrameCount) {
+        func_800A3C9C(globalCtx, skelAnime);
+        return 1;
+    }
+    skelAnime->animCurrentFrame += skelAnime->animPlaybackSpeed * updateRate;
+    if (0.0f < ((skelAnime->animCurrentFrame - skelAnime->animFrameCount) * skelAnime->animPlaybackSpeed)) {
+        skelAnime->animCurrentFrame = skelAnime->animFrameCount;
+    } else {
+        if (skelAnime->animCurrentFrame < 0.0f) {
+            skelAnime->animCurrentFrame += skelAnime->totalFrames;
+        } else if (skelAnime->totalFrames <= skelAnime->animCurrentFrame) {
+            skelAnime->animCurrentFrame -= skelAnime->totalFrames;
+        }
+    }
+    func_800A3C9C(globalCtx, skelAnime);
+    return 0;
+}
+
+void SkelAnime_SetTransition(GlobalContext* globalCtx, SkelAnime* skelAnime, f32 transitionRate) {
+    skelAnime->transCurrentFrame = 1.0f;
+    skelAnime->transitionStep = 1.0f / transitionRate;
+}
+
+void SkelAnime_ChangeLinkAnim(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimetionEntry* linkAnimetionEntrySeg,
+                              f32 playbackSpeed, f32 frame, f32 frameCount, u8 animationMode, f32 transitionRate) {
+
+    skelAnime->mode = animationMode;
+    if ((transitionRate != 0.0f) &&
+        ((linkAnimetionEntrySeg != skelAnime->linkAnimetionSeg) || (frame != skelAnime->animCurrentFrame))) {
+        if (transitionRate < 0) {
+            func_800A3B8C(skelAnime);
+            SkelAnime_CopyVec3s(skelAnime, skelAnime->transitionDrawTbl, skelAnime->actorDrawTbl);
+            transitionRate = -transitionRate;
+        } else {
+            skelAnime->animUpdate = &func_800A3BE4;
+            SkelAnime_LoadLinkAnimetion(globalCtx, linkAnimetionEntrySeg, (s32)frame, skelAnime->limbCount,
+                                        skelAnime->transitionDrawTbl);
+        }
+        skelAnime->transCurrentFrame = 1.0f;
+        skelAnime->transitionStep = 1.0f / transitionRate;
+    } else {
+        func_800A3B8C(skelAnime);
+        SkelAnime_LoadLinkAnimetion(globalCtx, linkAnimetionEntrySeg, (s32)frame, skelAnime->limbCount,
+                                    skelAnime->actorDrawTbl);
+        skelAnime->transCurrentFrame = 0.0f;
+    }
+
+    skelAnime->linkAnimetionSeg = linkAnimetionEntrySeg;
+    skelAnime->animCurrentFrame = 0.0f;
+    skelAnime->initialFrame = frame;
+    skelAnime->animCurrentFrame = frame;
+    skelAnime->animFrameCount = frameCount;
+    skelAnime->totalFrames = SkelAnime_GetTotalFrames(linkAnimetionEntrySeg);
+    skelAnime->animPlaybackSpeed = playbackSpeed;
+}
+
+void SkelAnime_ChangeLinkAnimDefaultStop(GlobalContext* globalCtx, SkelAnime* skelAnime,
+                                         LinkAnimetionEntry* linkAnimetionEntrySeg) {
+    SkelAnime_ChangeLinkAnim(globalCtx, skelAnime, linkAnimetionEntrySeg, 1.0f, 0.0f,
+                             SkelAnime_GetFrameCount(&linkAnimetionEntrySeg->genericHeader), 2, 0.0f);
+}
+
+void SkelAnime_ChangeLinkAnimPlaybackStop(GlobalContext* globalCtx, SkelAnime* skelAnime,
+                                          LinkAnimetionEntry* linkAnimetionEntrySeg, f32 playbackSpeed) {
+    SkelAnime_ChangeLinkAnim(globalCtx, skelAnime, linkAnimetionEntrySeg, playbackSpeed, 0.0f,
+                             SkelAnime_GetFrameCount(&linkAnimetionEntrySeg->genericHeader), 2, 0.0f);
+}
+
+void SkelAnime_ChangeLinkAnimDefaultRepeat(GlobalContext* globalCtx, SkelAnime* skelAnime,
+                                           LinkAnimetionEntry* linkAnimetionEntrySeg) {
+    SkelAnime_ChangeLinkAnim(globalCtx, skelAnime, linkAnimetionEntrySeg, 1.0f, 0.0f,
+                             SkelAnime_GetFrameCount(&linkAnimetionEntrySeg->genericHeader), 0, 0.0f);
+}
+
+void SkelAnime_ChangeLinkAnimPlaybackRepeat(GlobalContext* globalCtx, SkelAnime* skelAnime,
+                                            LinkAnimetionEntry* linkAnimetionEntrySeg, f32 playbackSpeed) {
+    SkelAnime_ChangeLinkAnim(globalCtx, skelAnime, linkAnimetionEntrySeg, playbackSpeed, 0.0f,
+                             SkelAnime_GetFrameCount(&linkAnimetionEntrySeg->genericHeader), 0, 0.0f);
+}
+
+void func_800A41FC(GlobalContext* globalCtx, SkelAnime* skelAnime) {
+    SkelAnime_LoadAnimationType1(globalCtx, skelAnime->limbCount, skelAnime->transitionDrawTbl,
+                                 skelAnime->actorDrawTbl);
+}
+
+void func_800A422C(GlobalContext* globalCtx, SkelAnime* skelAnime) {
+    SkelAnime_LoadAnimationType1(globalCtx, skelAnime->limbCount, skelAnime->actorDrawTbl,
+                                 skelAnime->transitionDrawTbl);
+}
+
+void func_800A425C(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimetionEntry* linkAnimetionEntrySeg,
+                   f32 frame) {
+    SkelAnime_LoadLinkAnimetion(globalCtx, linkAnimetionEntrySeg, (s32)frame, skelAnime->limbCount,
+                                skelAnime->transitionDrawTbl);
+}
+
+void func_800A42A0(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimetionEntry* linkAnimetionEntrySeg,
+                   f32 frame) {
+    SkelAnime_LoadLinkAnimetion(globalCtx, linkAnimetionEntrySeg, (s32)frame, skelAnime->limbCount,
+                                skelAnime->actorDrawTbl);
+}
+
+void func_800A42E4(GlobalContext* globalCtx, SkelAnime* skelAnime, f32 frame) {
+    SkelAnime_LoadAnimationType2(globalCtx, skelAnime->limbCount, skelAnime->actorDrawTbl, skelAnime->transitionDrawTbl,
+                                 frame);
+}
+
+void func_800A431C(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimetionEntry* linkAnimetionEntrySeg,
+                   f32 transitionFrame, LinkAnimetionEntry* linkAnimetionEntrySeg2, f32 frame, f32 transitionRate,
+                   Vec3s* actorDrawTbl) {
+    Vec3s* alignedActorDrawTbl;
+    SkelAnime_LoadLinkAnimetion(globalCtx, linkAnimetionEntrySeg, (s32)transitionFrame, skelAnime->limbCount,
+                                skelAnime->actorDrawTbl);
+
+    alignedActorDrawTbl = (Vec3s*)ALIGN16((u32)actorDrawTbl);
+
+    SkelAnime_LoadLinkAnimetion(globalCtx, linkAnimetionEntrySeg2, (s32)frame, skelAnime->limbCount,
+                                alignedActorDrawTbl);
+    SkelAnime_LoadAnimationType2(globalCtx, skelAnime->limbCount, skelAnime->actorDrawTbl, alignedActorDrawTbl,
+                                 transitionRate);
+}
+
+void func_800A43B8(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimetionEntry* linkAnimetionEntrySeg,
+                   f32 transitionFrame, LinkAnimetionEntry* linkAnimetionEntrySeg2, f32 frame, f32 transitionRate,
+                   Vec3s* actorDrawTbl) {
+    Vec3s* alignedActorDrawTbl;
+
+    SkelAnime_LoadLinkAnimetion(globalCtx, linkAnimetionEntrySeg, (s32)transitionFrame, skelAnime->limbCount,
+                                skelAnime->transitionDrawTbl);
+
+    alignedActorDrawTbl = (Vec3s*)ALIGN16((u32)actorDrawTbl);
+
+    SkelAnime_LoadLinkAnimetion(globalCtx, linkAnimetionEntrySeg2, (s32)frame, skelAnime->limbCount,
+                                alignedActorDrawTbl);
+    SkelAnime_LoadAnimationType2(globalCtx, skelAnime->limbCount, skelAnime->transitionDrawTbl, alignedActorDrawTbl,
+                                 transitionRate);
+}
+
+void SkelAnime_SetModeStop(SkelAnime* skelAnime) {
+    skelAnime->mode = 2;
+    func_800A3B8C(skelAnime);
+}
+
+s32 func_800A4478(SkelAnime* skelAnime, f32 arg1, f32 updateRate) {
+    f32 updateSpeed;
+    f32 temp_f12;
+    f32 nextFrame;
+
+    updateSpeed = skelAnime->animPlaybackSpeed * updateRate;
+    nextFrame = skelAnime->animCurrentFrame - updateSpeed;
+    if (nextFrame < 0.0f) {
+        nextFrame += skelAnime->totalFrames;
+    } else if (skelAnime->totalFrames <= nextFrame) {
+        nextFrame -= skelAnime->totalFrames;
+    }
+
+    if ((arg1 == 0.0f) && (updateSpeed > 0.0f)) {
+        arg1 = skelAnime->totalFrames;
+    }
+
+    temp_f12 = (nextFrame + updateSpeed) - arg1;
+    if ((0.0f <= (temp_f12 * updateSpeed)) && (((temp_f12 - updateSpeed) * updateSpeed) < 0.0f)) {
+        return 1;
+    }
+    return 0;
+}
+
+s32 func_800A4530(SkelAnime* skelAnime, f32 arg1) {
+    f32 updateRate = R_UPDATE_RATE * 0.5f;
+
+    return func_800A4478(skelAnime, arg1, updateRate);
+}
+
+void SkelAnime_Init(GlobalContext* globalCtx, SkelAnime* skelAnime, SkeletonHeader* skeletonHeaderSeg,
+                    AnimationHeader* animationSeg, Vec3s* actorDrawTable, Vec3s* transitionDrawTable, s32 limbCount) {
+    SkeletonHeader* skeletonHeader;
+
+    skeletonHeader = SEGMENTED_TO_VIRTUAL(skeletonHeaderSeg);
+    skelAnime->limbCount = skeletonHeader->limbCount + 1;
+    skelAnime->skeleton = SEGMENTED_TO_VIRTUAL(skeletonHeader->skeletonSeg);
+    if (actorDrawTable == NULL) {
+        skelAnime->actorDrawTbl =
+            ZeldaArena_MallocDebug(skelAnime->limbCount * sizeof(*skelAnime->actorDrawTbl), "../z_skelanime.c", 2968);
+        skelAnime->transitionDrawTbl = ZeldaArena_MallocDebug(
+            skelAnime->limbCount * sizeof(*skelAnime->transitionDrawTbl), "../z_skelanime.c", 2969);
+    } else {
+        if (limbCount != skelAnime->limbCount) {
+            __assert("joint_buff_num == this->joint_num", "../z_skelanime.c", 2973);
+        }
+        skelAnime->actorDrawTbl = actorDrawTable;
+        skelAnime->transitionDrawTbl = transitionDrawTable;
+    }
+    if ((skelAnime->actorDrawTbl == NULL) || (skelAnime->transitionDrawTbl == NULL)) {
+        osSyncPrintf(VT_FGCOL(RED));
+        osSyncPrintf("Skeleton_Info2_ct メモリアロケーションエラー\n"); // Skeleton_Info2_ct memory allocation error
+        osSyncPrintf(VT_RST);
+    }
+
+    if (animationSeg != NULL) {
+        SkelAnime_ChangeAnimDefaultRepeat(skelAnime, animationSeg);
+    }
+}
+
+void SkelAnime_InitSV(GlobalContext* globalCtx, SkelAnime* skelAnime, SkeletonHeader* skeletonHeaderSeg,
+                      AnimationHeader* animationSeg, Vec3s* actorDrawTable, Vec3s* transitionDrawTable, s32 limbCount) {
+    SkeletonHeader* skeletonHeader;
+
+    skeletonHeader = SEGMENTED_TO_VIRTUAL(skeletonHeaderSeg);
+    skelAnime->limbCount = skeletonHeader->limbCount + 1;
+    skelAnime->dListCount = skeletonHeader->dListCount;
+    skelAnime->skeleton = SEGMENTED_TO_VIRTUAL(skeletonHeader->skeletonSeg);
+
+    if (actorDrawTable == NULL) {
+        skelAnime->actorDrawTbl =
+            ZeldaArena_MallocDebug(skelAnime->limbCount * sizeof(*skelAnime->actorDrawTbl), "../z_skelanime.c", 3047);
+
+        skelAnime->transitionDrawTbl = ZeldaArena_MallocDebug(
+            skelAnime->limbCount * sizeof(*skelAnime->transitionDrawTbl), "../z_skelanime.c", 3048);
+    } else {
+        if (limbCount != skelAnime->limbCount) {
+            __assert("joint_buff_num == this->joint_num", "../z_skelanime.c", 3052);
+        }
+        skelAnime->actorDrawTbl = actorDrawTable;
+        skelAnime->transitionDrawTbl = transitionDrawTable;
+    }
+    if ((skelAnime->actorDrawTbl == NULL) || (skelAnime->transitionDrawTbl == NULL)) {
+        osSyncPrintf(VT_FGCOL(RED));
+        osSyncPrintf(
+            "Skeleton_Info_Rom_SV_ct メモリアロケーションエラー\n"); // Skeleton_Info_Rom_SV_ct Memory allocation error
+        osSyncPrintf(VT_RST);
+    }
+
+    if (animationSeg != NULL) {
+        SkelAnime_ChangeAnimDefaultRepeat(skelAnime, animationSeg);
+    }
+}
+
+void SkelAnime_InitSkin(GlobalContext* globalCtx, SkelAnime* skelAnime, SkeletonHeader* skeletonHeaderSeg,
+                        AnimationHeader* animationSeg) {
+    SkeletonHeader* skeletonHeader;
+
+    skeletonHeader = SEGMENTED_TO_VIRTUAL(skeletonHeaderSeg);
+    skelAnime->limbCount = skeletonHeader->limbCount + 1;
+    skelAnime->skeleton = SEGMENTED_TO_VIRTUAL(skeletonHeader->skeletonSeg);
+    skelAnime->actorDrawTbl =
+        ZeldaArena_MallocDebug(skelAnime->limbCount * sizeof(*skelAnime->actorDrawTbl), "../z_skelanime.c", 3120);
+    skelAnime->transitionDrawTbl =
+        ZeldaArena_MallocDebug(skelAnime->limbCount * sizeof(*skelAnime->transitionDrawTbl), "../z_skelanime.c", 3121);
+    if ((skelAnime->actorDrawTbl == NULL) || (skelAnime->transitionDrawTbl == NULL)) {
+        osSyncPrintf(VT_FGCOL(RED));
+        osSyncPrintf(
+            "Skeleton_Info2_skin2_ct メモリアロケーションエラー\n"); // Skeleton_Info2_skin2_ct Memory allocation error
+        osSyncPrintf(VT_RST);
+    }
+
+    if (animationSeg != NULL) {
+        SkelAnime_ChangeAnimDefaultRepeat(skelAnime, animationSeg);
+    }
+}
+
+void func_800A49B0(SkelAnime* skelAnime) {
+    if (skelAnime->mode < 2) {
+        skelAnime->animUpdate = &func_800A4D9C;
+    } else if (skelAnime->mode < 4) {
+        skelAnime->animUpdate = &func_800A4EE0;
+    } else {
+        skelAnime->animUpdate = &func_800A4E38;
+    }
+}
+
+s32 SkelAnime_FrameUpdateMatrix(SkelAnime* skelAnime) {
+    return skelAnime->animUpdate(skelAnime);
+}
+
+s32 func_800A4A20(SkelAnime* skelAnime) {
+    f32 prevUnk28;
+    f32 updateRate;
+
+    prevUnk28 = skelAnime->transCurrentFrame;
+    updateRate = R_UPDATE_RATE * (1.0f / 3.0f);
+    skelAnime->transCurrentFrame -= skelAnime->transitionStep * updateRate;
+    if (skelAnime->transCurrentFrame <= 0.0f) {
+        func_800A49B0(skelAnime);
+        skelAnime->transCurrentFrame = 0.0f;
+    }
+    SkelAnime_InterpolateVec3s(skelAnime->limbCount, skelAnime->actorDrawTbl, skelAnime->actorDrawTbl,
+                               skelAnime->transitionDrawTbl, 1.0f - (skelAnime->transCurrentFrame / prevUnk28));
+    return 0;
+}
+
+s32 func_800A4AD8(SkelAnime* skelAnime) {
+    s16 temp_a2;
+    s16 temp_a1;
+    f32 sp28;
+    f32 phi_f2;
+    f32 updateRate;
+
+    temp_a2 = (s16)(skelAnime->transCurrentFrame * 16384.0f);
+    updateRate = R_UPDATE_RATE * (1.0f / 3.0f);
+    skelAnime->transCurrentFrame -= skelAnime->transitionStep * updateRate;
+    if (skelAnime->transCurrentFrame <= 0.0f) {
+        func_800A49B0(skelAnime);
+        skelAnime->transCurrentFrame = 0.0f;
+    }
+    temp_a1 = (s16)(skelAnime->transCurrentFrame * 16384.0f);
+    if (skelAnime->unk_03 < 0) {
+        sp28 = 1.0f - Math_Coss(temp_a2);
+        phi_f2 = 1.0f - Math_Coss(temp_a1);
+    } else {
+        sp28 = Math_Sins(temp_a2);
+        phi_f2 = Math_Sins(temp_a1);
+    }
+    if (phi_f2 != 0.0f) {
+        phi_f2 /= sp28;
+    } else {
+        phi_f2 = 0.0f;
+    }
+    SkelAnime_InterpolateVec3s(skelAnime->limbCount, skelAnime->actorDrawTbl, skelAnime->actorDrawTbl,
+                               skelAnime->transitionDrawTbl, 1.0f - phi_f2);
+    return 0;
+}
+
+void func_800A4C58(SkelAnime* skelAnime) {
+    s32 t;
+    f32 updateRate;
+    char pad[4];
+    Vec3s sp38[98];
+    f32 temp_f10;
+    f32 temp_f2;
+
+    SkelAnime_AnimateFrame(skelAnime->animCurrentSeg, skelAnime->animCurrentFrame, skelAnime->limbCount,
+                           skelAnime->actorDrawTbl);
+    if (skelAnime->mode & 0x1) {
+        t = (s32)skelAnime->animCurrentFrame;
+        temp_f10 = t;
+        temp_f2 = skelAnime->animCurrentFrame - temp_f10;
+        t++;
+        if (t >= (s32)skelAnime->totalFrames) {
+            t = 0;
+        }
+        SkelAnime_AnimateFrame(skelAnime->animCurrentSeg, t, skelAnime->limbCount, sp38);
+        SkelAnime_InterpolateVec3s(skelAnime->limbCount, skelAnime->actorDrawTbl, skelAnime->actorDrawTbl, sp38,
+                                   temp_f2);
+    }
+    if (skelAnime->transCurrentFrame != 0) {
+        updateRate = R_UPDATE_RATE * (1.0f / 3.0f);
+        skelAnime->transCurrentFrame -= skelAnime->transitionStep * updateRate;
+        if (skelAnime->transCurrentFrame <= 0.0f) {
+            skelAnime->transCurrentFrame = 0.0f;
+            return;
+        }
+        SkelAnime_InterpolateVec3s(skelAnime->limbCount, skelAnime->actorDrawTbl, skelAnime->actorDrawTbl,
+                                   skelAnime->transitionDrawTbl, skelAnime->transCurrentFrame);
+    }
+}
+
+s32 func_800A4D9C(SkelAnime* skelAnime) {
+    f32 updateRate = R_UPDATE_RATE * (1.0f / 3.0f);
+    skelAnime->animCurrentFrame += skelAnime->animPlaybackSpeed * updateRate;
+    if (skelAnime->animCurrentFrame < 0.0f) {
+        skelAnime->animCurrentFrame += skelAnime->totalFrames;
+    } else if (skelAnime->totalFrames <= skelAnime->animCurrentFrame) {
+        skelAnime->animCurrentFrame -= skelAnime->totalFrames;
+    }
+    func_800A4C58(skelAnime);
+    return 0;
+}
+
+s32 func_800A4E38(SkelAnime* skelAnime) {
+    f32 updateRate = R_UPDATE_RATE * (1.0f / 3.0f);
+    skelAnime->animCurrentFrame += skelAnime->animPlaybackSpeed * updateRate;
+    if (skelAnime->animCurrentFrame < skelAnime->initialFrame) {
+        skelAnime->animCurrentFrame =
+            (skelAnime->animCurrentFrame - skelAnime->initialFrame) + skelAnime->animFrameCount;
+    } else if (skelAnime->animFrameCount <= skelAnime->animCurrentFrame) {
+        skelAnime->animCurrentFrame =
+            (skelAnime->animCurrentFrame - skelAnime->animFrameCount) + skelAnime->initialFrame;
+    }
+
+    func_800A4C58(skelAnime);
+    return 0;
+}
+
+s32 func_800A4EE0(SkelAnime* skelAnime) {
+    f32 updateRate;
+
+    updateRate = R_UPDATE_RATE * (1.0f / 3.0f);
+    if (skelAnime->animCurrentFrame == skelAnime->animFrameCount) {
+
+        SkelAnime_AnimateFrame(skelAnime->animCurrentSeg, (s32)skelAnime->animCurrentFrame, skelAnime->limbCount,
+                               skelAnime->actorDrawTbl);
+        func_800A4C58(skelAnime);
+        return 1;
+    }
+    skelAnime->animCurrentFrame += skelAnime->animPlaybackSpeed * updateRate;
+    if (0.0f < ((skelAnime->animCurrentFrame - skelAnime->animFrameCount) * skelAnime->animPlaybackSpeed)) {
+        skelAnime->animCurrentFrame = skelAnime->animFrameCount;
+    } else {
+        if (skelAnime->animCurrentFrame < 0.0f) {
+            skelAnime->animCurrentFrame += skelAnime->totalFrames;
+        } else {
+            if (skelAnime->totalFrames <= skelAnime->animCurrentFrame) {
+                skelAnime->animCurrentFrame -= skelAnime->totalFrames;
+            }
+        }
+    }
+    func_800A4C58(skelAnime);
+    return 0;
+}
+
+void SkelAnime_ChangeAnimImpl(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 playbackSpeed, f32 frame,
+                              f32 frameCount, u8 animationType, f32 transitionRate, s8 unk2) {
+    skelAnime->mode = animationType;
+    if ((transitionRate != 0.0f) &&
+        ((animationSeg != skelAnime->animCurrentSeg) || (frame != skelAnime->animCurrentFrame))) {
+        if (transitionRate < 0) {
+            func_800A49B0(skelAnime);
+            SkelAnime_CopyVec3s(skelAnime, skelAnime->transitionDrawTbl, skelAnime->actorDrawTbl);
+            transitionRate = -transitionRate;
+        } else {
+            if (unk2 != 0) {
+                skelAnime->animUpdate = &func_800A4AD8;
+                skelAnime->unk_03 = unk2;
+            } else {
+                skelAnime->animUpdate = &func_800A4A20;
+            }
+            SkelAnime_AnimateFrame(animationSeg, frame, skelAnime->limbCount, skelAnime->transitionDrawTbl);
+        }
+        skelAnime->transCurrentFrame = 1.0f;
+        skelAnime->transitionStep = 1.0f / transitionRate;
+    } else {
+        func_800A49B0(skelAnime);
+        SkelAnime_AnimateFrame(animationSeg, frame, skelAnime->limbCount, skelAnime->actorDrawTbl);
+        skelAnime->transCurrentFrame = 0.0f;
+    }
+
+    skelAnime->animCurrentSeg = animationSeg;
+    skelAnime->initialFrame = frame;
+    skelAnime->animFrameCount = frameCount;
+    skelAnime->totalFrames = SkelAnime_GetTotalFrames(&animationSeg->genericHeader);
+    if (skelAnime->mode >= 4) {
+        skelAnime->animCurrentFrame = 0.0f;
+    } else {
+        skelAnime->animCurrentFrame = frame;
+        if (skelAnime->mode < 2) {
+            skelAnime->animFrameCount = skelAnime->totalFrames - 1.0f;
+        }
+    }
+    skelAnime->animPlaybackSpeed = playbackSpeed;
+}
+
+void SkelAnime_ChangeAnim(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 playbackSpeed, f32 frame,
+                          f32 frameCount, u8 mode, f32 transitionRate) {
+    SkelAnime_ChangeAnimImpl(skelAnime, animationSeg, playbackSpeed, frame, frameCount, mode, transitionRate, 0);
+}
+
+void SkelAnime_ChangeAnimDefaultStop(SkelAnime* skelAnime, AnimationHeader* animationSeg) {
+    SkelAnime_ChangeAnim(skelAnime, animationSeg, 1.0f, 0.0f, SkelAnime_GetFrameCount(&animationSeg->genericHeader), 2,
+                         0.0f);
+}
+
+void SkelAnime_ChangeAnimTransitionStop(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 transitionRate) {
+    SkelAnime_ChangeAnim(skelAnime, animationSeg, 1.0f, 0, SkelAnime_GetFrameCount(&animationSeg->genericHeader), 2,
+                         transitionRate);
+}
+
+void SkelAnime_ChangeAnimPlaybackStop(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 playbackSpeed) {
+    SkelAnime_ChangeAnim(skelAnime, animationSeg, playbackSpeed, 0.0f,
+                         SkelAnime_GetFrameCount(&animationSeg->genericHeader), 2, 0.0f);
+}
+
+void SkelAnime_ChangeAnimDefaultRepeat(SkelAnime* skelAnime, AnimationHeader* animationSeg) {
+    SkelAnime_ChangeAnim(skelAnime, animationSeg, 1.0f, 0.0f, SkelAnime_GetFrameCount(&animationSeg->genericHeader), 0,
+                         0.0f);
+}
+
+void SkelAnime_ChangeAnimTransitionRepeat(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 transitionRate) {
+    SkelAnime_ChangeAnim(skelAnime, animationSeg, 1.0f, 0.0f, 0.0f, 0, transitionRate);
+}
+
+void SkelAnime_ChangeAnimPlaybackRepeat(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 playbackSpeed) {
+    SkelAnime_ChangeAnim(skelAnime, animationSeg, playbackSpeed, 0.0f,
+                         SkelAnime_GetFrameCount(&animationSeg->genericHeader), 0, 0.0f);
+}
+
+void SkelAnime_AnimSetStop(SkelAnime* skelAnime) {
+    skelAnime->mode = 2;
+    skelAnime->animFrameCount = skelAnime->totalFrames;
+    func_800A49B0(skelAnime);
+}
+
+void SkelAnime_AnimReverse(SkelAnime* skelAnime) {
+    f32 initialFrame = skelAnime->initialFrame;
+
+    skelAnime->initialFrame = skelAnime->animFrameCount;
+    skelAnime->animPlaybackSpeed = -skelAnime->animPlaybackSpeed;
+    skelAnime->animFrameCount = initialFrame;
+}
+
+void func_800A5428(SkelAnime* skelAnime, Vec3s* dst, Vec3s* src, u8* index) {
+    s32 i;
+    for (i = 0; i < skelAnime->limbCount; i++, dst++, src++) {
+        if (*index++) {
+            *dst = *src;
+        }
+    }
+}
+
+void func_800A5490(SkelAnime* skelAnime, Vec3s* dst, Vec3s* src, u8* arg3) {
+    s32 i;
+    for (i = 0; i < skelAnime->limbCount; i++, dst++, src++) {
+        if (*arg3++ < 1U) {
+            *dst = *src;
+        }
+    }
+}
+
+/*
+ * Moves `pos` backwards on the xz plane from `angle`
+ */
+void func_800A54FC(SkelAnime* skelAnime, Vec3f* pos, s16 angle) {
+    f32 x;
+    f32 z;
+    f32 sin;
+    f32 cos;
+
+    if (skelAnime->flags & 0x10) {
+        pos->z = 0.0f;
+        pos->x = 0.0f;
+    } else {
+        // `angle` rotation around y axis.
+        x = skelAnime->actorDrawTbl->x;
+        z = skelAnime->actorDrawTbl->z;
+        sin = Math_Sins(angle);
+        cos = Math_Coss(angle);
+        pos->x = x * cos + z * sin;
+        pos->z = z * cos - x * sin;
+        x = skelAnime->prevFramePos.x;
+        z = skelAnime->prevFramePos.z;
+        // `prevFrameRot` rotation around y axis.
+        sin = Math_Sins(skelAnime->prevFrameRot);
+        cos = Math_Coss(skelAnime->prevFrameRot);
+        pos->x -= x * cos + z * sin;
+        pos->z -= z * cos - x * sin;
+    }
+
+    skelAnime->prevFrameRot = angle;
+    skelAnime->prevFramePos.x = skelAnime->actorDrawTbl->x;
+    skelAnime->actorDrawTbl->x = skelAnime->unk_3E.x;
+    skelAnime->prevFramePos.z = skelAnime->actorDrawTbl->z;
+    skelAnime->actorDrawTbl->z = skelAnime->unk_3E.z;
+    if (skelAnime->flags & ANIM_FLAG_UPDATEXZ) {
+        if (skelAnime->flags & ANIM_FLAG_UPDATEY) {
+            pos->y = 0.0f;
+        } else {
+            pos->y = skelAnime->actorDrawTbl->y - skelAnime->prevFramePos.y;
+        }
+        skelAnime->prevFramePos.y = skelAnime->actorDrawTbl->y;
+        skelAnime->actorDrawTbl->y = skelAnime->unk_3E.y;
+    } else {
+        pos->y = 0.0f;
+        skelAnime->prevFramePos.y = skelAnime->actorDrawTbl->y;
+    }
+    skelAnime->flags &= ~ANIM_FLAG_UPDATEY;
+}
+
+s32 func_800A56C8(SkelAnime* skelAnime, f32 arg1) {
+    return func_800A4478(skelAnime, arg1, 1.0f);
+}
+
+void SkelAnime_Free(SkelAnime* skelAnime, GlobalContext* globalCtx) {
+    if (skelAnime->actorDrawTbl != NULL) {
+        ZeldaArena_FreeDebug(skelAnime->actorDrawTbl, "../z_skelanime.c", 3729);
+    } else {
+        osSyncPrintf("now_joint あきまへん！！\n"); // now_joint Akimane! !
+    }
+
+    if (skelAnime->transitionDrawTbl != NULL) {
+        ZeldaArena_FreeDebug(skelAnime->transitionDrawTbl, "../z_skelanime.c", 3731);
+    } else {
+        osSyncPrintf("morf_joint あきまへん！！\n"); // "morf_joint Akimane !!"
+    }
+}
+
+void SkelAnime_CopyVec3s(SkelAnime* skelAnime, Vec3s* dst, Vec3s* src) {
+    s32 i;
+    for (i = 0; i < skelAnime->limbCount; i++) {
+        *dst++ = *src++;
+    }
+}
diff --git a/src/code/z_skin.c b/src/code/z_skin.c
index 617a633c1..ca907bb17 100644
--- a/src/code/z_skin.c
+++ b/src/code/z_skin.c
@@ -20,4 +20,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_skin/func_800A63CC.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_skin/func_800A6408.s")
-
diff --git a/src/code/z_skin_awb.c b/src/code/z_skin_awb.c
index aaffdcadb..4e4530025 100644
--- a/src/code/z_skin_awb.c
+++ b/src/code/z_skin_awb.c
@@ -10,4 +10,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_awb/func_800A698C.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_awb/func_800A6AC4.s")
-
diff --git a/src/code/z_skin_matrix.c b/src/code/z_skin_matrix.c
index 2c7a215fe..27d703f30 100644
--- a/src/code/z_skin_matrix.c
+++ b/src/code/z_skin_matrix.c
@@ -40,4 +40,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A7EC0.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A8030.s")
-
diff --git a/src/code/z_sram.c b/src/code/z_sram.c
index dd9578f0e..0f2bcaa64 100644
--- a/src/code/z_sram.c
+++ b/src/code/z_sram.c
@@ -24,4 +24,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_sram/func_800A9CD4.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_sram/func_800A9D28.s")
-
diff --git a/src/code/z_view.c b/src/code/z_view.c
index 84eb4770d..18336b98a 100644
--- a/src/code/z_view.c
+++ b/src/code/z_view.c
@@ -1,63 +1,602 @@
 #include <ultra64.h>
 #include <global.h>
+#include <vt.h>
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA190.s")
+volatile u32 D_8012ABF0 = 1;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA1F8.s")
+// TODO replace UnkViewStruct with Viewport and match with that instead
+void func_800AA190(UnkViewStruct* arg0, Viewport* viewport) {
+    s32 xLen;
+    s32 yLen;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA250.s")
+    xLen = viewport->rightX - viewport->leftX;
+    yLen = viewport->bottomY - viewport->topY;
+    arg0->unk_0 = (xLen * 2);
+    arg0->unk_2 = (yLen * 2);
+    arg0->unk_4 = 0x01FF;
+    arg0->unk_6 = 0;
+    arg0->unk_8 = (((viewport->leftX * 2) + xLen) * 2);
+    arg0->unk_A = (((viewport->topY * 2) + yLen) * 2);
+    arg0->unk_C = 0x01FF;
+    arg0->unk_E = 0;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA278.s")
+View* func_800AA1F8(GraphicsContext* gfxCtx) {
+    View* view = SystemArena_MallocDebug(sizeof(View), "../z_view.c", 285);
+    if (view != NULL) {
+        func_80106860(view, 0, sizeof(View)); // TODO prototype this
+        func_800AA278(view, gfxCtx);
+    }
+    return view;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA358.s")
+void func_800AA250(View* view) {
+    SystemArena_FreeDebug(view, "../z_view.c", 297);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA3F0.s")
+void func_800AA278(View* view, GraphicsContext* gfxCtx) {
+    view->gfxCtx = gfxCtx;
+    view->viewport.topY = 0;
+    view->viewport.bottomY = 240;
+    view->viewport.leftX = 0;
+    view->viewport.rightX = 320;
+    view->magic = 0x56494557; //"VIEW"
+    view->eye.x = 0.0f;
+    view->eye.y = 0.0f;
+    view->unk_24 = 1.0f;
+    view->fieldOfView = 60.0f;
+    view->fogDistance = 10.0f;
+    view->zDepth = 12800.0f;
+    view->unk_34.x = 0.0f;
+    view->unk_40.x = 0.0f;
+    view->unk_40.y = 1.0f;
+    view->unk_40.z = 0.0f;
+    view->eye.z = -1.0f;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA43C.s")
+    if (D_8012ABF0 != 0) {
+        if (&D_8012ABF0) {}
+        osSyncPrintf("\nview: initialize ---\n", gfxCtx, view);
+        D_8012ABF0 = 0;
+    }
+    view->unk_124 = 0;
+    view->unk_120 = 7;
+    func_800AA7B8(view);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA454.s")
+void func_800AA358(View* view, Vec3f* vec1, Vec3f* vec2, Vec3f* vec3) {
+    if (vec1->x == vec2->x && vec1->z == vec2->z) {
+        vec1->x += 0.1f;
+    }
+    view->eye = *vec1;
+    view->unk_34 = *vec2;
+    view->unk_40 = *vec3;
+    view->unk_120 |= 1;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA460.s")
+void func_800AA3F0(View* view, Vec3f* vec1, Vec3f* vec2, Vec3f* vec3) {
+    view->eye = *vec1;
+    view->unk_34 = *vec2;
+    view->unk_40 = *vec3;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA48C.s")
+void func_800AA43C(View* view, f32 arg1) {
+    view->unk_120 |= 4;
+    view->unk_24 = arg1;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA4A8.s")
+void func_800AA454(View* view, f32* arg1) {
+    *arg1 = view->unk_24;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA4E0.s")
+void func_800AA460(View* view, f32 fieldOfView, f32 fogDistance, f32 zDepth) {
+    view->fieldOfView = fieldOfView;
+    view->fogDistance = fogDistance;
+    view->zDepth = zDepth;
+    view->unk_120 |= 4;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA4FC.s")
+void func_800AA48C(View* view, f32* fieldOfView, f32* fogDistance, f32* zDepth) {
+    *fieldOfView = view->fieldOfView;
+    *fogDistance = view->fogDistance;
+    *zDepth = view->zDepth;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA52C.s")
+void func_800AA4A8(View* view, f32 fieldOfView, f32 fogDistance, f32 zDepth) {
+    view->fieldOfView = fieldOfView;
+    view->fogDistance = fogDistance;
+    view->zDepth = zDepth;
+    view->unk_120 |= 8;
+    view->unk_24 = 1.0f;
+}
 
+void func_800AA4E0(View* view, f32* fieldOfView, f32* fogDistance, f32* zDepth) {
+    *fieldOfView = view->fieldOfView;
+    *fogDistance = view->fogDistance;
+    *zDepth = view->zDepth;
+}
+
+void func_800AA4FC(View* view, Viewport* viewport) {
+    view->viewport = *viewport;
+    view->unk_120 |= 2;
+}
+
+void func_800AA52C(View* view, Viewport* viewport) {
+    *viewport = view->viewport;
+}
+
+#ifdef NON_MATCHING
+// regalloc, zeros optimised out
+void func_800AA550(View* view) {
+    s32 phi_v1;
+    s32 phi_v1_2;
+    s32 pad;
+    s32 ulx;
+    s32 uly;
+    s32 lrx;
+    s32 lry;
+    GraphicsContext* gfxCtx;
+    s32 temp_a0;
+    Gfx* dispRefs[4];
+
+    gfxCtx = view->gfxCtx;
+    phi_v1 = func_800B38FC();
+    if (phi_v1 < 0) {
+        phi_v1 = 0;
+    }
+    if (phi_v1 >= 0x79) {
+        phi_v1 = 0x78;
+    }
+    ulx = view->viewport.leftX + 0;
+    uly = view->viewport.topY + phi_v1;
+    lrx = view->viewport.rightX - 0;
+    lry = view->viewport.bottomY - phi_v1;
+    if (ulx < 0) {
+        __assert("ulx >= 0", "../z_view.c", 454);
+    }
+    if (uly < 0) {
+        __assert("uly >= 0", "../z_view.c", 455);
+    }
+    if (lrx > SCREEN_WIDTH) {
+        __assert("lrx <= SCREEN_WD", "../z_view.c", 456);
+    }
+    if (lry > SCREEN_HEIGHT) {
+        __assert("lry <= SCREEN_HT", "../z_view.c", 457);
+    }
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_view.c", 459);
+    gDPPipeSync(gfxCtx->polyOpa.p++);
+    gDPSetScissor(gfxCtx->polyOpa.p++, G_SC_NON_INTERLACE, ulx, uly, lrx, lry);
+    gDPPipeSync(gfxCtx->polyXlu.p++);
+    gDPSetScissor(gfxCtx->polyXlu.p++, G_SC_NON_INTERLACE, ulx, uly, lrx, lry);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_view.c", 472);
+}
+#else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA550.s")
+#endif
+
+void func_800AA76C(View* view, f32 arg1, f32 arg2, f32 arg3) {
+    view->unk_E8.x = arg1;
+    view->unk_E8.y = arg2;
+    view->unk_E8.z = arg3;
+}
+
+void func_800AA78C(View* view, f32 arg1, f32 arg2, f32 arg3) {
+    view->unk_F4.x = arg1;
+    view->unk_F4.y = arg2;
+    view->unk_F4.z = arg3;
+}
+
+void func_800AA7AC(View* view, f32 arg1) {
+    view->unk_100 = arg1;
+}
+
+void func_800AA7B8(View* view) {
+    view->unk_E8.x = 0.0f;
+    view->unk_E8.y = 0.0f;
+    view->unk_E8.z = 0.0f;
+    view->unk_F4.x = 1.0f;
+    view->unk_F4.y = 1.0f;
+    view->unk_F4.z = 1.0f;
+    view->unk_104 = view->unk_E8;
+    view->unk_110 = view->unk_F4;
+    view->unk_100 = 0.0f;
+}
+
+void func_800AA814(View* view) {
+    view->unk_E8.x = 0.0f;
+    view->unk_E8.y = 0.0f;
+    view->unk_E8.z = 0.0f;
+    view->unk_F4.x = 1.0f;
+    view->unk_F4.y = 1.0f;
+    view->unk_F4.z = 1.0f;
+    view->unk_100 = 1.0f;
+}
+
+void func_800AA840(View* view, Vec3f vec1, Vec3f vec2, f32 arg3) {
+    view->unk_E8 = vec1;
+    view->unk_F4 = vec2;
+    view->unk_100 = arg3;
+}
+
+s32 func_800AA890(View* view, Mtx* mtx) {
+    MtxF mtxF;
+
+    if (view->unk_100 == 0.0f) {
+        return 0;
+    } else if (view->unk_100 == 1.0f) {
+        view->unk_104 = view->unk_E8;
+        view->unk_110 = view->unk_F4;
+        view->unk_100 = 0.0f;
+    } else {
+        view->unk_104.x += ((view->unk_E8.x - view->unk_104.x) * view->unk_100);
+        view->unk_104.y += ((view->unk_E8.y - view->unk_104.y) * view->unk_100);
+        view->unk_104.z += ((view->unk_E8.z - view->unk_104.z) * view->unk_100);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA76C.s")
+        view->unk_110.x += ((view->unk_F4.x - view->unk_110.x) * view->unk_100);
+        view->unk_110.y += ((view->unk_F4.y - view->unk_110.y) * view->unk_100);
+        view->unk_110.z += ((view->unk_F4.z - view->unk_110.z) * view->unk_100);
+    }
+    Matrix_MtxToMtxF(mtx, &mtxF);
+    Matrix_Put(&mtxF);
+    Matrix_RotateX(view->unk_104.x, 1);
+    Matrix_RotateY(view->unk_104.y, 1);
+    Matrix_RotateZ(view->unk_104.z, 1);
+    Matrix_Scale(view->unk_110.x, view->unk_110.y, view->unk_110.z, MTXMODE_APPLY);
+    Matrix_RotateZ(-view->unk_104.z, 1);
+    Matrix_RotateY(-view->unk_104.y, 1);
+    Matrix_RotateX(-view->unk_104.x, 1);
+    Matrix_ToMtx(mtx, "../z_view.c", 566);
+    return 1;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA78C.s")
+void func_800AAA50(View* view, s32 arg1) {
+    arg1 = (view->unk_120 & arg1) | arg1 >> 4;
+    if (arg1 & 8) {
+        func_800AB0A8(view);
+    } else {
+        func_800AAA9C(view);
+    }
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA7AC.s")
+#ifdef NON_MATCHING
+// Just one stack var
+s32 func_800AAA9C(View* view) {
+    s32 pad;
+    s32 pad1;
+    s32 ylen;
+    Viewport* viewport;
+    Mtx* projection;
+    MtxF* viewing;
+    Gfx* dispRefs[6];
+    s32 xlen;
+    GraphicsContext* gfxCtx;
+    s32 i;
+    MtxF mtxF;
+    MtxF mtxFv;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA7B8.s")
+    gfxCtx = view->gfxCtx;
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_view.c", 596);
+    viewport = Graph_Alloc(gfxCtx, sizeof(Viewport));
+    LogUtils_CheckNullPointer("vp", viewport, "../z_view.c", 601);
+    func_800AA190(viewport, &view->viewport);
+    view->unk_50 = *viewport;
+    func_800AA550(view);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA814.s")
+    gSPViewport(gfxCtx->polyOpa.p++, viewport);
+    gSPViewport(gfxCtx->polyXlu.p++, viewport);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA840.s")
+    projection = Graph_Alloc(gfxCtx, sizeof(Mtx));
+    LogUtils_CheckNullPointer("projection", projection, "../z_view.c", 616);
+    view->unk_E0 = projection;
+    xlen = view->viewport.rightX - view->viewport.leftX;
+    ylen = view->viewport.bottomY - view->viewport.topY;
+    if (HREG(80) == 0xB) {
+        if (HREG(94) != 0xB) {
+            HREG(94) = 0xB;
+            HREG(83) = 0x3C;
+            HREG(84) = 0x3415;
+            HREG(85) = 0xA;
+            HREG(86) = 0x3200;
+            HREG(87) = 0x64;
+        }
+        guPerspective(projection, &view->unk_11C, HREG(83), HREG(84) / 10000.0f, HREG(85), HREG(86), HREG(87) / 100.0f);
+    } else {
+        guPerspective(projection, &view->unk_11C, view->fieldOfView, (f32)xlen / (f32)ylen, view->fogDistance,
+                      view->zDepth, view->unk_24);
+    }
+    if (QREG(88) & 1) {
+        osSyncPrintf("fovy %f near %f far %f scale %f aspect %f normal %08x\n", view->fieldOfView, view->fogDistance,
+                     view->zDepth, view->unk_24, (f32)xlen / (f32)ylen, view->unk_11C);
+        Matrix_MtxToMtxF(projection, &mtxF);
+        osSyncPrintf("projection\n");
+        for (i = 0; i < 4; i++) {
+            osSyncPrintf("	%f	%f	%f	%f\n", mtxF.mf[i][0], mtxF.mf[i][1], mtxF.mf[i][2],
+                         mtxF.mf[i][3]);
+        }
+        osSyncPrintf("\n");
+    }
+    view->unk_60 = *projection;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AA890.s")
+    func_800AA890(view, projection);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AAA50.s")
+    gSPPerspNormalize(gfxCtx->polyOpa.p++, view->unk_11C);
+    gSPMatrix(gfxCtx->polyOpa.p++, projection, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
+    gSPPerspNormalize(gfxCtx->polyXlu.p++, view->unk_11C);
+    gSPMatrix(gfxCtx->polyXlu.p++, projection, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
 
+    viewing = Graph_Alloc(gfxCtx, sizeof(MtxF));
+    LogUtils_CheckNullPointer("viewing", viewing, "../z_view.c", 667);
+    view->unk_E4 = viewing;
+    if (view->eye.x == view->unk_34.x && view->eye.y == view->unk_34.y && view->eye.z == view->unk_34.z) {
+        view->eye.x += 1.0f;
+        view->eye.y += 1.0f;
+        view->eye.z += 1.0f;
+    }
+    func_800ABE74(view->eye.x, view->eye.y, view->eye.z);
+    func_80101E34(viewing, view->eye.x, view->eye.y, view->eye.z, view->unk_34.x, view->unk_34.y, view->unk_34.z,
+                  view->unk_40.x, view->unk_40.y, view->unk_40.z);
+    view->unk_A0 = *viewing;
+
+    if (QREG(88) & 2) {
+        Matrix_MtxToMtxF(view->unk_E4, &mtxFv);
+        osSyncPrintf("viewing\n");
+        for (i = 0; i < 4; i++) {
+            osSyncPrintf("	%f	%f	%f	%f\n", mtxFv.mf[i][0], mtxFv.mf[i][1], mtxFv.mf[i][2],
+                         mtxFv.mf[i][3]);
+        }
+        osSyncPrintf("\n");
+    }
+
+    gSPMatrix(gfxCtx->polyOpa.p++, viewing, G_MTX_NOPUSH | G_MTX_MUL | G_MTX_PROJECTION);
+    gSPMatrix(gfxCtx->polyXlu.p++, viewing, G_MTX_NOPUSH | G_MTX_MUL | G_MTX_PROJECTION);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_view.c", 711);
+    return 1;
+}
+#else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AAA9C.s")
+#endif
+
+s32 func_800AB0A8(View* view) {
+    Viewport* viewport;
+    Mtx* projection;
+    s32 pad;
+    s32 pad1;
+    GraphicsContext* gfxCtx;
+    Gfx* dispRefs[3];
+
+    gfxCtx = view->gfxCtx;
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_view.c", 726);
+    viewport = Graph_Alloc(gfxCtx, sizeof(Viewport));
+    LogUtils_CheckNullPointer("vp", viewport, "../z_view.c", 730);
+    func_800AA190(viewport, &view->viewport);
+    view->unk_50 = *viewport;
+    func_800AA550(view);
+
+    gSPViewport(gfxCtx->polyOpa.p++, viewport);
+    gSPViewport(gfxCtx->polyXlu.p++, viewport);
+    gSPViewport(gfxCtx->overlay.p++, viewport);
+
+    projection = Graph_Alloc(gfxCtx, sizeof(Mtx));
+    LogUtils_CheckNullPointer("projection", projection, "../z_view.c", 744);
+    view->unk_E0 = projection;
+    func_801045A4(projection, -(f32)(s32)gScreenWidth * 0.5f, (f32)(s32)gScreenWidth * 0.5f,
+                  -(f32)(s32)gScreenHeight * 0.5f, (f32)(s32)gScreenHeight * 0.5f, view->fogDistance, view->zDepth,
+                  view->unk_24);
+
+    view->unk_60 = *projection;
+
+    gSPMatrix(gfxCtx->polyOpa.p++, projection, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
+    gSPMatrix(gfxCtx->polyXlu.p++, projection, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_view.c", 762);
+    return 1;
+}
+
+#ifdef NON_MATCHING
+// saved registers allocated differently, everything else is OK
+s32 func_800AB2C4(View* view) {
+    Mtx* projection;
+    f32 pad;
+    f32 pad1;
+    Viewport* viewport;
+    Gfx* dispRefs[4];
+    GraphicsContext* gfxCtx;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AB0A8.s")
+    gfxCtx = view->gfxCtx;
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_view.c", 777);
+    viewport = Graph_Alloc(gfxCtx, sizeof(Viewport));
+    LogUtils_CheckNullPointer("vp", viewport, "../z_view.c", 781);
+    func_800AA190(viewport, &view->viewport);
+    view->unk_50 = *viewport;
 
+    gDPPipeSync(gfxCtx->overlay.p++);
+    gDPSetScissor(gfxCtx->overlay.p++, G_SC_NON_INTERLACE, view->viewport.leftX, view->viewport.topY,
+                  view->viewport.rightX, view->viewport.bottomY);
+    gSPViewport(gfxCtx->overlay.p++, viewport);
+
+    projection = Graph_Alloc(gfxCtx, sizeof(Mtx));
+    LogUtils_CheckNullPointer("projection", projection, "../z_view.c", 791);
+    view->unk_E0 = projection;
+    func_801045A4(projection, -(f32)(s32)gScreenWidth * 0.5f, (f32)(s32)gScreenWidth * 0.5f,
+                  -(f32)(s32)gScreenHeight * 0.5f, (f32)(s32)gScreenHeight * 0.5f, view->fogDistance, view->zDepth,
+                  view->unk_24);
+    view->unk_60 = *projection;
+
+    gSPMatrix(gfxCtx->overlay.p++, projection, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
+
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_view.c", 801);
+    return 1;
+}
+#else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AB2C4.s")
+#endif
+
+#ifdef NON_MATCHING
+// regalloc
+s32 func_800AB560(View* view) {
+    s32 pad;
+    s32 pad1;
+    s32 pad2;
+    s32 pad3;
+    GraphicsContext* gfxCtx;
+    Viewport* viewport;
+    Mtx* projection;
+    MtxF* viewing;
+    Gfx* dispRefs[6];
+    f32 aspect;
+
+    gfxCtx = view->gfxCtx;
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_view.c", 816);
+
+    viewport = Graph_Alloc(gfxCtx, sizeof(Viewport));
+    LogUtils_CheckNullPointer("vp", viewport, "../z_view.c", 821);
+
+    func_800AA190(viewport, &view->viewport);
+    view->unk_50 = *viewport;
+    gDPPipeSync(gfxCtx->overlay.p++);
+    gDPSetScissor(gfxCtx->overlay.p++, G_SC_NON_INTERLACE, view->viewport.leftX, view->viewport.topY,
+                  view->viewport.rightX, view->viewport.bottomY);
+    gSPViewport(gfxCtx->overlay.p++, viewport);
+
+    projection = Graph_Alloc(gfxCtx, sizeof(Mtx));
+    LogUtils_CheckNullPointer("projection", projection, "../z_view.c", 833);
+
+    view->unk_E0 = projection;
+    guPerspective(projection, &view->unk_11C, view->fieldOfView,
+                  (f32)(view->viewport.rightX - view->viewport.leftX) /
+                      (f32)(view->viewport.bottomY - view->viewport.topY),
+                  view->fogDistance, view->zDepth, view->unk_24);
+    view->unk_60 = *projection;
+    gSPPerspNormalize(gfxCtx->overlay.p++, view->unk_11C);
+    gSPMatrix(gfxCtx->overlay.p++, projection, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
+
+    viewing = Graph_Alloc(gfxCtx, sizeof(MtxF));
+    LogUtils_CheckNullPointer("viewing", viewing, "../z_view.c", 848);
+
+    view->unk_E4 = viewing;
+    if (view->eye.x == view->unk_34.x && view->eye.y == view->unk_34.y && view->eye.z == view->unk_34.z) {
+        view->eye.x += 1.0f;
+        view->eye.y += 1.0f;
+        view->eye.z += 1.0f;
+    }
+    func_800ABE74(view->eye.x, view->eye.y, view->eye.z);
+    func_80101E34(viewing, view->eye.x, view->eye.y, view->eye.z, view->unk_34.x, view->unk_34.y, view->unk_34.z,
+                  view->unk_40.x, view->unk_40.y, view->unk_40.z);
+    view->unk_A0 = *viewing;
+    gSPMatrix(gfxCtx->overlay.p++, viewing, G_MTX_NOPUSH | G_MTX_MUL | G_MTX_PROJECTION);
 
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_view.c", 871);
+    return 1;
+}
+#else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AB560.s")
+#endif
+
+s32 func_800AB944(View* view) {
+    Gfx* dispRefs[5];
+
+    Graph_OpenDisps(dispRefs, view->gfxCtx, "../z_view.c", 878);
+    func_800ABE74(view->eye.x, view->eye.y, view->eye.z);
+    func_80101E34(view->unk_E4, view->eye.x, view->eye.y, view->eye.z, view->unk_34.x, view->unk_34.y, view->unk_34.z,
+                  view->unk_40.x, view->unk_40.y, view->unk_40.z);
+
+    Graph_CloseDisps(dispRefs, view->gfxCtx, "../z_view.c", 886);
+    return 1;
+}
+
+#ifdef NON_MATCHING
+// saved register usage is wrong, relatively minor reorderings, regalloc
+s32 func_800AB9EC(View* view, s32 arg1, Gfx** p) {
+    Viewport* viewport;
+    Mtx* projection;
+    Mtx* projection2;
+    MtxF* viewing;
+    GraphicsContext* gfxCtx;
+    Gfx* pLocal;
+
+    gfxCtx = view->gfxCtx;
+    pLocal = *p;
+    arg1 = (view->unk_120 & arg1) | arg1 >> 4;
+    if (arg1 & 2) {
+        viewport = Graph_Alloc(view->gfxCtx, sizeof(Viewport));
+        LogUtils_CheckNullPointer("vp", viewport, "../z_view.c", 910);
+        func_800AA190(viewport, &view->viewport);
+
+        view->unk_50 = *viewport;
+
+        gDPPipeSync(pLocal++);
+        gDPSetScissor(pLocal++, G_SC_NON_INTERLACE, view->viewport.leftX, view->viewport.topY, view->viewport.rightX,
+                      view->viewport.bottomY);
+        gSPViewport(pLocal++, viewport);
+    }
+    if (arg1 & 8) {
+        projection = Graph_Alloc(gfxCtx, sizeof(Mtx));
+        LogUtils_CheckNullPointer("projection", projection, "../z_view.c", 921);
+        view->unk_E0 = projection;
+        func_801045A4(projection, -(f32)(s32)gScreenWidth * 0.5f, (f32)(s32)gScreenWidth * 0.5f,
+                      -(f32)(s32)gScreenHeight * 0.5f, (f32)(s32)gScreenHeight * 0.5f, view->fogDistance, view->zDepth,
+                      view->unk_24);
+
+        view->unk_60 = *projection;
+
+        gSPMatrix(pLocal++, projection, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
+    } else if (arg1 & 6) {
+        projection2 = Graph_Alloc(gfxCtx, sizeof(Mtx));
+        LogUtils_CheckNullPointer("projection", projection2, "../z_view.c", 932);
+        view->unk_E0 = projection2;
+        guPerspective(projection2, &view->unk_11C, view->fieldOfView,
+                      (f32)(view->viewport.rightX - view->viewport.leftX) /
+                          (f32)(view->viewport.bottomY - view->viewport.topY),
+                      view->fogDistance, view->zDepth, view->unk_24);
+
+        view->unk_60 = *projection2;
+
+        gSPPerspNormalize(pLocal++, view->unk_11C);
+        gSPMatrix(pLocal++, projection2, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
+    }
+    if (arg1 & 1) {
+        viewing = Graph_Alloc(gfxCtx, sizeof(MtxF));
+        LogUtils_CheckNullPointer("viewing", viewing, "../z_view.c", 948);
+        view->unk_E4 = viewing;
+        func_800ABE74(view->eye.x, view->eye.y, view->eye.z);
+        func_80101E34(viewing, view->eye.x, view->eye.y, view->eye.z, view->unk_34.x, view->unk_34.y, view->unk_34.z,
+                      view->unk_40.x, view->unk_40.y, view->unk_40.z);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AB944.s")
+        view->unk_A0 = *viewing;
 
+        gSPMatrix(pLocal++, viewing, G_MTX_NOPUSH | G_MTX_MUL | G_MTX_PROJECTION);
+    }
+    view->unk_120 = 0;
+    *p = pLocal;
+    return 1;
+}
+#else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800AB9EC.s")
+#endif
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_view/func_800ABE74.s")
+s32 func_800ABE74(f32 eyeX, f32 eyeY, f32 eyeZ) {
+    s32 errorCode = 0;
 
+    if ((eyeX * eyeX) + (eyeY * eyeY) + (eyeZ * eyeZ) > 1073676288.0f) {
+        errorCode = 3;
+    } else {
+        f32 absEyeX;
+        f32 absEyeY;
+        f32 absEyeZ;
+        absEyeX = ABS(eyeX);
+        absEyeY = ABS(eyeY);
+        absEyeZ = ABS(eyeZ);
+        if (((18900.0f < absEyeX) || (18900.0f < absEyeY)) || (18900.0f < absEyeZ)) {
+            errorCode = 2;
+        } else if (((16000.0f < absEyeX) || (16000.0f < absEyeY)) || (16000.0f < absEyeZ)) {
+            errorCode = 1;
+        }
+    }
+    if (errorCode != 0) {
+        osSyncPrintf(VT_FGCOL(RED));
+        // Is too large
+        osSyncPrintf("eye が大きすぎます eye=[%8.3f %8.3f %8.3f] error=%d\n", eyeX, eyeY, eyeZ, errorCode);
+        osSyncPrintf(VT_RST);
+    }
+    return errorCode;
+}
diff --git a/src/code/z_vimode.c b/src/code/z_vimode.c
index e15d619ac..1fa3ba452 100644
--- a/src/code/z_vimode.c
+++ b/src/code/z_vimode.c
@@ -16,4 +16,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_vimode/func_800ACA98.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_vimode/func_800ACAF8.s")
-
diff --git a/src/code/z_vismono.c b/src/code/z_vismono.c
index 75956af41..239e81ce0 100644
--- a/src/code/z_vismono.c
+++ b/src/code/z_vismono.c
@@ -12,4 +12,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_vismono/func_800AD5C0.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_vismono/func_800AD870.s")
-
diff --git a/src/code/z_vr_box.c b/src/code/z_vr_box.c
index c468b4b29..8008c6aca 100644
--- a/src/code/z_vr_box.c
+++ b/src/code/z_vr_box.c
@@ -12,4 +12,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_vr_box/func_800AF218.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_vr_box/func_800B0E50.s")
-
diff --git a/src/code/z_vr_box_draw.c b/src/code/z_vr_box_draw.c
index 6af1a46ea..4161c4615 100644
--- a/src/code/z_vr_box_draw.c
+++ b/src/code/z_vr_box_draw.c
@@ -6,4 +6,3 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_vr_box_draw/func_800B10C4.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_vr_box_draw/func_800B1744.s")
-