Animation system updated, some more boot files decompiled (+6%), z_fcurve_data_skelanime decompiled (1 non-matching), some asm files split, etc (#89)

* Progress on various files

* gfxprint stuff

* split some rodata, add iconv for rodata string parsing

* z_std_dma rodata

* 2 nonmatchings in gfxprint

* mtxuty-cvt ok

* more

* match a function in idle.c

* progress

* Cleanup

* Rename BgPolygon to CollisionPoly

* progress

* some effect stuff

* more effect progress

* updates

* made suggested changes

* z_effect_soft_sprite_old_init mostly ok

* remove old effects enum

* gamealloc.c OK

* added more files

* motor.c almost done

* motor.c OK

* updates

* migration of two files

* listalloc.c oK

* z_fcurve_data_skelanime split

* z_fcurve_data_skelanime.c decompiled

* more files split

* z_malloc.c OK

* contpfs.c OK

* fault.c rodata migrated

* migrated fault_drawer rodata

* update

* update preprocess.py

* renamed functions in z_skelanime

* started z_skelanime cleanup

* like halfway through fixing z_skelanime

* animation system updated to meet oot standards

* remove unused animation structs

* rename matrix structs to fit oot

* Add -woff 712

* fix diff_settings.py because i accidentally broke it before

* fixed merge conflict, doesn't match though

* It matches now

* Updates

* Fixed warnings...added gcc code syntax checking

* Remove gcc check, added in Tharo's PR

* warnings fixed (i think)

* fixed all warnings i think

* ok

* not sure what to do

* Fix all warnings i think (z_en_a_keep needs some file cleanup thouguh)

* it matches if i do this

* remove comment

* accidentally put osPfsFreeBlocks in epilinkhandle.c

* memcmp -> bcmp

* change u32 size to size_t size, delete string.h because it caused unnecessary confusion with defining size_t twice

* format.sh

* MTXMODE_NEW and MTXMODE_APPLY to matrix functions

* Made suggested changes

* pragma sFaultDrawerFont instead of including in repo

* add some functions to functions.h

* Bss reordering fixed in z_collision_check...added hack to disasm.py

* Updated z_en_a_keep.c

* Missed suggestion in EnAObj_Destroy

* .

* update z_fcurve_Data_skelanime and z_skelanime with suggestions

* devmgr.c ok

* minor changes

* Addressed comments

* remove redundant file

* gfxp -> dlist in game.c

* updated actorfixer.py

* fixed warnings in z_malloc

* Change void* back to Actor*

* format

* Add the soft_sprit comments back

* Rename SV->Flex

* remove .common

* run format

* Update src/code/z_skelanime.c

* u32 channel

Co-authored-by: Lucas Shaw <lucas.shaw1123@gmail.com>
Co-authored-by: angie <angheloalf95@gmail.com>
Co-authored-by: Kenix3 <kenixwhisperwind@gmail.com>

src/boot_O1/viextendvstart.c

@@ -0,0 +1,5 @@
+#include "global.h"
+
+void osViExtendVStart(u32 a0) {
+    __additional_scanline = a0;
+}

src/boot_O2/__osMalloc.c

@@ -45,7 +45,7 @@ ArenaNode* ArenaImpl_GetLastBlock(Arena* arena) {
     return last;
 }
 
-void __osMallocInit(Arena* arena, void* start, u32 size) {
+void __osMallocInit(Arena* arena, void* start, size_t size) {
     bzero(arena, sizeof(*arena));
     ArenaImpl_LockInit(arena);
     __osMallocAddBlock(arena, start, size);
@@ -91,7 +91,7 @@ u8 __osMallocIsInitalized(Arena* arena) {
     return arena->isInit;
 }
 
-void* __osMalloc(Arena* arena, u32 size) {
+void* __osMalloc(Arena* arena, size_t size) {
     ArenaNode* iter;
     ArenaNode* newNode;
     void* alloc;
@@ -134,7 +134,7 @@ void* __osMalloc(Arena* arena, u32 size) {
     return alloc;
 }
 
-void* __osMallocR(Arena* arena, u32 size) {
+void* __osMallocR(Arena* arena, size_t size) {
     ArenaNode* iter;
     ArenaNode* newNode;
     u32 blockSize;
@@ -219,7 +219,7 @@ end:
 
 #pragma GLOBAL_ASM("asm/non_matchings/boot/__osMalloc/__osRealloc.s")
 
-void __osAnalyzeArena(Arena* arena, u32* outMaxFree, u32* outFree, u32* outAlloc) {
+void __osAnalyzeArena(Arena* arena, size_t* outMaxFree, size_t* outFree, size_t* outAlloc) {
     ArenaNode* iter;
 
     ArenaImpl_Lock(arena);

src/boot_O2/__osMemset.c

@@ -1,6 +1,6 @@
 #include "global.h"
 
-void* __osMemset(void* ptr, s32 val, u32 size) {
+void* __osMemset(void* ptr, s32 val, size_t size) {
     u8* dst = ptr;
     register s32 rem;
 

src/boot_O2/loadfragment2.c

@@ -71,7 +71,7 @@ void Load2_Relocate(u32 allocatedVRamAddr, OverlayRelocationSection* overlayInfo
 s32 Load2_LoadOverlay(u32 vRomStart, u32 vRomEnd, u32 vRamStart, u32 vRamEnd, u32 allocatedVRamAddr) {
     int nbytes;
     u32 pad;
-    u32 size;
+    size_t size;
     void* end;
     OverlayRelocationSection* overlayInfo;
 
@@ -106,9 +106,9 @@ s32 Load2_LoadOverlay(u32 vRomStart, u32 vRomEnd, u32 vRamStart, u32 vRamEnd, u3
 #pragma GLOBAL_ASM("asm/non_matchings/boot/loadfragment2/Load2_LoadOverlay.s")
 #endif
 
-void* Load2_AllocateAndLoad(u32 vRomStart, u32 vRomEnd, u32 vRamStart, u32 vRamEnd) {
+void* Overlay_AllocateAndLoad(u32 vRomStart, u32 vRomEnd, u32 vRamStart, u32 vRamEnd) {
     void* allocatedVRamAddr;
-    u32 size;
+    size_t size;
 
     size = vRamEnd - vRamStart;
     allocatedVRamAddr = SystemArena_MallocR(size);

src/boot_O2/system_malloc.c

@@ -2,15 +2,15 @@
 
 Arena gSystemArena;
 
-void* SystemArena_Malloc(u32 size) {
+void* SystemArena_Malloc(size_t size) {
     return __osMalloc(&gSystemArena, size);
 }
 
-void* SystemArena_MallocR(u32 size) {
+void* SystemArena_MallocR(size_t size) {
     return __osMallocR(&gSystemArena, size);
 }
 
-void* SystemArena_Realloc(void* oldPtr, u32 newSize) {
+void* SystemArena_Realloc(void* oldPtr, size_t newSize) {
     return __osRealloc(&gSystemArena, oldPtr, newSize);
 }
 
@@ -18,9 +18,9 @@ void SystemArena_Free(void* ptr) {
     __osFree(&gSystemArena, ptr);
 }
 
-void* SystemArena_Calloc(u32 elements, u32 size) {
+void* SystemArena_Calloc(u32 elements, size_t size) {
     void* ptr;
-    u32 totalSize = elements * size;
+    size_t totalSize = elements * size;
 
     ptr = __osMalloc(&gSystemArena, totalSize);
     if (ptr != NULL) {
@@ -29,7 +29,7 @@ void* SystemArena_Calloc(u32 elements, u32 size) {
     return ptr;
 }
 
-void SystemArena_AnalyzeArena(u32* maxFreeBlock, u32* bytesFree, u32* bytesAllocated) {
+void SystemArena_AnalyzeArena(size_t* maxFreeBlock, size_t* bytesFree, size_t* bytesAllocated) {
     __osAnalyzeArena(&gSystemArena, maxFreeBlock, bytesFree, bytesAllocated);
 }
 
@@ -37,7 +37,7 @@ u32 SystemArena_CheckArena(void) {
     return __osCheckArena(&gSystemArena);
 }
 
-void SystemArena_InitArena(void* start, u32 size) {
+void SystemArena_InitArena(void* start, size_t size) {
     __osMallocInit(&gSystemArena, start, size);
 }
 

src/boot_O2_g3/fault.c

@@ -1,7 +1,32 @@
+#include "ultra64.h"
 #include "global.h"
 #include "vt.h"
 
-#pragma GLOBAL_ASM("asm/non_matchings/boot/fault/D_800982B0.s")
+// data
+const char* sCpuExceptions[] = {
+    "Interrupt",
+    "TLB modification",
+    "TLB exception on load",
+    "TLB exception on store",
+    "Address error on load",
+    "Address error on store",
+    "Bus error on inst.",
+    "Bus error on data",
+    "System call exception",
+    "Breakpoint exception",
+    "Reserved instruction",
+    "Coprocessor unusable",
+    "Arithmetic overflow",
+    "Trap exception",
+    "Virtual coherency on inst.",
+    "Floating point exception",
+    "Watchpoint exception",
+    "Virtual coherency on data",
+};
+
+const char* sFpuExceptions[] = {
+    "Unimplemented operation", "Invalid operation", "Division by zero", "Overflow", "Underflow", "Inexact operation",
+};
 
 void Fault_SleepImpl(u32 duration) {
     u64 value = (duration * OS_CPU_COUNTER) / 1000ull;
@@ -79,7 +104,7 @@ void Fault_RemoveClient(FaultClient* client) {
     }
 }
 
-void Fault_AddAddrConvClient(FaultAddrConvClient* client, fault_address_converter_func callback, void* param) {
+void Fault_AddAddrConvClient(FaultAddrConvClient* client, FaultAddrConvFunc callback, void* param) {
     OSIntMask mask;
     u32 alreadyExists = 0;
 
@@ -269,9 +294,9 @@ void Fault_PrintFPCR(u32 value) {
     u32 flag = 0x20000;
 
     FaultDrawer_Printf("FPCSR:%08xH ", value);
-    for (i = 0; i < ARRAY_COUNT(sExceptionNames); i++) {
+    for (i = 0; i < ARRAY_COUNT(sFpuExceptions); i++) {
         if (value & flag) {
-            FaultDrawer_Printf("(%s)", sExceptionNames[i]);
+            FaultDrawer_Printf("(%s)", sFpuExceptions[i]);
             break;
         }
         flag >>= 1;
@@ -284,9 +309,9 @@ void osSyncPrintfFPCR(u32 value) {
     u32 flag = 0x20000;
 
     osSyncPrintf("FPCSR:%08xH  ", value);
-    for (i = 0; i < ARRAY_COUNT(sExceptionNames); i++) {
+    for (i = 0; i < ARRAY_COUNT(sFpuExceptions); i++) {
         if (value & flag) {
-            osSyncPrintf("(%s)\n", sExceptionNames[i]);
+            osSyncPrintf("(%s)\n", sFpuExceptions[i]);
             break;
         }
         flag >>= 1;
@@ -308,7 +333,7 @@ void Fault_PrintThreadContext(OSThread* t) {
     FaultDrawer_SetCursor(0x16, 0x14);
 
     ctx = &t->context;
-    FaultDrawer_Printf("THREAD:%d (%d:%s)\n", t->id, causeStrIdx, D_80096B80[causeStrIdx]);
+    FaultDrawer_Printf("THREAD:%d (%d:%s)\n", t->id, causeStrIdx, sCpuExceptions[causeStrIdx]);
     FaultDrawer_SetCharPad(-1, 0);
 
     FaultDrawer_Printf("PC:%08xH SR:%08xH VA:%08xH\n", (u32)ctx->pc, (u32)ctx->sr, (u32)ctx->badvaddr);
@@ -368,7 +393,7 @@ void osSyncPrintfThreadContext(OSThread* t) {
 
     ctx = &t->context;
     osSyncPrintf("\n");
-    osSyncPrintf("THREAD ID:%d (%d:%s)\n", t->id, causeStrIdx, D_80096B80[causeStrIdx]);
+    osSyncPrintf("THREAD ID:%d (%d:%s)\n", t->id, causeStrIdx, sCpuExceptions[causeStrIdx]);
 
     osSyncPrintf("PC:%08xH   SR:%08xH   VA:%08xH\n", (u32)ctx->pc, (u32)ctx->sr, (u32)ctx->badvaddr);
     osSyncPrintf("AT:%08xH   V0:%08xH   V1:%08xH\n", (u32)ctx->at, (u32)ctx->v0, (u32)ctx->v1);
@@ -444,7 +469,7 @@ void Fault_WaitForButtonCombo(void) {
     } while (!CHECK_BTN_ALL(input->cur.button, BTN_DLEFT | BTN_L | BTN_R | BTN_CRIGHT));
 }
 
-void Fault_DrawMemDumpPage(char* title, u32* addr, u32 param_3) {
+void Fault_DrawMemDumpPage(const char* title, u32* addr, u32 param_3) {
     u32* alignedAddr;
     u32* writeAddr;
     s32 y;
@@ -741,9 +766,9 @@ void Fault_SetOptionsFromController3(void) {
     }
 
     if (faultCustomOptions) {
-        graphPC = graphOSThread.context.pc;
-        graphRA = graphOSThread.context.ra;
-        graphSP = graphOSThread.context.sp;
+        graphPC = sGraphThread.context.pc;
+        graphRA = sGraphThread.context.ra;
+        graphSP = sGraphThread.context.sp;
         if (CHECK_BTN_ALL(input3->press.button, BTN_R)) {
             faultCopyToLog = !faultCopyToLog;
             FaultDrawer_SetOsSyncPrintfEnabled(faultCopyToLog);

src/boot_O2_g3/fault_drawer.c

@@ -1,6 +1,8 @@
 #include "global.h"
 #include "vt.h"
 
+extern const u32 sFaultDrawerFont[];
+
 FaultDrawer* sFaultDrawContext = &sFaultDrawerStruct;
 FaultDrawer sFaultDrawerDefault = {
     (u16*)0x803DA800,                   // fb - TODO map out buffers in this region and avoid hard-coded pointer
@@ -14,7 +16,7 @@ FaultDrawer sFaultDrawerDefault = {
     GPACK_RGBA5551(0, 0, 0, 0),         // backColor
     22,                                 // cursorX
     16,                                 // cursorY
-    (u32*)&sFaultDrawerFont,            // font
+    (u32*)sFaultDrawerFont,             // font
     8,                                  // charW
     8,                                  // charH
     0,                                  // charWPad
@@ -142,7 +144,7 @@ void FaultDrawer_FillScreen() {
 
 #pragma GLOBAL_ASM("asm/non_matchings/boot/fault_drawer/FaultDrawer_FormatStringFunc.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/boot/fault_drawer/D_80099080.s")
+const char D_80099080[] = "(null)";
 
 void FaultDrawer_VPrintf(const char* str, char* args) { // va_list
     _Printf((PrintCallback)FaultDrawer_FormatStringFunc, sFaultDrawContext, str, args);

src/boot_O2_g3/yaz0.c

@@ -122,7 +122,7 @@ s32 Yaz0_DecompressImpl(u8* src, u8* dst) {
     return 0;
 }
 
-void Yaz0_Decompress(u32 romStart, void* dst, u32 size) {
+void Yaz0_Decompress(u32 romStart, void* dst, size_t size) {
     s32 status;
     u32 pad;
     char sp80[0x50];

src/boot_O2_g3/z_std_dma.c

@@ -9,7 +9,7 @@ OSMesg sDmaMgrMsgs[32];
 OSThread sDmaMgrThread;
 u8 sDmaMgrStack[0x500];
 
-s32 DmaMgr_DMARomToRam(u32 rom, void* ram, u32 size) {
+s32 DmaMgr_DMARomToRam(u32 rom, void* ram, size_t size) {
     OSIoMesg ioMsg;
     OSMesgQueue queue;
     OSMesg msg[1];
@@ -111,7 +111,7 @@ const char* func_800809F4(u32 a0) {
 void DmaMgr_ProcessMsg(DmaRequest* req) {
     u32 vrom;
     void* ram;
-    u32 size;
+    size_t size;
     u32 romStart;
     u32 romSize;
     DmaEntry* dmaEntry;
@@ -172,7 +172,7 @@ void DmaMgr_ThreadEntry(void* a0) {
     }
 }
 
-s32 DmaMgr_SendRequestImpl(DmaRequest* request, void* vramStart, u32 vromStart, u32 size, UNK_TYPE4 unused,
+s32 DmaMgr_SendRequestImpl(DmaRequest* request, void* vramStart, u32 vromStart, size_t size, UNK_TYPE4 unused,
                            OSMesgQueue* queue, OSMesg msg) {
     if (gIrqMgrResetStatus >= 2) {
         return -2;
@@ -190,7 +190,7 @@ s32 DmaMgr_SendRequestImpl(DmaRequest* request, void* vramStart, u32 vromStart,
     return 0;
 }
 
-s32 DmaMgr_SendRequest0(void* vramStart, u32 vromStart, u32 size) {
+s32 DmaMgr_SendRequest0(void* vramStart, u32 vromStart, size_t size) {
     DmaRequest req;
     OSMesgQueue queue;
     OSMesg msg[1];

src/code/PreRender.c

@@ -17,7 +17,7 @@ void PreRender_SetValuesSave(PreRender* this, u32 width, u32 height, void* fbuf,
 
 void PreRender_Init(PreRender* this) {
     bzero(this, sizeof(PreRender));
-    func_80174AA0(&this->alloc);
+    ListAlloc_Init(&this->alloc);
 }
 
 /**
@@ -35,7 +35,7 @@ void PreRender_SetValues(PreRender* this, u32 width, u32 height, void* fbuf, voi
 }
 
 void PreRender_Destroy(PreRender* this) {
-    func_80174BA0(&this->alloc);
+    ListAlloc_FreeAll(&this->alloc);
 }
 
 void func_8016FDB8(PreRender* this, Gfx** gfxp, void* buf, void* bufSave, u32 arg4) {

src/code/TwoHeadArena.c

@@ -12,7 +12,7 @@ void* THA_GetTail(TwoHeadArena* tha) {
     return tha->tail;
 }
 
-void* THA_AllocStart(TwoHeadArena* tha, u32 size) {
+void* THA_AllocStart(TwoHeadArena* tha, size_t size) {
     void* start = tha->head;
 
     tha->head = (u32)tha->head + size;
@@ -23,7 +23,7 @@ void* THA_AllocStart1(TwoHeadArena* tha) {
     return THA_AllocStart(tha, 1);
 }
 
-void* THA_AllocEnd(TwoHeadArena* tha, u32 size) {
+void* THA_AllocEnd(TwoHeadArena* tha, size_t size) {
     u32 mask;
 
     if (size >= 0x10) {
@@ -42,14 +42,14 @@ void* THA_AllocEnd(TwoHeadArena* tha, u32 size) {
     return tha->tail;
 }
 
-void* THA_AllocEndAlign16(TwoHeadArena* tha, u32 size) {
+void* THA_AllocEndAlign16(TwoHeadArena* tha, size_t size) {
     u32 mask = ~0xF;
 
     tha->tail = (((u32)tha->tail & mask) - size) & mask;
     return tha->tail;
 }
 
-void* THA_AllocEndAlign(TwoHeadArena* tha, u32 size, u32 mask) {
+void* THA_AllocEndAlign(TwoHeadArena* tha, size_t size, u32 mask) {
     tha->tail = (((u32)tha->tail & mask) - size) & mask;
     return tha->tail;
 }
@@ -67,7 +67,7 @@ void THA_Init(TwoHeadArena* tha) {
     tha->tail = (u32)tha->bufp + tha->size;
 }
 
-void THA_Ct(TwoHeadArena* tha, void* ptr, u32 size) {
+void THA_Ct(TwoHeadArena* tha, void* ptr, size_t size) {
     bzero(tha, sizeof(TwoHeadArena));
     tha->bufp = ptr;
     tha->size = size;

src/code/TwoHeadGfxArena.c

@@ -1,6 +1,6 @@
 #include "global.h"
 
-void THGA_Ct(TwoHeadGfxArena* thga, Gfx* start, u32 size) {
+void THGA_Ct(TwoHeadGfxArena* thga, Gfx* start, size_t size) {
     THA_Ct((TwoHeadArena*)thga, start, size);
 }
 
@@ -44,7 +44,7 @@ Gfx* THGA_AllocStart8Wrapper(TwoHeadGfxArena* thga) {
     return THGA_AllocStart8(thga);
 }
 
-Gfx* THGA_AllocEnd(TwoHeadGfxArena* thga, u32 size) {
+Gfx* THGA_AllocEnd(TwoHeadGfxArena* thga, size_t size) {
     return THA_AllocEnd((TwoHeadArena*)thga, size);
 }
 

src/code/code_800F23E0.c

@@ -1,5 +0,0 @@
-#include "global.h"
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_800F23E0/func_800F23E0.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_800F23E0/func_800F2478.s")

src/code/code_80122660.c

@@ -1,5 +0,0 @@
-#include "global.h"
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_80122660/func_80122660.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_80122660/func_80122670.s")

src/code/game.c

@@ -22,7 +22,7 @@ void Game_SetFramerateDivisor(GameState* gameState, s32 divisor) {
 }
 
 void GameState_SetFBFilter(Gfx** gfx, u32 arg1) {
-    Gfx* _gfx = *gfx;
+    Gfx* dlist = *gfx;
 
     if ((R_FB_FILTER_TYPE > 0) && (R_FB_FILTER_TYPE < 5)) {
         D_801F8010.type = R_FB_FILTER_TYPE;
@@ -30,7 +30,7 @@ void GameState_SetFBFilter(Gfx** gfx, u32 arg1) {
         D_801F8010.color.g = R_FB_FILTER_PRIM_COLOR(1);
         D_801F8010.color.b = R_FB_FILTER_PRIM_COLOR(2);
         D_801F8010.color.a = R_FB_FILTER_A;
-        func_80140D10(&D_801F8010, &_gfx, arg1);
+        func_80140D10(&D_801F8010, &dlist, arg1);
     } else {
         if ((R_FB_FILTER_TYPE == 5) || (R_FB_FILTER_TYPE == 6)) {
             D_801F8020.useRgba = (R_FB_FILTER_TYPE == 6);
@@ -42,7 +42,7 @@ void GameState_SetFBFilter(Gfx** gfx, u32 arg1) {
             D_801F8020.envColor.g = R_FB_FILTER_ENV_COLOR(1);
             D_801F8020.envColor.b = R_FB_FILTER_ENV_COLOR(2);
             D_801F8020.envColor.a = R_FB_FILTER_A;
-            func_80142100(&D_801F8020, &_gfx, arg1);
+            func_80142100(&D_801F8020, &dlist, arg1);
         } else {
             if (R_FB_FILTER_TYPE == 7) {
                 sMonoColors.unk_00 = 0;
@@ -54,27 +54,24 @@ void GameState_SetFBFilter(Gfx** gfx, u32 arg1) {
                 sMonoColors.envColor.g = R_FB_FILTER_ENV_COLOR(1);
                 sMonoColors.envColor.b = R_FB_FILTER_ENV_COLOR(2);
                 sMonoColors.envColor.a = R_FB_FILTER_A;
-                VisMono_Draw(&sMonoColors, &_gfx, arg1);
+                VisMono_Draw(&sMonoColors, &dlist, arg1);
             }
         }
     }
 
-    *gfx = _gfx;
+    *gfx = dlist;
 }
 
-void Game_Nop80173534(GameState* gamestate) {
-    ;
+void Game_Nop80173534(GameState* gameState) {
 }
 
-void GameState_Draw(GameState* gamestate, GraphicsContext* gfxCtx) {
+void GameState_Draw(GameState* gameState, GraphicsContext* gfxCtx) {
     Gfx* nextDisplayList;
     Gfx* polyOpa;
 
     OPEN_DISPS(gfxCtx);
 
-    polyOpa = POLY_OPA_DISP;
-    nextDisplayList = Graph_GfxPlusOne(POLY_OPA_DISP);
-
+    nextDisplayList = Graph_GfxPlusOne(polyOpa = POLY_OPA_DISP);
     gSPDisplayList(OVERLAY_DISP++, nextDisplayList);
 
     if (R_FB_FILTER_TYPE && R_FB_FILTER_ENV_COLOR(3) == 0) {
@@ -98,119 +95,123 @@ void GameState_Draw(GameState* gamestate, GraphicsContext* gfxCtx) {
 
     if (R_ENABLE_ARENA_DBG != 0) {
         SpeedMeter_DrawTimeEntries(&D_801F7FF0, gfxCtx);
-        SpeedMeter_DrawAllocEntries(&D_801F7FF0, gfxCtx, gamestate);
+        SpeedMeter_DrawAllocEntries(&D_801F7FF0, gfxCtx, gameState);
     }
 
     CLOSE_DISPS(gfxCtx);
 }
 
-void Game_ResetSegments(GraphicsContext* gfxCtx) {
-    gSPSegment(gfxCtx->polyOpa.p++, 0, 0);
-    gSPSegment(gfxCtx->polyOpa.p++, 0xF, gfxCtx->framebuffer);
-    gSPSegment(gfxCtx->polyXlu.p++, 0, 0);
-    gSPSegment(gfxCtx->polyXlu.p++, 0xF, gfxCtx->framebuffer);
-    gSPSegment(gfxCtx->overlay.p++, 0, 0);
-    gSPSegment(gfxCtx->overlay.p++, 0xF, gfxCtx->framebuffer);
+void GameState_SetFrameBuffer(GraphicsContext* gfxCtx) {
+    OPEN_DISPS(gfxCtx);
+
+    gSPSegment(POLY_OPA_DISP++, 0, NULL);
+    gSPSegment(POLY_OPA_DISP++, 0xF, gfxCtx->framebuffer);
+    gSPSegment(POLY_XLU_DISP++, 0, NULL);
+    gSPSegment(POLY_XLU_DISP++, 0xF, gfxCtx->framebuffer);
+    gSPSegment(OVERLAY_DISP++, 0, NULL);
+    gSPSegment(OVERLAY_DISP++, 0xF, gfxCtx->framebuffer);
+
+    CLOSE_DISPS(gfxCtx);
 }
 
 void func_801736DC(GraphicsContext* gfxCtx) {
     Gfx* nextDisplayList;
-    Gfx* _polyOpa;
+    Gfx* polyOpa;
 
-    nextDisplayList = Graph_GfxPlusOne(_polyOpa = gfxCtx->polyOpa.p);
-    gSPDisplayList(gfxCtx->overlay.p++, nextDisplayList);
+    OPEN_DISPS(gfxCtx);
+
+    nextDisplayList = Graph_GfxPlusOne(polyOpa = gfxCtx->polyOpa.p);
+    gSPDisplayList(OVERLAY_DISP++, nextDisplayList);
     gSPEndDisplayList(nextDisplayList++);
-    Graph_BranchDlist(_polyOpa, nextDisplayList);
+    Graph_BranchDlist(polyOpa, nextDisplayList);
 
-    gfxCtx->polyOpa.p = nextDisplayList;
+    POLY_OPA_DISP = nextDisplayList;
+
+    CLOSE_DISPS(gfxCtx);
 }
 
-void Game_UpdateInput(GameState* gamestate) {
-    Padmgr_GetInput(gamestate->input, 1);
+void Game_UpdateInput(GameState* gameState) {
+    Padmgr_GetInput(gameState->input, 1);
 }
 
-void Game_Update(GameState* gamestate) {
-    GraphicsContext* _gCtx;
-    _gCtx = gamestate->gfxCtx;
+void Game_Update(GameState* gameState) {
+    GraphicsContext* gfxCtx = gameState->gfxCtx;
 
-    Game_ResetSegments(gamestate->gfxCtx);
+    GameState_SetFrameBuffer(gameState->gfxCtx);
 
-    gamestate->main(gamestate);
+    gameState->main(gameState);
 
     if (R_PAUSE_MENU_MODE != 2) {
-        GameState_Draw(gamestate, _gCtx);
-        func_801736DC(_gCtx);
+        GameState_Draw(gameState, gfxCtx);
+        func_801736DC(gfxCtx);
     }
 }
 
-void Game_IncrementFrameCount(GameState* gamestate) {
-    Game_Nop80173534(gamestate);
-    gamestate->frames++;
+void Game_IncrementFrameCount(GameState* gameState) {
+    Game_Nop80173534(gameState);
+    gameState->frames++;
 }
 
-void Game_InitHeap(GameState* gamestate, u32 size) {
-    GameState* _ctx;
-    void* buf;
-
-    _ctx = gamestate;
-    buf = Gamealloc_Alloc(&_ctx->alloc, size);
+void GameState_InitArena(GameState* gameState, size_t size) {
+    GameAlloc* alloc = &gameState->alloc;
+    void* buf = GameAlloc_Malloc(alloc, size);
 
     if (buf) {
-        THA_Ct(&gamestate->heap, buf, size);
+        THA_Ct(&gameState->heap, buf, size);
         return;
     }
 
-    THA_Ct(&gamestate->heap, NULL, 0);
-    __assert("../game.c", 0x40B);
+    THA_Ct(&gameState->heap, NULL, 0);
+    __assert("../game.c", 1035);
 }
 
-void Game_ResizeHeap(GameState* gamestate, u32 size) {
+void GameState_Realloc(GameState* gameState, size_t size) {
     GameAlloc* alloc;
-    void* buf;
-    u32 systemMaxFree;
-    u32 bytesFree;
-    u32 bytesAllocated;
+    void* gameArena;
+    size_t systemMaxFree;
+    size_t bytesFree;
+    size_t bytesAllocated;
     void* heapStart;
 
-    heapStart = gamestate->heap.bufp;
-    alloc = &gamestate->alloc;
-    THA_Dt(&gamestate->heap);
-    Gamealloc_Free(alloc, heapStart);
+    heapStart = gameState->heap.bufp;
+    alloc = &gameState->alloc;
+    THA_Dt(&gameState->heap);
+    GameAlloc_Free(alloc, heapStart);
     SystemArena_AnalyzeArena(&systemMaxFree, &bytesFree, &bytesAllocated);
     size = ((systemMaxFree - (sizeof(ArenaNode))) < size) ? (0) : (size);
-    if (!size) {
+    if (size == 0) {
         size = systemMaxFree - (sizeof(ArenaNode));
     }
 
-    if ((buf = Gamealloc_Alloc(alloc, size)) != NULL) {
-        THA_Ct(&gamestate->heap, buf, size);
+    if ((gameArena = GameAlloc_Malloc(alloc, size)) != NULL) {
+        THA_Ct(&gameState->heap, gameArena, size);
     } else {
-        THA_Ct(&gamestate->heap, 0, 0);
-        __assert("../game.c", 0x432);
+        THA_Ct(&gameState->heap, 0, 0);
+        __assert("../game.c", 1074);
     }
 }
 
-void Game_StateInit(GameState* gamestate, GameStateFunc gameStateInit, GraphicsContext* gfxCtx) {
-    gamestate->gfxCtx = gfxCtx;
-    gamestate->frames = 0U;
-    gamestate->main = NULL;
-    gamestate->destroy = NULL;
-    gamestate->running = 1;
-    gfxCtx->unk274 = D_801FBB88;
+void GameState_Init(GameState* gameState, GameStateFunc init, GraphicsContext* gfxCtx) {
+    gameState->gfxCtx = gfxCtx;
+    gameState->frames = 0U;
+    gameState->main = NULL;
+    gameState->destroy = NULL;
+    gameState->running = 1;
+    gfxCtx->viMode = D_801FBB88;
     gfxCtx->viConfigFeatures = gViConfigFeatures;
     gfxCtx->viConfigXScale = gViConfigXScale;
     gfxCtx->viConfigYScale = gViConfigYScale;
-    gamestate->nextGameStateInit = NULL;
-    gamestate->nextGameStateSize = 0U;
+    gameState->nextGameStateInit = NULL;
+    gameState->nextGameStateSize = 0U;
 
     {
         s32 requiredScopeTemp;
 
-        Gamealloc_Init(&gamestate->alloc);
-        Game_InitHeap(gamestate, 0x100000);
-        Game_SetFramerateDivisor(gamestate, 3);
+        GameAlloc_Init(&gameState->alloc);
+        GameState_InitArena(gameState, 0x100000);
+        Game_SetFramerateDivisor(gameState, 3);
 
-        gameStateInit(gamestate);
+        init(gameState);
 
         func_80140CE0(&D_801F8010);
         func_801420C0(&D_801F8020);
@@ -219,17 +220,17 @@ void Game_StateInit(GameState* gamestate, GameStateFunc gameStateInit, GraphicsC
         func_801773A0(&D_801F7FF0);
         func_8013ED9C();
 
-        osSendMesg(&gamestate->gfxCtx->unk5C, NULL, 1);
+        osSendMesg(&gameState->gfxCtx->unk5C, NULL, 1);
     }
 }
 
-void Game_StateFini(GameState* gamestate) {
+void GameState_Destroy(GameState* gameState) {
     func_80172BC0();
     func_8019E014();
-    osRecvMesg(&gamestate->gfxCtx->unk5C, 0, 1);
+    osRecvMesg(&gameState->gfxCtx->unk5C, NULL, OS_MESG_BLOCK);
 
-    if (gamestate->destroy != 0) {
-        gamestate->destroy(gamestate);
+    if (gameState->destroy != NULL) {
+        gameState->destroy(gameState);
     }
 
     func_8013EDD0();
@@ -238,28 +239,28 @@ void Game_StateFini(GameState* gamestate) {
     func_801420F4(&D_801F8020);
     func_80141900(&sMonoColors);
     func_80140900(&D_801F8048);
-    THA_Dt(&gamestate->heap);
-    Gamealloc_FreeAll(&gamestate->alloc);
+    THA_Dt(&gameState->heap);
+    GameAlloc_Cleanup(&gameState->alloc);
 }
 
-GameStateFunc Game_GetNextStateInit(GameState* gamestate) {
-    return gamestate->nextGameStateInit;
+GameStateFunc GameState_GetNextStateInit(GameState* gameState) {
+    return gameState->nextGameStateInit;
 }
 
-u32 Game_GetNextStateSize(GameState* gamestate) {
-    return gamestate->nextGameStateSize;
+size_t Game_GetNextStateSize(GameState* gameState) {
+    return gameState->nextGameStateSize;
 }
 
-u32 Game_GetShouldContinue(GameState* gamestate) {
-    return gamestate->running;
+u32 GameState_IsRunning(GameState* gameState) {
+    return gameState->running;
 }
 
-s32 Game_GetHeapFreeSize(GameState* gamestate) {
-    return THA_GetSize(&gamestate->heap);
+s32 GameState_GetArenaSize(GameState* gameState) {
+    return THA_GetSize(&gameState->heap);
 }
 
-s32 func_80173B48(GameState* gamestate) {
-    s32 result;
-    result = OS_CYCLES_TO_NSEC(gamestate->framerateDivisor * sIrqMgrRetraceTime) - OS_CYCLES_TO_NSEC(D_801FBAF0);
+s32 func_80173B48(GameState* gameState) {
+    s32 result = OS_CYCLES_TO_NSEC(gameState->framerateDivisor * sIrqMgrRetraceTime) - OS_CYCLES_TO_NSEC(D_801FBAF0);
+
     return result;
 }

src/code/gamealloc.c

@@ -1,11 +1,59 @@
 #include "global.h"
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/gamealloc/func_80173BF0.s")
+void GameAlloc_Log(GameAlloc* this) {
+    GameAllocEntry* iter;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/gamealloc/Gamealloc_Alloc.s")
+    iter = this->base.next;
+    while (iter != &this->base) {
+        iter = iter->next;
+    }
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/gamealloc/Gamealloc_Free.s")
+void* GameAlloc_Malloc(GameAlloc* this, size_t size) {
+    GameAllocEntry* ptr = SystemArena_Malloc(size + sizeof(GameAllocEntry));
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/gamealloc/Gamealloc_FreeAll.s")
+    if (ptr != NULL) {
+        ptr->size = size;
+        ptr->prev = this->head;
+        this->head->next = ptr;
+        this->head = ptr;
+        ptr->next = &this->base;
+        this->base.prev = this->head;
+        return ptr + 1;
+    } else {
+        return NULL;
+    }
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/gamealloc/Gamealloc_Init.s")
+void GameAlloc_Free(GameAlloc* this, void* data) {
+    GameAllocEntry* ptr;
+
+    if (data != NULL) {
+        ptr = &((GameAllocEntry*)data)[-1];
+        ptr->prev->next = ptr->next;
+        ptr->next->prev = ptr->prev;
+        this->head = this->base.prev;
+        SystemArena_Free(ptr);
+    }
+}
+
+void GameAlloc_Cleanup(GameAlloc* this) {
+    GameAllocEntry* next = this->base.next;
+    GameAllocEntry* cur;
+
+    while (&this->base != next) {
+        cur = next;
+        next = next->next;
+        SystemArena_Free(cur);
+    }
+
+    this->head = &this->base;
+    this->base.next = &this->base;
+    this->base.prev = &this->base;
+}
+
+void GameAlloc_Init(GameAlloc* this) {
+    this->head = &this->base;
+    this->base.next = &this->base;
+    this->base.prev = &this->base;
+}

src/code/listalloc.c

@@ -1,9 +1,62 @@
 #include "global.h"
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/listalloc/func_80174AA0.s")
+ListAlloc* ListAlloc_Init(ListAlloc* this) {
+    this->prev = NULL;
+    this->next = NULL;
+    return this;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/listalloc/func_80174AB4.s")
+void* ListAlloc_Alloc(ListAlloc* this, size_t size) {
+    ListAlloc* ptr = SystemArena_Malloc(size + sizeof(ListAlloc));
+    ListAlloc* next;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/listalloc/func_80174B20.s")
+    if (ptr == NULL) {
+        return NULL;
+    }
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/listalloc/func_80174BA0.s")
+    next = this->next;
+    if (next != NULL) {
+        next->next = ptr;
+    }
+
+    ptr->prev = next;
+    ptr->next = NULL;
+    this->next = ptr;
+
+    if (this->prev == NULL) {
+        this->prev = ptr;
+    }
+
+    return (u8*)ptr + sizeof(ListAlloc);
+}
+
+void ListAlloc_Free(ListAlloc* this, void* data) {
+    ListAlloc* ptr = &((ListAlloc*)data)[-1];
+
+    if (ptr->prev != NULL) {
+        ptr->prev->next = ptr->next;
+    }
+
+    if (ptr->next != NULL) {
+        ptr->next->prev = ptr->prev;
+    }
+
+    if (this->prev == ptr) {
+        this->prev = ptr->next;
+    }
+
+    if (this->next == ptr) {
+        this->next = ptr->prev;
+    }
+
+    SystemArena_Free(ptr);
+}
+
+void ListAlloc_FreeAll(ListAlloc* this) {
+    ListAlloc* iter = this->prev;
+
+    while (iter != NULL) {
+        ListAlloc_Free(this, (u8*)iter + sizeof(ListAlloc));
+        iter = this->prev;
+    }
+}

src/code/main.c

@@ -28,36 +28,36 @@ void Main(void* arg) {
 
     R_ENABLE_ARENA_DBG = 0;
 
-    osCreateMesgQueue(&siEventCallbackQueue, siEventCallbackBuffer, ARRAY_COUNT(siEventCallbackBuffer));
-    osSetEventMesg(OS_EVENT_SI, &siEventCallbackQueue, NULL);
+    osCreateMesgQueue(&sSiIntMsgQ, sSiIntMsgBuf, ARRAY_COUNT(sSiIntMsgBuf));
+    osSetEventMesg(OS_EVENT_SI, &sSiIntMsgQ, NULL);
 
-    osCreateMesgQueue(&mainIrqmgrCallbackQueue, mainIrqCallbackBuffer, ARRAY_COUNT(mainIrqCallbackBuffer));
+    osCreateMesgQueue(&irqMgrMsgQ, irqMgrMsgBuf, ARRAY_COUNT(irqMgrMsgBuf));
 
     StackCheck_Init(&schedStackEntry, schedStack, schedStack + sizeof(schedStack), 0, 0x100, "sched");
     Sched_Init(&gSchedContext, schedStack + sizeof(schedStack), Z_PRIORITY_SCHED, D_8009B290, 1, &gIrqMgr);
 
     CIC6105_AddRomInfoFaultPage();
 
-    IrqMgr_AddClient(&gIrqMgr, &mainIrqmgrCallbackNode, &mainIrqmgrCallbackQueue);
+    IrqMgr_AddClient(&gIrqMgr, &irqClient, &irqMgrMsgQ);
 
     StackCheck_Init(&audioStackEntry, audioStack, audioStack + sizeof(audioStack), 0, 0x100, "audio");
     AudioMgr_Init(&audioContext, audioStack + sizeof(audioStack), Z_PRIORITY_AUDIOMGR, 0xA, &gSchedContext, &gIrqMgr);
 
     StackCheck_Init(&padmgrStackEntry, padmgrStack, padmgrStack + sizeof(padmgrStack), 0, 0x100, "padmgr");
-    Padmgr_Start(&siEventCallbackQueue, &gIrqMgr, 7, Z_PRIORITY_PADMGR, padmgrStack + sizeof(padmgrStack));
+    PadMgr_Init(&sSiIntMsgQ, &gIrqMgr, 7, Z_PRIORITY_PADMGR, padmgrStack + sizeof(padmgrStack));
 
     AudioMgr_Unlock(&audioContext);
 
-    StackCheck_Init(&graphStackEntry, graphStack, graphStack + sizeof(graphStack), 0, 0x100, "graph");
-    osCreateThread(&graphOSThread, Z_THREAD_ID_GRAPH, Graph_ThreadEntry, arg, graphStack + sizeof(graphStack),
+    StackCheck_Init(&sGraphStackInfo, sGraphStack, sGraphStack + sizeof(sGraphStack), 0, 0x100, "graph");
+    osCreateThread(&sGraphThread, Z_THREAD_ID_GRAPH, Graph_ThreadEntry, arg, sGraphStack + sizeof(sGraphStack),
                    Z_PRIORITY_GRAPH);
-    osStartThread(&graphOSThread);
+    osStartThread(&sGraphThread);
 
     exit = false;
 
     while (!exit) {
         msg = NULL;
-        osRecvMesg(&mainIrqmgrCallbackQueue, (OSMesg)&msg, OS_MESG_BLOCK);
+        osRecvMesg(&irqMgrMsgQ, (OSMesg)&msg, OS_MESG_BLOCK);
         if (msg == NULL) {
             break;
         }
@@ -72,6 +72,6 @@ void Main(void* arg) {
         }
     }
 
-    IrqMgr_RemoveClient(&gIrqMgr, &mainIrqmgrCallbackNode);
-    osDestroyThread(&graphOSThread);
+    IrqMgr_RemoveClient(&gIrqMgr, &irqClient);
+    osDestroyThread(&sGraphThread);
 }

src/code/padmgr.c

@@ -54,4 +54,4 @@
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/padmgr/Padmgr_ThreadEntry.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/padmgr/Padmgr_Start.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/padmgr/PadMgr_Init.s")

src/code/sys_matrix.c

@@ -1,92 +1,92 @@
 #include "global.h"
 
-void SysMatrix_StateAlloc(GameState* gamestate) {
-    sMatrixStack = (MtxF*)THA_AllocEndAlign16(&gamestate->heap, 0x500);
+void Matrix_StateAlloc(GameState* gameState) {
+    sMatrixStack = (MtxF*)THA_AllocEndAlign16(&gameState->heap, 0x500);
     sCurrentMatrix = sMatrixStack;
 }
 
-void SysMatrix_StatePush(void) {
+void Matrix_StatePush(void) {
     MtxF* prev = sCurrentMatrix;
 
     sCurrentMatrix++;
     Matrix_MtxFCopy(sCurrentMatrix, prev);
 }
 
-void SysMatrix_StatePop(void) {
+void Matrix_StatePop(void) {
     sCurrentMatrix--;
 }
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_CopyCurrentState.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_CopyCurrentState.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_SetCurrentState.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_SetCurrentState.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_GetCurrentState.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_GetCurrentState.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertMatrix.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertMatrix.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertTranslation.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertTranslation.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_Scale.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertXRotation_s.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertXRotation_s.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertXRotation_f.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertXRotation_f.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_RotateStateAroundXAxis.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_RotateStateAroundXAxis.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_SetStateXRotation.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_SetStateXRotation.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_RotateY.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertYRotation_f.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertYRotation_f.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertZRotation_s.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertZRotation_s.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertZRotation_f.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertZRotation_f.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertRotation.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertRotation.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_RotateAndTranslateState.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_JointPosition.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_SetStateRotationAndTranslation.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_SetStateRotationAndTranslation.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_ToRSPMatrix.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_ToRSPMatrix.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_GetStateAsRSPMatrix.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_ToMtx.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_NewMtx.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_AppendToPolyOpaDisp.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_AppendToPolyOpaDisp.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_MultiplyVector3fByState.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_MultiplyVector3fByState.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_GetStateTranslation.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_GetStateTranslation.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_GetStateTranslationAndScaledX.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_GetStateTranslationAndScaledX.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_GetStateTranslationAndScaledY.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_GetStateTranslationAndScaledY.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_GetStateTranslationAndScaledZ.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_GetStateTranslationAndScaledZ.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_MultiplyVector3fXZByCurrentState.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_MultiplyVector3fXZByCurrentState.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_MtxFCopy.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_FromRSPMatrix.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_FromRSPMatrix.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_MultiplyVector3fByMatrix.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_MultiplyVector3fByMatrix.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_TransposeXYZ.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_TransposeXYZ.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_NormalizeXYZ.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_NormalizeXYZ.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/func_8018219C.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/func_801822C4.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertRotationAroundUnitVector_f.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertRotationAroundUnitVector_f.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertRotationAroundUnitVector_s.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertRotationAroundUnitVector_s.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/func_80182C90.s")