diff --git a/include/functions.h b/include/functions.h
index 48eef2922e..239bb91c67 100644
--- a/include/functions.h
+++ b/include/functions.h
@@ -439,7 +439,7 @@ void osViSetEvent(OSMesgQueue* mq, OSMesg m, u32 retraceCount);
 s32 osPfsIsPlug(OSMesgQueue* queue, u8* pattern);
 // void func_800925CC(void);
 // void func_80092680(void);
-// void __osVoiceGetStatus(void);
+s32 __osVoiceGetStatus(OSMesgQueue* mq, s32 port, u8* status);
 OSPiHandle* osCartRomInit(void);
 // void func_80092A80(void);
 // s32 __osPfsSelectBank(OSPfs* pfs, UNK_TYPE4 param_2);
@@ -563,7 +563,7 @@ void func_800AE5A0(GlobalContext* globalCtx);
 // void func_800AE5E4(void);
 void func_800AE778(GlobalContext* globalCtx, Color_RGBA8* color, s16 param_3, s16 param_4);
 void func_800AE8EC(GlobalContext* globalCtx);
-void func_800AE930(CollisionContext* bgCtxt, s32 param_2, float* param_3, f32 param_4, s16 param_5, CollisionPoly* param_6, s32 param_7);
+void func_800AE930(CollisionContext* colCtx, s32 param_2, float* param_3, f32 param_4, s16 param_5, CollisionPoly* param_6, s32 param_7);
 // void func_800AEF44(void);
 void EffectTireMark_InitParticle(EffTireMarkParticle* particle);
 void EffectTireMark_Init(EffTireMarkParams* params, EffTireMarkInit* init);
@@ -643,16 +643,20 @@ void EffectSsKiraKira_SpawnDispersed (GlobalContext * globalCtx, Vec3f * pos, Ve
 // void EffectSsGSpk_SpawnRandColor(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE2 param_6, UNK_TYPE2 param_7);
 // void EffectSsGSpk_SpawnSmall(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7);
 // void EffectSsDFire_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, Vec3f* pzParm3, Vec3f* pzParm4, UNK_TYPE2 param_5, UNK_TYPE2 param_6, UNK_TYPE2 param_7, UNK_TYPE2 param_8, UNK_TYPE2 param_9, UNK_TYPE4 param_10);
-// void EffectSsBubble_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, UNK_TYPE4 uParm3, UNK_TYPE4 uParm4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
+void EffectSsBubble_Spawn(GlobalContext* globalCtx, Vec3f* pos, f32 yPosOffset, f32 yPosRandScale, f32 xzPosRandScale,
+                          f32 scale);
 void EffectSsGRipple_Spawn(GlobalContext* globalCtx, Vec3f* pos, s16 radius, s16 radiusMax, s16 life);
 void EffectSsGSplash_Spawn(GlobalContext* globalCtx, Vec3f* pos, Color_RGBA8* primColor, Color_RGBA8* envColor,
                            s16 type, s16 scale);
 // void EffectSsGFire_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2);
 // void EffectSsLightning_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, Color_RGBA8* pzParm3, Color_RGBA8* pzParm4, UNK_TYPE2 param_5, UNK_TYPE2 param_6, UNK_TYPE2 param_7, UNK_TYPE2 param_8);
 // void EffectSsDtBubble_SpawnColorProfile(UNK_TYPE4 param_1, Vec3f* param_2, Vec3f* param_3, Vec3f* param_4, UNK_TYPE2 param_5, UNK_TYPE2 param_6, UNK_TYPE2 param_7, UNK_TYPE2 param_8);
-// void EffectSsDtBubble_SpawnCustomColor(UNK_TYPE4 uParm1, Vec3f* pzParm2, Vec3f* pzParm3, Vec3f* pzParm4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE2 param_7, UNK_TYPE2 param_8, UNK_TYPE2 param_9);
-// void EffectSsHahen_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, Vec3f* pzParm3, Vec3f* pzParm4, UNK_TYPE2 param_5, UNK_TYPE2 param_6, UNK_TYPE2 param_7, UNK_TYPE2 param_8, UNK_TYPE4 param_9);
-// void EffectSsHahen_SpawnBurst(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5, UNK_TYPE2 param_6, UNK_TYPE2 param_7, UNK_TYPE2 param_8, UNK_TYPE2 param_9, UNK_TYPE4 param_10);
+void EffectSsDtBubble_SpawnCustomColor(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity, Vec3f* accel,
+                                       Color_RGBA8* primColor, Color_RGBA8* envColor, s16 scale, s16 life, s16 randXZ);
+void EffectSsHahen_Spawn(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity, Vec3f* accel, s16 unused, s16 scale,
+                         s16 objId, s16 life, Gfx* dList);
+void EffectSsHahen_SpawnBurst(GlobalContext* globalCtx, Vec3f* pos, f32 burstScale, s16 unused, s16 scale,
+                              s16 randScaleRange, s16 count, s16 objId, s16 life, Gfx* dList);
 // void func_800B2364(void);
 // void EffectSsStick_Spawn(UNK_TYPE4 uParm1, UNK_PTR puParm2, UNK_TYPE2 uParm3);
 // void EffectSsSibuki_Spawn(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5, UNK_TYPE2 param_6, UNK_TYPE2 param_7);
@@ -672,7 +676,8 @@ void EffectSsKakera_Spawn(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity,
 // void EffectSsEnIce_SpawnFlyingVec3f(UNK_TYPE4 uParm1, Actor* pzParm2, Vec3f* pzParm3, Color_RGBA8* pzParm4, Color_RGBA8* param_5, UNK_TYPE4 param_6);
 // void func_800B2B44(void);
 // void func_800B2B7C(void);
-// void EffectSsEnIce_Spawn(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8);
+void EffectSsEnIce_Spawn(GlobalContext* globalCtx, Vec3f* pos, f32 scale, Vec3f* velocity, Vec3f* accel,
+                         Color_RGBA8* primColor, Color_RGBA8* envColor, s32 life);
 // void EffectSsFireTail_Spawn(UNK_TYPE4 uParm1, UNK_TYPE4 uParm2, Vec3f* pzParm3, UNK_TYPE4 uParm4, Vec3f* param_5, UNK_TYPE2 param_6, Color_RGBA8* param_7, Color_RGBA8* param_8, UNK_TYPE2 param_9, UNK_TYPE2 param_10, UNK_TYPE4 param_11);
 // void EffectSsFireTail_SpawnFlame(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5, UNK_TYPE4 param_6);
 // void EffectSsFireTail_SpawnFlameOnPlayer(void);
@@ -681,17 +686,18 @@ void EffectSsKakera_Spawn(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity,
 // void EffectSsExtra_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, Vec3f* pzParm3, Vec3f* pzParm4, UNK_TYPE2 param_5, UNK_TYPE2 param_6);
 void EffectSsDeadDb_Spawn(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity, Vec3f* accel, Color_RGBA8* prim, Color_RGBA8* env,
                           s16 scale, s16 scaleStep, s32 unk);
-// void func_800B3030(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5, UNK_TYPE2 param_6, UNK_TYPE4 param_7);
+void func_800B3030(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity, Vec3f* accel, s16 scale, s16 scaleStep,
+                   s32 colorIndex);
 // void EffectSsDeadDd_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, Vec3f* pzParm3, Vec3f* pzParm4, UNK_TYPE1* param_5, UNK_TYPE1* param_6, UNK_TYPE2 param_7, UNK_TYPE2 param_8, UNK_TYPE2 param_9, UNK_TYPE4 param_10);
 // void EffectSsDeadDs_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, Vec3f* pzParm3, Vec3f* pzParm4, UNK_TYPE2 param_5, UNK_TYPE2 param_6, UNK_TYPE2 param_7, UNK_TYPE4 param_8);
 // void func_800B31BC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5, UNK_TYPE4 param_6);
-// void EffectSsIceSmoke_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, Vec3f* pzParm3, Vec3f* pzParm4, UNK_TYPE2 param_5);
+void EffectSsIceSmoke_Spawn(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity, Vec3f* accel, s16 scale);
 // void EffectSsIceBlock_Spawn(UNK_TYPE4 uParm1, Vec3f* pzParm2, Vec3f* pzParm3, Vec3f* pzParm4, UNK_TYPE2 param_5);
-void func_800B32D0(GameState* ctxt);
+void func_800B32D0(GameState* gamestate);
 // void func_800B3644(void);
 void DLF_LoadGameState(GameStateOverlay* gameState);
 void DLF_FreeGameState(GameStateOverlay* gameState);
-void Actor_PrintLists(ActorContext* actCtxt);
+void Actor_PrintLists(ActorContext* actorCtx);
 void ActorShape_Init(ActorShape* actorShape, f32 yOffset, ActorShadowFunc func, f32 scale);
 void ActorShadow_Draw(Actor* actor, Lights* mapper, GlobalContext* globalCtx, Gfx* displayList, Color_RGBA8* color);
 void func_800B3FC0(Actor* actor, Lights* mapper, GlobalContext* globalCtx);
@@ -707,8 +713,8 @@ void func_800B4EDC(GlobalContext* globalCtx, Vec3f* pzParm2, Vec3f* pzParm3, f32
 // void func_800B4F40(TargetContext* targetContext, s32 param_2, UNK_TYPE4 param_3, UNK_TYPE4 param_4, UNK_TYPE4 param_5);
 void func_800B4F78(TargetContext* targetContext, u8 type, GlobalContext* globalCtx);
 void func_800B5040(TargetContext* targetContext, Actor* actor, u8 type, GlobalContext* globalCtx);
-void Actor_TargetContextInit(TargetContext* targetCtxt, Actor* actor, GlobalContext* globalCtx);
-void func_800B5208(TargetContext* targetCtxt, GlobalContext* globalCtx);
+void Actor_TargetContextInit(TargetContext* targetCtx, Actor* actor, GlobalContext* globalCtx);
+void func_800B5208(TargetContext* targetCtx, GlobalContext* globalCtx);
 void func_800B5814(TargetContext* targetContext, ActorPlayer* player, Actor* param_3, GlobalContext* globalCtx);
 u32 Flags_GetSwitch(GlobalContext* globalCtx, s32 flag);
 void Actor_SetSwitchFlag(GlobalContext* globalCtx, s32 flag);
@@ -725,12 +731,12 @@ void Actor_SetRoomClearedTemp(GlobalContext* globalCtx, u32 roomNumber);
 void Actor_UnsetRoomClearedTemp(GlobalContext* globalCtx, u32 roomNumber);
 u32 Actor_GetCollectibleFlag(GlobalContext* globalCtx, s32 index);
 void Actor_SetCollectibleFlag(GlobalContext* globalCtx, s32 index);
-void Actor_TitleCardContextInit(GlobalContext* globalCtx, TitleCardContext* titleCtxt);
-void Actor_TitleCardCreate(GlobalContext* globalCtx, TitleCardContext* titleCtxt, u32 texture, s16 param_4, s16 param_5, u8 param_6, u8 param_7);
+void Actor_TitleCardContextInit(GlobalContext* globalCtx, TitleCardContext* titleCardCtx);
+void Actor_TitleCardCreate(GlobalContext* globalCtx, TitleCardContext* titleCardCtx, u32 texture, s16 param_4, s16 param_5, u8 param_6, u8 param_7);
 // void Actor_Nop800B5E50(UNK_TYPE4 param_1, UNK_TYPE4 param_2, UNK_TYPE4 param_3, UNK_TYPE4 param_4);
-void Actor_TitleCardUpdate(GlobalContext* globalCtx, TitleCardContext* titleCtxt);
-void Actor_TitleCardDraw(GlobalContext* globalCtx, TitleCardContext* titleCtxt);
-// UNK_TYPE4 func_800B6434(GlobalContext* globalCtx, TitleCardContext* titleCtxt);
+void Actor_TitleCardUpdate(GlobalContext* globalCtx, TitleCardContext* titleCardCtx);
+void Actor_TitleCardDraw(GlobalContext* globalCtx, TitleCardContext* titleCardCtx);
+// UNK_TYPE4 func_800B6434(GlobalContext* globalCtx, TitleCardContext* titleCardCtx);
 // UNK_TYPE4 func_800B645C(void);
 void func_800B6468(GlobalContext* globalCtx);
 void func_800B6474(GlobalContext* globalCtx);
@@ -825,7 +831,7 @@ UNK_TYPE4 func_800B8A1C(Actor* actor, GlobalContext* globalCtx, s32 iParm3, f32
 // void func_800B8B84(void);
 // void func_800B8BB0(void);
 // void func_800B8BD0(void);
-// void func_800B8BFC(void);
+s32 func_800B8BFC(Actor* actor, GlobalContext* globalCtx);
 // void func_800B8C20(void);
 void func_800B8C50(Actor* actor, GlobalContext* globalCtx);
 // void func_800B8C78(void);
@@ -836,20 +842,21 @@ void func_800B8C50(Actor* actor, GlobalContext* globalCtx);
 void func_800B8D98(GlobalContext* globalCtx, Actor* actor, f32 param_3, s16 param_4, f32 param_5);
 // void func_800B8DD4(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
 // void func_800B8E1C(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
-// void func_800B8E58(void);
-void Audio_PlayActorSound2(Actor* actor, s16 sfxId);
+void func_800B8E58(Actor* actor, u16 sfxId);
+void Audio_PlayActorSound2(Actor* actor, u16 sfxId);
 // void func_800B8FC0(void);
-void func_800B9010(Actor* actor, s16 sfxId);
+void func_800B8F98(Actor* actor, u16 sfxId);
+void func_800B9010(Actor* actor, u16 sfxId);
 // void func_800B9038(void);
 // void func_800B9084(void);
 void func_800B9098(Actor* actor);
 s32 func_800B90AC(GlobalContext* globalCtx, Actor* actor, UNK_TYPE arg2, UNK_TYPE arg3, UNK_TYPE arg4);
 // void func_800B90F4(void);
-void func_800B9120(ActorContext* actCtxt);
-// void Actor_Init(GlobalContext* globalCtx, ActorContext* actCtxt, UNK_TYPE4 uParm3);
-void func_800B9334(GlobalContext* globalCtx, ActorContext* actCtxt);
+void func_800B9120(ActorContext* actorCtx);
+// void Actor_Init(GlobalContext* globalCtx, ActorContext* actorCtx, UNK_TYPE4 uParm3);
+void func_800B9334(GlobalContext* globalCtx, ActorContext* actorCtx);
 Actor* Actor_UpdateActor(s800B948C* params);
-void Actor_UpdateAll(GlobalContext* globalCtx, ActorContext* actCtxt);
+void Actor_UpdateAll(GlobalContext* globalCtx, ActorContext* actorCtx);
 void Actor_DrawActor(GlobalContext* globalCtx, Actor* actor);
 void func_800B9D1C(Actor* actor);
 void Actor_DrawAllSetup(GlobalContext* globalCtx);
@@ -858,21 +865,21 @@ s32 Actor_RecordUndrawnActor(GlobalContext* globalCtx, Actor* actor);
 void func_800B9EF4(GlobalContext* globalCtx, s32 numActors, Actor** actors);
 s32 func_800BA2D8(GlobalContext* globalCtx, Actor* actor);
 s32 func_800BA2FC(GlobalContext* globalCtx, Actor* actor, Vec3f* param_3, f32 param_4);
-void Actor_DrawAll(GlobalContext* globalCtx, ActorContext* aCtxt);
-void func_800BA6FC(GlobalContext* globalCtx, ActorContext* aCtxt);
-void func_800BA798(GlobalContext* globalCtx, ActorContext* aCtxt);
-void func_800BA8B8(GlobalContext* globalCtx, ActorContext* actCtxt);
+void Actor_DrawAll(GlobalContext* globalCtx, ActorContext* actorCtx);
+void func_800BA6FC(GlobalContext* globalCtx, ActorContext* actorCtx);
+void func_800BA798(GlobalContext* globalCtx, ActorContext* actorCtx);
+void func_800BA8B8(GlobalContext* globalCtx, ActorContext* actorCtx);
 // void func_800BA9B4(void);
-void Actor_InsertIntoTypeList(ActorContext* actCtxt, Actor* actor, u8 type);
-Actor* Actor_RemoveFromTypeList(GlobalContext* globalCtx, ActorContext* actCtxt, Actor* actor);
+void Actor_InsertIntoTypeList(ActorContext* actorCtx, Actor* actor, u8 type);
+Actor* Actor_RemoveFromTypeList(GlobalContext* globalCtx, ActorContext* actorCtx, Actor* actor);
 void Actor_FreeOverlay(ActorOverlay* entry);
-Actor* Actor_Spawn(ActorContext* actCtxt, GlobalContext* globalCtx, s16 index, f32 x, f32 y, f32 z, s16 rotX, s16 rotY, s16 rotZ, s16 sParm10);
-ActorInit* Actor_LoadOverlay(ActorContext* actCtxt, s16 index);
-Actor* Actor_SpawnWithParentAndCutscene(ActorContext* actCtxt, GlobalContext* globalCtx, s16 index, f32 x, f32 y, f32 z, s16 rotX, s16 rotY, s16 rotZ, s16 variable, u32 cutscene, s32 param_12, Actor* parent);
-Actor* Actor_SpawnWithParent(ActorContext* actCtxt, Actor* parent, GlobalContext* globalCtx, s16 index, f32 x, f32 y, f32 z, s16 rotX, s16 rotY, s16 rotZ, s16 variable);
-void Actor_SpawnTransitionActors(GlobalContext* globalCtx, ActorContext* actCtxt);
-void func_800BB2D0(ActorContext* aCtxt, u16* param_2, GlobalContext* globalCtx);
-Actor* func_800BB498(ActorContext* actCtxt, Actor* actor, GlobalContext* globalCtx);
+Actor* Actor_Spawn(ActorContext* actorCtx, GlobalContext* globalCtx, s16 index, f32 x, f32 y, f32 z, s16 rotX, s16 rotY, s16 rotZ, s16 sParm10);
+ActorInit* Actor_LoadOverlay(ActorContext* actorCtx, s16 index);
+Actor* Actor_SpawnWithParentAndCutscene(ActorContext* actorCtx, GlobalContext* globalCtx, s16 index, f32 x, f32 y, f32 z, s16 rotX, s16 rotY, s16 rotZ, s16 variable, u32 cutscene, s32 param_12, Actor* parent);
+Actor* Actor_SpawnWithParent(ActorContext* actorCtx, Actor* parent, GlobalContext* globalCtx, s16 index, f32 x, f32 y, f32 z, s16 rotX, s16 rotY, s16 rotZ, s16 variable);
+void Actor_SpawnTransitionActors(GlobalContext* globalCtx, ActorContext* actorCtx);
+void func_800BB2D0(ActorContext* actorCtx, u16* param_2, GlobalContext* globalCtx);
+Actor* func_800BB498(ActorContext* actorCtx, Actor* actor, GlobalContext* globalCtx);
 // void func_800BB59C(void);
 // void func_800BB604(void);
 // void func_800BB8EC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
@@ -881,7 +888,7 @@ void func_800BBA88(GlobalContext* globalCtx, Actor* actor);
 void func_800BBB74(s16* arg1, UNK_TYPE1 arg2, UNK_TYPE1 arg3, UNK_TYPE4 arg4);
 // void func_800BBC20(void);
 // void func_800BBCEC(void);
-// void func_800BBDAC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE2 param_7, UNK_TYPE2 param_8, UNK_TYPE1 param_9);
+// void func_800BBDAC(GlobalContext* globalCtx, UNK_PTR param_2, UNK_PTR param_3, f32 param_4, UNK_TYPE4 param_5, f32 param_6, s16 param_7, s16 param_8, u8 param_9);
 void func_800BBFB0(GlobalContext* globalCtx, Vec3f* position, f32 param3, s32 param_4, s16 param_5, s16 param_6, u8 param_7);
 void func_800BC154(GlobalContext* globalCtx, ActorContext* actorCtx, Actor* actor, u8 actorCategory);
 // void func_800BC188(void);
@@ -948,7 +955,7 @@ void BgCheck_PolygonGetNormal(CollisionPoly* polygon, f32* normalX, f32* normalY
 void func_800C0094(struct CollisionPoly* param_1, f32 xOffset, f32 yOffset, f32 zOffset, MtxF* matrix);
 f32 func_800C01B8(CollisionPoly* param_1, Vec3f* param_2);
 void BgCheck_CreateColTriParamsFromPolygon(CollisionPoly* polygon, Vec3s* vertices, TriNorm* tri);
-void func_800C02C0(CollisionPoly* poly, s32 index, CollisionContext* bgCtxt, TriNorm* tri);
+void func_800C02C0(CollisionPoly* poly, s32 index, CollisionContext* colCtx, TriNorm* tri);
 // void func_800C0340(CollisionPoly* param_1, Vec3s* param_2, UNK_TYPE4 param_3, UNK_TYPE4 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
 // UNK_TYPE4 func_800C0474(CollisionPoly* param_1, Vec3s* param_2, UNK_TYPE4 param_3, UNK_TYPE4 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
 // void func_800C0668(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
@@ -956,8 +963,8 @@ void func_800C02C0(CollisionPoly* poly, s32 index, CollisionContext* bgCtxt, Tri
 // void func_800C074C(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
 // void func_800C07F0(void);
 void BgCheck_PolygonCollidesWithSphere(CollisionPoly* polygon, Vec3s* verticies, Vec3f* pos, f32 readius);
-void BgCheck_ScenePolygonListsInsertSorted(CollisionContext* bgCtxt, u16* head, CollisionPoly* polygons, Vec3s* vertices, s16 index);
-void BgCheck_ScenePolygonListsInsert(StaticLookup* subdivision, CollisionContext* bgCtxt, CollisionPoly* polygons, Vec3s* vertices, s16 index);
+void BgCheck_ScenePolygonListsInsertSorted(CollisionContext* colCtx, u16* head, CollisionPoly* polygons, Vec3s* vertices, s16 index);
+void BgCheck_ScenePolygonListsInsert(StaticLookup* subdivision, CollisionContext* colCtx, CollisionPoly* polygons, Vec3s* vertices, s16 index);
 // void func_800C0E74(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8, UNK_TYPE4 param_9, UNK_TYPE4 param_10);
 // void func_800C10FC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8, UNK_TYPE4 param_9);
 // void func_800C1238(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE1 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8, UNK_TYPE4 param_9, UNK_TYPE4 param_10, UNK_TYPE4 param_11);
@@ -970,27 +977,27 @@ void BgCheck_ScenePolygonListsInsert(StaticLookup* subdivision, CollisionContext
 // void func_800C2460(void);
 // void func_800C2514(void);
 // void func_800C25E0(void);
-void BgCheck_GetPolyMinSubdivisions(CollisionContext* bgCtxt, Vec3f* min, s32* xSubdivision, s32* ySubdivision, s32* zSubdivision);
-void BgCheck_GetPolyMaxSubdivisions(CollisionContext* bgCtxt, Vec3f* max, s32* xSubdivision, s32* ySubdivision, s32* zSubdivision);
-void BgCheck_GetPolyMinMaxSubdivisions(CollisionContext* bgCtxt, Vec3s* vertices, CollisionPoly* polygons, s32* minX, s32* minY, s32* minZ, s32* maxX, s32* maxY, s32* maxZ, s16 index);
+void BgCheck_GetPolyMinSubdivisions(CollisionContext* colCtx, Vec3f* min, s32* xSubdivision, s32* ySubdivision, s32* zSubdivision);
+void BgCheck_GetPolyMaxSubdivisions(CollisionContext* colCtx, Vec3f* max, s32* xSubdivision, s32* ySubdivision, s32* zSubdivision);
+void BgCheck_GetPolyMinMaxSubdivisions(CollisionContext* colCtx, Vec3s* vertices, CollisionPoly* polygons, s32* minX, s32* minY, s32* minZ, s32* maxX, s32* maxY, s32* maxZ, s16 index);
 // UNK_TYPE4 func_800C2BE0(Vec3f* param_1, Vec3f* param_2, CollisionPoly* polygons, Vec3s* vertices, s16 index);
-u32 BgCheck_SplitScenePolygonsIntoSubdivisions(CollisionContext* bgCtxt, GlobalContext* globalCtx, StaticLookup* subdivisions);
+u32 BgCheck_SplitScenePolygonsIntoSubdivisions(CollisionContext* colCtx, GlobalContext* globalCtx, StaticLookup* subdivisions);
 s32 BgCheck_GetIsDefaultSpecialScene(GlobalContext* globalCtx);
 s32 BgCheck_GetSpecialSceneMaxMemory(s32 sceneId, u32* maxMemory);
 void BgCheck_CalcSubdivisionSize(f32 min, s32 subdivisions, f32* max, f32* subdivisionSize, f32* inverseSubdivisionSize);
 s32 BgCheck_GetSpecialSceneMaxObjects(GlobalContext* globalCtx, u32* maxNodes, u32* maxPolygons, u32* maxVertices);
-void BgCheck_Init(CollisionContext* bgCtxt, GlobalContext* globalCtx, CollisionHeader* mesh);
-void func_800C3C00(CollisionContext* bgCtxt, u32 param_2);
-void func_800C3C14(CollisionContext* bgCtxt, u32 param_2);
-CollisionHeader* BgCheck_GetActorMeshHeader(CollisionContext* bgCtxt, s32 index);
+void BgCheck_Init(CollisionContext* colCtx, GlobalContext* globalCtx, CollisionHeader* mesh);
+void func_800C3C00(CollisionContext* colCtx, u32 param_2);
+void func_800C3C14(CollisionContext* colCtx, u32 param_2);
+CollisionHeader* BgCheck_GetActorMeshHeader(CollisionContext* colCtx, s32 index);
 // void func_800C3C94(void);
-f32 func_800C3D50(s32 arg0, CollisionContext* bgCtxt, s32 arg2, CollisionPoly** arg3, s32* arg4, Vec3f* pos, Actor* actor, s32 arg7, f32 arg8, s32 arg9);
+f32 func_800C3D50(s32 arg0, CollisionContext* colCtx, s32 arg2, CollisionPoly** arg3, s32* arg4, Vec3f* pos, Actor* actor, s32 arg7, f32 arg8, s32 arg9);
 // void func_800C3F40(void);
 // void func_800C3FA0(void);
 // void func_800C4000(void);
 // void func_800C4058(void);
 // void func_800C40B4(void);
-f32 func_800C411C(CollisionContext* bgCtxt, CollisionPoly** arg1, s32* arg2, Actor* actor, Vec3f* pos);
+f32 func_800C411C(CollisionContext* colCtx, CollisionPoly** arg1, s32* arg2, Actor* actor, Vec3f* pos);
 // void func_800C4188(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
 // void func_800C41E4(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
 // void func_800C4240(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
@@ -1000,7 +1007,7 @@ f32 func_800C411C(CollisionContext* bgCtxt, CollisionPoly** arg1, s32* arg2, Act
 // void func_800C4488(void);
 // void func_800C44F0(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
 // void func_800C455C(void);
-s32 func_800C45C4(CollisionContext* bgCtxt, u32 param_2, Vec3f* param_3, Vec3f* param_4, Vec3f* param_5, f32 param_6, s32* param_7, s32* param_8, DynaPolyActor* param_9, f32 param_10, u8 param_11);
+s32 func_800C45C4(CollisionContext* colCtx, u32 param_2, Vec3f* param_3, Vec3f* param_4, Vec3f* param_5, f32 param_6, s32* param_7, s32* param_8, DynaPolyActor* param_9, f32 param_10, u8 param_11);
 // void func_800C4C74(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7);
 // void func_800C4CD8(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8);
 // void func_800C4D3C(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8, UNK_TYPE4 param_9);
@@ -1047,7 +1054,7 @@ s32 BgCheck_IsActorMeshIndexValid(s32 index);
 void BgCheck_DynaInit(GlobalContext* globalCtx, DynaCollisionContext* param_2);
 void BgCheck_DynaAlloc(GlobalContext* globalCtx, DynaCollisionContext* dyna);
 s32 BgCheck_AddActorMesh(GlobalContext* globalCtx, DynaCollisionContext* dyna, DynaPolyActor* actor, CollisionHeader* header);
-DynaPolyActor* BgCheck_GetActorOfMesh(CollisionContext* bgCtxt, s32 index);
+DynaPolyActor* BgCheck_GetActorOfMesh(CollisionContext* colCtx, s32 index);
 void func_800C62BC(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 index);
 void func_800C6314(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 index);
 void func_800C636C(GlobalContext* globalCtx, DynaCollisionContext* dyna, s32 index);
@@ -1076,45 +1083,45 @@ void BgCheck_UpdateAllActorMeshes(GlobalContext* globalCtx, DynaCollisionContext
 // void func_800C9380(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE2 param_8);
 void BgCheck_RelocateMeshHeaderPointers(CollisionHeader* header);
 void BgCheck_RelocateMeshHeader(CollisionHeader* meshSegPtr, CollisionHeader** param_2);
-void BgCheck_RelocateAllMeshHeaders(CollisionContext* bgCtxt, GlobalContext* globalCtx);
+void BgCheck_RelocateAllMeshHeaders(CollisionContext* colCtx, GlobalContext* globalCtx);
 // void func_800C9640(void);
-u32 BgCheck_GetPolygonAttributes(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index, s32 attributeIndex);
-u32 func_800C9704(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
+u32 BgCheck_GetPolygonAttributes(CollisionContext* colCtx, CollisionPoly* polygon, s32 index, s32 attributeIndex);
+u32 func_800C9704(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
 // void func_800C9728(void);
-// UNK_TYPE4 func_800C9770(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
+// UNK_TYPE4 func_800C9770(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
 // void func_800C97F8(void);
-// UNK_TYPE4 func_800C9844(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
+// UNK_TYPE4 func_800C9844(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
 // void func_800C98CC(void);
-// UNK_TYPE4 func_800C9924(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C99AC(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C99D4(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C99FC(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C9A24(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C9A4C(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C9A7C(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C9AB0(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C9AE4(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C9B18(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C9B40(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C9B68(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C9B90(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C9BB8(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C9BDC(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-// u32 func_800C9C24(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index, UNK_TYPE4 param_4);
-u32 func_800C9C74(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C9C9C(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C9CC4(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C9CEC(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
+// UNK_TYPE4 func_800C9924(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C99AC(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C99D4(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C99FC(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C9A24(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C9A4C(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C9A7C(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C9AB0(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C9AE4(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C9B18(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C9B40(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C9B68(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C9B90(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C9BB8(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C9BDC(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+// u32 func_800C9C24(CollisionContext* colCtx, CollisionPoly* polygon, s32 index, UNK_TYPE4 param_4);
+u32 func_800C9C74(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C9C9C(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C9CC4(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C9CEC(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
 // void func_800C9D14(void);
 // void func_800C9D50(void);
 u32 func_800C9D8C(CollisionContext* param_1, CollisionPoly* param_2, s32 param_3);
 // void func_800C9DDC(void);
-u32 func_800C9E18(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C9E40(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-u32 func_800C9E88(CollisionContext* bgCtxt, CollisionPoly* polygon, s32 index);
-// void func_800C9EBC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7);
-// void func_800CA1AC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
-void func_800CA1E8(GlobalContext* globalCtx, CollisionContext* bgCtxt, f32 arg2, f32 arg3, f32* arg4, UNK_PTR arg5);
+u32 func_800C9E18(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C9E40(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+u32 func_800C9E88(CollisionContext* colCtx, CollisionPoly* polygon, s32 index);
+// void func_800C9EBC(GlobalContext* globalCtx, CollisionContext* colCtx, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7);
+// void func_800CA1AC(GlobalContext* globalCtx, CollisionContext* colCtx, f32 param_3, f32 param_4, f32* param_5, UNK_PTR param_6);
+void func_800CA1E8(GlobalContext* globalCtx, CollisionContext* colCtx, f32 arg2, f32 arg3, f32* arg4, UNK_PTR arg5);
 // void func_800CA22C(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
 // void func_800CA568(void);
 // void func_800CA634(void);
@@ -1124,18 +1131,18 @@ void func_800CA1E8(GlobalContext* globalCtx, CollisionContext* bgCtxt, f32 arg2,
 // void func_800CA6F0(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7);
 // void func_800CA9D0(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
 // void func_800CAA14(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
-void BgCheck2_UpdateActorPosition(CollisionContext* bgCtxt, s32 index, Actor* actor);
-void BgCheck2_UpdateActorYRotation(CollisionContext* bgCtxt, s32 index, Actor* actor);
-void BgCheck2_AttachToMesh(CollisionContext* bgCtxt, Actor* actor, s32 index);
-u32 BgCheck2_UpdateActorAttachedToMesh(CollisionContext* bgCtxt, s32 index, Actor* actor);
+void BgCheck2_UpdateActorPosition(CollisionContext* colCtx, s32 index, Actor* actor);
+void BgCheck2_UpdateActorYRotation(CollisionContext* colCtx, s32 index, Actor* actor);
+void BgCheck2_AttachToMesh(CollisionContext* colCtx, Actor* actor, s32 index);
+u32 BgCheck2_UpdateActorAttachedToMesh(CollisionContext* colCtx, s32 index, Actor* actor);
 void BcCheck3_BgActorInit(DynaPolyActor* actor, UNK_TYPE4 param_2);
 void BgCheck3_LoadMesh(GlobalContext* globalCtx, DynaPolyActor* actor, CollisionHeader* meshHeader);
 void BgCheck3_ResetFlags(DynaPolyActor* actor);
 void func_800CAE88(DynaPolyActor* actor);
 void func_800CAE9C(DynaPolyActor* actor);
-void func_800CAEB0(CollisionContext* bgCtxt, s32 index);
+void func_800CAEB0(CollisionContext* colCtx, s32 index);
 void func_800CAEE0(DynaPolyActor* actor);
-void func_800CAEF4(CollisionContext* bgCtxt, s32 index);
+void func_800CAEF4(CollisionContext* colCtx, s32 index);
 void func_800CAF24(DynaPolyActor* actor);
 void func_800CAF38(DynaPolyActor* actor);
 s32 func_800CAF4C(DynaPolyActor* actor);
@@ -1689,7 +1696,7 @@ s16 ActorCutscene_GetAdditionalCutscene(s16 index);
 s16 ActorCutscene_GetLength(s16 index);
 // void func_800F2138(void);
 // void func_800F2178(void);
-// s16 ActorCutscene_GetCurrentCamera(void);
+s16 ActorCutscene_GetCurrentCamera(s16 index);
 // void func_800F21CC(void);
 // UNK_TYPE4 func_800F22C4(s16 param_1, Actor* actor);
 void ActorCutscene_SetReturnCamera(s16 index);
@@ -1740,7 +1747,7 @@ void Kanfont_LoadMessageBoxEnd(Font* font, u16 type);
 void Kanfont_LoadOrderedFont(Font* font);
 // void func_800F5090(void);
 // void func_800F50D4(void);
-void Kankyo_Init(GlobalContext* globalCtx, KankyoContext* kanCtxt);
+void Kankyo_Init(GlobalContext* globalCtx, KankyoContext* envCtx);
 u32 func_800F5954(u8* param_1, u32 param_2, u32 param_3, u8 param_4, u8 param_5);
 // void func_800F5A8C(void);
 // void func_800F5B10(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5);
@@ -1750,16 +1757,16 @@ u32 func_800F5954(u8* param_1, u32 param_2, u32 param_3, u8 param_4, u8 param_5)
 // void func_800F6A04(void);
 // void func_800F6A40(void);
 // void func_800F6AB8(void);
-void func_800F6B44(GlobalContext* globalCtx, KankyoContext* kanCtxt, s32 iParm3, s32 iParm4, s16* param_5);
+void func_800F6B44(GlobalContext* globalCtx, KankyoContext* envCtx, s32 iParm3, s32 iParm4, s16* param_5);
 // void func_800F6CEC(void);
 // void func_800F6EA4(void);
 // UNK_TYPE4 Kankyo_IsSceneUpsideDown(GlobalContext* globalCtx);
-void func_800F6FF8(GlobalContext* globalCtx, KankyoContext* kanCtxt, LightContext* lCtxt);
+void func_800F6FF8(GlobalContext* globalCtx, KankyoContext* envCtx, LightContext* lightCtx);
 // void func_800F8554(void);
 // void func_800F88C4(void);
 // void func_800F8970(void);
 // void func_800F8A9C(void);
-// void func_800F8CD4(GlobalContext* globalCtx, KankyoContext* kanCtxt, LightContext* lCtxt, s32 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
+// void func_800F8CD4(GlobalContext* globalCtx, KankyoContext* envCtx, LightContext* lightCtx, s32 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6);
 // void func_800F8D84(void);
 // void func_800F9728(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7);
 // void func_800F9824(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8, UNK_TYPE4 param_9, UNK_TYPE2 param_10, UNK_TYPE1 param_11);
@@ -2205,7 +2212,7 @@ s32 func_801224E0(s32 param_1, s16 param_2, s16 param_3);
 // void func_80122660(void);
 // UNK_TYPE4 func_80122670(s32* param_1, Input* input);
 // void func_801226E0(void);
-// void func_80122744(void);
+void func_80122744(GlobalContext* globalCtx, UNK_PTR arg1, u32 arg2, Vec3s* arg3);
 s32 func_80122760(GlobalContext* globalCtx, UNK_PTR arg1, f32 arg2);
 void func_80122868(GlobalContext* globalCtx, ActorPlayer* player);
 void func_801229A0(GlobalContext* globalCtx, ActorPlayer* player);
@@ -2429,12 +2436,12 @@ void func_8012DEE8(GlobalContext* globalCtx, Room* room, u32 flags);
 u32 func_8012E254(s32 param_1, GlobalContext* globalCtx);
 void func_8012E32C(GlobalContext* globalCtx, Room* room, u32 flags);
 void Room_DrawType1Mesh(GlobalContext* globalCtx, Room* room, u32 flags);
-void Room_Init(GlobalContext* globalCtx, RoomContext* roomCtxt);
-u32 Room_AllocateAndLoad(GlobalContext* globalCtx, RoomContext* roomCtxt);
-s32 Room_StartRoomTransition(GlobalContext* globalCtx, RoomContext* roomCtxt, s32 index);
-s32 Room_HandleLoadCallbacks(GlobalContext* globalCtx, RoomContext* roomCtxt);
+void Room_Init(GlobalContext* globalCtx, RoomContext* roomCtx);
+u32 Room_AllocateAndLoad(GlobalContext* globalCtx, RoomContext* roomCtx);
+s32 Room_StartRoomTransition(GlobalContext* globalCtx, RoomContext* roomCtx, s32 index);
+s32 Room_HandleLoadCallbacks(GlobalContext* globalCtx, RoomContext* roomCtx);
 void Room_Draw(GlobalContext* globalCtx, Room* room, u32 flags);
-void func_8012EBF8(GlobalContext* globalCtx, RoomContext* roomCtxt);
+void func_8012EBF8(GlobalContext* globalCtx, RoomContext* roomCtx);
 s32 func_8012EC80(GlobalContext* globalCtx);
 void func_8012ED34(s16 equipment);
 u8 func_8012ED78(GlobalContext* globalCtx, s16 equipment);
@@ -2446,7 +2453,7 @@ void func_8012F1BC(s16 sceneIndex);
 s16 func_8012F22C(s16 sceneIndex);
 void func_8012F278(GlobalContext* globalCtx);
 s32 Object_Spawn(ObjectContext* objectCtx, s16 id);
-void Object_InitBank(GameState* state, ObjectContext* objectCtx);
+void Object_InitBank(GameState* gamestate, ObjectContext* objectCtx);
 void Object_UpdateBank(ObjectContext* objectCtx);
 s32 Object_GetIndex(ObjectContext* objectCtx, s16 id);
 s32 Object_IsLoaded(ObjectContext* objectCtx, s32 index);
@@ -2465,7 +2472,7 @@ void Scene_HeaderCmdObjectList(GlobalContext* globalCtx, SceneCmd* cmd);
 void Scene_HeaderCmdLightList(GlobalContext* globalCtx, SceneCmd* cmd);
 void Scene_HeaderCmdPathList(GlobalContext* globalCtx, SceneCmd* cmd);
 void Scene_HeaderCmdTransiActorList(GlobalContext* globalCtx, SceneCmd* cmd);
-void Transition_Init(GameState* state, TransitionContext* transitionCtx);
+void Transition_Init(GameState* gamestate, TransitionContext* transitionCtx);
 void Scene_HeaderCmdEnvLightSettings(GlobalContext* globalCtx, SceneCmd* cmd);
 s32 Scene_LoadAreaTextures(GlobalContext* globalCtx, s32 fileIndex);
 void Scene_HeaderCmdSkyboxSettings(GlobalContext* globalCtx, SceneCmd* cmd);
@@ -2809,9 +2816,9 @@ void func_801420F4(void* arg0);
 void func_80142100(void* arg0, Gfx** gfx, u32 arg2);
 s32 func_80142440(SkyboxContext* skyboxCtx, Vtx* vtx, s32 arg2, s32 arg3, s32 arg4, s32 arg5, s32 arg6, s32 arg7, s32 arg8); // func_80142440
 void func_80143148(SkyboxContext* skyboxCtx, s32 arg1); // func_80143148
-void func_801431E8(GameState* state, SkyboxContext* skyboxCtx, s16 skyType); // func_801431E8
+void func_801431E8(GameState* gamestate, SkyboxContext* skyboxCtx, s16 skyType); // func_801431E8
 void func_80143324(GlobalContext* globalCtx, SkyboxContext* skyboxCtx, s16 skyType); // func_80143324
-void func_801434E4(GameState* state, SkyboxContext* skyboxCtx, s16 skyType); // func_801434E4
+void func_801434E4(GameState* gamestate, SkyboxContext* skyboxCtx, s16 skyType); // func_801434E4
 // void func_801435A0(void);
 // void func_80143624(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE1 param_5, UNK_TYPE1 param_6, UNK_TYPE1 param_7);
 // void func_80143668(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7);
@@ -2830,13 +2837,13 @@ u32 Sram_CalcChecksum(u8* data, u32 length);
 // void func_80144E78(void);
 // void func_8014546C(void);
 // void func_80145698(void);
-void func_801457CC(GameState* ctxt, SramContext* param_2);
+void func_801457CC(GameState* gamestate, SramContext* param_2);
 void func_80146580(s32 param_1, SramContext* param_2, s32 param_3);
 // void func_80146628(void);
 // void func_80146AA0(void);
 // void func_80146DF8(void);
 // void func_80146E40(void);
-void Sram_Alloc(GameState* ctxt, SramContext* iParm2);
+void Sram_Alloc(GameState* gamestate, SramContext* iParm2);
 // void func_80146EBC(SramContext* param_1, UNK_TYPE4 param_2, UNK_TYPE4 param_3);
 // void func_80146EE8(void);
 // void func_80146F5C(void);
@@ -3052,10 +3059,10 @@ void func_801699D4(GlobalContext* globalCtx, s16 param_2, s16 param_3);
 // void func_80169C84(void);
 // void convert_scene_number_among_shared_scenes(void);
 void func_80169D40(GlobalContext* globalCtx);
-// void func_80169DCC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5, UNK_TYPE4 param_6, UNK_TYPE2 param_7);
+void func_80169DCC(GlobalContext* globalCtx, s32 arg1, u16 arg2, s32 arg3, s32 arg4, Vec3f *arg5, s16 arg6);
 void func_80169E6C(GlobalContext* globalCtx, s32 param_1, s32 param_2);
 // void func_80169ECC(void);
-// void func_80169EFC(void);
+void func_80169EFC(GlobalContext* globalCtx);
 // void func_80169F78(void);
 // void func_80169FDC(void);
 // void func_80169FFC(void);
@@ -3149,22 +3156,22 @@ void TitleSetup_Init(GameState* gameState);
 void Game_UpdateFramerateVariables(s32 divisor);
 void Game_SetFramerateDivisor(GameState* gameState, s32 divisor);
 void GameState_SetFBFilter(Gfx** gfx, u32 arg1);
-void Game_Nop80173534(GameState* ctxt);
-void GameState_Draw(GameState* ctxt, GraphicsContext* gfxCtx);
+void Game_Nop80173534(GameState* gamestate);
+void GameState_Draw(GameState* gamestate, GraphicsContext* gfxCtx);
 void Game_ResetSegments(GraphicsContext* gfxCtx);
 void func_801736DC(GraphicsContext* gfxCtx);
-void Game_UpdateInput(GameState* ctxt);
-void Game_Update(GameState* ctxt);
-void Game_IncrementFrameCount(GameState* ctxt);
-void Game_InitHeap(GameState* ctxt, u32 size);
-void Game_ResizeHeap(GameState* ctxt, u32 size);
-void Game_StateInit(GameState* ctxt, GameStateFunc gameStateInit, GraphicsContext* gfxCtx);
-void Game_StateFini(GameState* ctxt);
-GameStateFunc Game_GetNextStateInit(GameState* ctxt);
-u32 Game_GetNextStateSize(GameState* ctxt);
-u32 Game_GetShouldContinue(GameState* ctxt);
-s32 Game_GetHeapFreeSize(GameState* ctxt);
-s32 func_80173B48(GameState* ctxt);
+void Game_UpdateInput(GameState* gamestate);
+void Game_Update(GameState* gamestate);
+void Game_IncrementFrameCount(GameState* gamestate);
+void Game_InitHeap(GameState* gamestate, u32 size);
+void Game_ResizeHeap(GameState* gamestate, u32 size);
+void Game_StateInit(GameState* gamestate, GameStateFunc gameStateInit, GraphicsContext* gfxCtx);
+void Game_StateFini(GameState* gamestate);
+GameStateFunc Game_GetNextStateInit(GameState* gamestate);
+u32 Game_GetNextStateSize(GameState* gamestate);
+u32 Game_GetShouldContinue(GameState* gamestate);
+s32 Game_GetHeapFreeSize(GameState* gamestate);
+s32 func_80173B48(GameState* gamestate);
 GameAlloc* func_80173BF0(GameAlloc* heap);
 void* Gamealloc_Alloc(GameAlloc* heap, u32 size);
 void Gamealloc_Free(GameAlloc* heap, void* ptr);
@@ -3173,14 +3180,14 @@ void Gamealloc_Init(GameAlloc* iParm1);
 // void Graph_FaultClient(void);
 void Graph_DlAlloc(TwoHeadGfxArena* dl, void* memoryBlock, u32 size);
 void Graph_InitTHGA(GraphicsContext* gfxCtx);
-GameStateOverlay* Graph_GetNextGameState(GameState* ctxt);
+GameStateOverlay* Graph_GetNextGameState(GameState* gamestate);
 void* Graph_FaultAddrConvFunc(void* addr);
 void Graph_Init(GraphicsContext* gfxCtx);
 // void Graph_Destroy(void);
-void Graph_Render(GraphicsContext* gfxCtx, GameState* ctxt);
-void Graph_FrameSetup(GameState* ctxt);
-void Graph_RenderFrame(GraphicsContext* gfxCtx, GameState* ctxt);
-void Graph_DoFrame(GraphicsContext* gfxCtx, GameState* ctxt);
+void Graph_Render(GraphicsContext* gfxCtx, GameState* gamestate);
+void Graph_FrameSetup(GameState* gamestate);
+void Graph_RenderFrame(GraphicsContext* gfxCtx, GameState* gamestate);
+void Graph_DoFrame(GraphicsContext* gfxCtx, GameState* gamestate);
 void Graph_ThreadEntry(void* arg);
 Gfx* Graph_GfxPlusOne(Gfx* gfx);
 Gfx* Graph_BranchDlist(Gfx* gfx, Gfx* dst);
@@ -3381,12 +3388,12 @@ s16 Math_Atan2S(f32 opposite, f32 adjacent);
 f32 Math_Atan2F(f32 opposite, f32 adjacent);
 s16 Math_FAtan2F(f32 adjacent, f32 opposite);
 f32 Math_Acot2F(f32 adjacent, f32 opposite);
-void SysMatrix_StateAlloc(GameState* ctxt);
+void SysMatrix_StateAlloc(GameState* gamestate);
 void SysMatrix_StatePush(void);
 void SysMatrix_StatePop(void);
 void SysMatrix_CopyCurrentState(MtxF* matrix);
 void SysMatrix_SetCurrentState(MtxF* matrix);
-// MtxF* SysMatrix_GetCurrentState(void);
+MtxF* SysMatrix_GetCurrentState(void);
 void SysMatrix_InsertMatrix(MtxF* matrix, s32 appendToState);
 void SysMatrix_InsertTranslation(f32 x, f32 y, f32 z, s32 appendToState);
 void Matrix_Scale(f32 xScale, f32 yScale, f32 zScale, u8 appendToState);
@@ -3405,7 +3412,7 @@ RSPMatrix* SysMatrix_ToRSPMatrix(MtxF* src, RSPMatrix* dst);
 RSPMatrix* SysMatrix_GetStateAsRSPMatrix(RSPMatrix* matrix);
 Mtx* Matrix_NewMtx(GraphicsContext* gfxCtx);
 RSPMatrix* SysMatrix_AppendStateToPolyOpaDisp(GraphicsContext* gfxCtx);
-void SysMatrix_AppendToPolyOpaDisp(MtxF* ctxt, GraphicsContext* gfxCtx);
+void SysMatrix_AppendToPolyOpaDisp(MtxF* mtx, GraphicsContext* gfxCtx);
 void SysMatrix_MultiplyVector3fByState(Vec3f* src, Vec3f* dst);
 void SysMatrix_GetStateTranslation(Vec3f* dst);
 void SysMatrix_GetStateTranslationAndScaledX(f32 scale, Vec3f* dst);
@@ -3904,8 +3911,8 @@ void func_8019FAD8(Vec3f* param_1, u16 param_2, f32 param_3);
 // void func_801A1D44(void);
 // void func_801A1DB8(void);
 // void func_801A1E0C(void);
-// void func_801A1F00(void);
-// void func_801A1F88(void);
+void func_801A1F00(s32 arg0, s32 arg1);
+void func_801A1F88(void);
 // void func_801A1FB4(void);
 // void func_801A2090(void);
 void func_801A246C(u8 param_1, u8 param_2);
@@ -4020,7 +4027,7 @@ void func_801A7794(u32 param_1, u32 param_2, u32 param_3);
 // void func_801A7B10(void);
 // void func_801A7D04(void);
 // void func_801A7D84(void);
-// void func_801A89A8(void);
+// void func_801A89A8(UNK_TYPE arg0);
 // void func_801A89D0(void);
 s32 func_801A8A50(s32 param1);
 // void func_801A8ABC(void);
@@ -4050,6 +4057,6 @@ void nop_801AAAA0(GlobalContext* globalCtx);
 
 // overlays
 
-void Title_Init(TitleContext* ctxt);
+void Title_Init(TitleContext* titleCtx);
 
 #endif
diff --git a/src/code/code_0x800CAAD0.c b/src/code/code_0x800CAAD0.c
index a21e3885ac..0db62aca08 100644
--- a/src/code/code_0x800CAAD0.c
+++ b/src/code/code_0x800CAAD0.c
@@ -5,7 +5,7 @@
 // Perhaps it is called something like z_bgcheck_attach.c
 // The functions will use the BgCheck2 prefix for now.
 
-void BgCheck2_UpdateActorPosition(CollisionContext* bgCtxt, s32 index, Actor* actor) {
+void BgCheck2_UpdateActorPosition(CollisionContext* colCtx, s32 index, Actor* actor) {
     MtxF prevMatrix;
     MtxF prevMatrixInv;
     MtxF currMatrix;
@@ -17,22 +17,22 @@ void BgCheck2_UpdateActorPosition(CollisionContext* bgCtxt, s32 index, Actor* ac
     }
 
     SkinMatrix_SetScaleRotateYRPTranslate(
-        &prevMatrix, bgCtxt->dyna.bgActors[index].prevTransform.scale.x,
-        bgCtxt->dyna.bgActors[index].prevTransform.scale.y, bgCtxt->dyna.bgActors[index].prevTransform.scale.z,
-        bgCtxt->dyna.bgActors[index].prevTransform.rot.x, bgCtxt->dyna.bgActors[index].prevTransform.rot.y,
-        bgCtxt->dyna.bgActors[index].prevTransform.rot.z, bgCtxt->dyna.bgActors[index].prevTransform.pos.x,
-        bgCtxt->dyna.bgActors[index].prevTransform.pos.y, bgCtxt->dyna.bgActors[index].prevTransform.pos.z);
+        &prevMatrix, colCtx->dyna.bgActors[index].prevTransform.scale.x,
+        colCtx->dyna.bgActors[index].prevTransform.scale.y, colCtx->dyna.bgActors[index].prevTransform.scale.z,
+        colCtx->dyna.bgActors[index].prevTransform.rot.x, colCtx->dyna.bgActors[index].prevTransform.rot.y,
+        colCtx->dyna.bgActors[index].prevTransform.rot.z, colCtx->dyna.bgActors[index].prevTransform.pos.x,
+        colCtx->dyna.bgActors[index].prevTransform.pos.y, colCtx->dyna.bgActors[index].prevTransform.pos.z);
 
     if (SkinMatrix_Invert(&prevMatrix, &prevMatrixInv) == 2) {
         return;
     }
 
     SkinMatrix_SetScaleRotateYRPTranslate(
-        &currMatrix, bgCtxt->dyna.bgActors[index].curTransform.scale.x,
-        bgCtxt->dyna.bgActors[index].curTransform.scale.y, bgCtxt->dyna.bgActors[index].curTransform.scale.z,
-        bgCtxt->dyna.bgActors[index].curTransform.rot.x, bgCtxt->dyna.bgActors[index].curTransform.rot.y,
-        bgCtxt->dyna.bgActors[index].curTransform.rot.z, bgCtxt->dyna.bgActors[index].curTransform.pos.x,
-        bgCtxt->dyna.bgActors[index].curTransform.pos.y, bgCtxt->dyna.bgActors[index].curTransform.pos.z);
+        &currMatrix, colCtx->dyna.bgActors[index].curTransform.scale.x,
+        colCtx->dyna.bgActors[index].curTransform.scale.y, colCtx->dyna.bgActors[index].curTransform.scale.z,
+        colCtx->dyna.bgActors[index].curTransform.rot.x, colCtx->dyna.bgActors[index].curTransform.rot.y,
+        colCtx->dyna.bgActors[index].curTransform.rot.z, colCtx->dyna.bgActors[index].curTransform.pos.x,
+        colCtx->dyna.bgActors[index].curTransform.pos.y, colCtx->dyna.bgActors[index].curTransform.pos.z);
 
     SkinMatrix_Vec3fMtxFMultXYZ(&prevMatrixInv, &actor->world.pos, &posWithInv);
     SkinMatrix_Vec3fMtxFMultXYZ(&currMatrix, &posWithInv, &newPos);
@@ -40,14 +40,14 @@ void BgCheck2_UpdateActorPosition(CollisionContext* bgCtxt, s32 index, Actor* ac
     actor->world.pos = newPos;
 }
 
-void BgCheck2_UpdateActorYRotation(CollisionContext* bgCtxt, s32 index, Actor* actor) {
+void BgCheck2_UpdateActorYRotation(CollisionContext* colCtx, s32 index, Actor* actor) {
     s16 angleChange;
 
     if (BgCheck_IsActorMeshIndexValid(index) == 0) {
         return;
     }
 
-    angleChange = bgCtxt->dyna.bgActors[index].curTransform.rot.y - bgCtxt->dyna.bgActors[index].prevTransform.rot.y;
+    angleChange = colCtx->dyna.bgActors[index].curTransform.rot.y - colCtx->dyna.bgActors[index].prevTransform.rot.y;
 
     if (actor->id == 0) {
         ((ActorPlayer*)actor)->unkAD4 += angleChange;
@@ -57,14 +57,14 @@ void BgCheck2_UpdateActorYRotation(CollisionContext* bgCtxt, s32 index, Actor* a
     actor->world.rot.y += angleChange;
 }
 
-void BgCheck2_AttachToMesh(CollisionContext* bgCtxt, Actor* actor, s32 index) {
+void BgCheck2_AttachToMesh(CollisionContext* colCtx, Actor* actor, s32 index) {
     DynaPolyActor* meshActor;
 
     if (BgCheck_IsActorMeshIndexValid(index) == 0) {
         return;
     }
 
-    meshActor = BgCheck_GetActorOfMesh(bgCtxt, index);
+    meshActor = BgCheck_GetActorOfMesh(colCtx, index);
     if (meshActor != NULL) {
         func_800CAE88(meshActor);
 
@@ -77,7 +77,7 @@ void BgCheck2_AttachToMesh(CollisionContext* bgCtxt, Actor* actor, s32 index) {
     }
 }
 
-u32 BgCheck2_UpdateActorAttachedToMesh(CollisionContext* bgCtxt, s32 index, Actor* actor) {
+u32 BgCheck2_UpdateActorAttachedToMesh(CollisionContext* colCtx, s32 index, Actor* actor) {
     u32 wasUpdated = 0;
     DynaPolyActor* meshActor;
 
@@ -85,23 +85,23 @@ u32 BgCheck2_UpdateActorAttachedToMesh(CollisionContext* bgCtxt, s32 index, Acto
         return 0;
     }
 
-    if (((bgCtxt->dyna.bgActorFlags[index] & 2) != 0) || ((bgCtxt->dyna.bgActorFlags[index] & 1) == 0)) {
+    if (((colCtx->dyna.bgActorFlags[index] & 2) != 0) || ((colCtx->dyna.bgActorFlags[index] & 1) == 0)) {
         return 0;
     }
 
-    meshActor = BgCheck_GetActorOfMesh(bgCtxt, index);
+    meshActor = BgCheck_GetActorOfMesh(colCtx, index);
 
     if (meshActor == NULL) {
         return 0;
     }
 
     if ((meshActor->unk154 & 1) != 0) {
-        BgCheck2_UpdateActorPosition(bgCtxt, index, actor);
+        BgCheck2_UpdateActorPosition(colCtx, index, actor);
         wasUpdated = 1;
     }
 
     if ((meshActor->unk154 & 2) != 0) {
-        BgCheck2_UpdateActorYRotation(bgCtxt, index, actor);
+        BgCheck2_UpdateActorYRotation(colCtx, index, actor);
         wasUpdated = 1;
     }
 
diff --git a/src/code/code_0x800CAE10.c b/src/code/code_0x800CAE10.c
index 21758e1646..472d31b601 100644
--- a/src/code/code_0x800CAE10.c
+++ b/src/code/code_0x800CAE10.c
@@ -29,10 +29,10 @@ void func_800CAE9C(DynaPolyActor* actor) {
     actor->unk_158 |= 2;
 }
 
-void func_800CAEB0(CollisionContext* bgCtxt, s32 index) {
+void func_800CAEB0(CollisionContext* colCtx, s32 index) {
     DynaPolyActor* actor;
 
-    actor = BgCheck_GetActorOfMesh(bgCtxt, index);
+    actor = BgCheck_GetActorOfMesh(colCtx, index);
     if (actor != (DynaPolyActor*)0x0) {
         func_800CAE9C(actor);
     }
@@ -42,10 +42,10 @@ void func_800CAEE0(DynaPolyActor* actor) {
     actor->unk_158 |= 4;
 }
 
-void func_800CAEF4(CollisionContext* bgCtxt, s32 index) {
+void func_800CAEF4(CollisionContext* colCtx, s32 index) {
     DynaPolyActor* actor;
 
-    actor = BgCheck_GetActorOfMesh(bgCtxt, index);
+    actor = BgCheck_GetActorOfMesh(colCtx, index);
     if (actor != (DynaPolyActor*)0x0) {
         func_800CAEE0(actor);
     }
diff --git a/src/code/game.c b/src/code/game.c
index 2100f99a9f..a26cff4242 100644
--- a/src/code/game.c
+++ b/src/code/game.c
@@ -63,11 +63,11 @@ void GameState_SetFBFilter(Gfx** gfx, u32 arg1) {
     *gfx = _gfx;
 }
 
-void Game_Nop80173534(GameState* ctxt) {
+void Game_Nop80173534(GameState* gamestate) {
     ;
 }
 
-void GameState_Draw(GameState* ctxt, GraphicsContext* gfxCtx) {
+void GameState_Draw(GameState* gamestate, GraphicsContext* gfxCtx) {
     Gfx* nextDisplayList;
     Gfx* _polyOpa;
     // Unused vars impact regalloc
@@ -95,7 +95,7 @@ lblUnk:; // Label prevents reordering, if(1) around the above block don't seem t
 
     if (R_ENABLE_ARENA_DBG != 0) {
         SpeedMeter_DrawTimeEntries(&D_801F7FF0, gfxCtx);
-        SpeedMeter_DrawAllocEntries(&D_801F7FF0, gfxCtx, ctxt);
+        SpeedMeter_DrawAllocEntries(&D_801F7FF0, gfxCtx, gamestate);
     }
 }
 
@@ -120,46 +120,46 @@ void func_801736DC(GraphicsContext* gfxCtx) {
     gfxCtx->polyOpa.p = nextDisplayList;
 }
 
-void Game_UpdateInput(GameState* ctxt) {
-    Padmgr_GetInput(ctxt->input, 1);
+void Game_UpdateInput(GameState* gamestate) {
+    Padmgr_GetInput(gamestate->input, 1);
 }
 
-void Game_Update(GameState* ctxt) {
+void Game_Update(GameState* gamestate) {
     GraphicsContext* _gCtx;
-    _gCtx = ctxt->gfxCtx;
+    _gCtx = gamestate->gfxCtx;
 
-    Game_ResetSegments(ctxt->gfxCtx);
+    Game_ResetSegments(gamestate->gfxCtx);
 
-    ctxt->main(ctxt);
+    gamestate->main(gamestate);
 
     if (R_PAUSE_MENU_MODE != 2) {
-        GameState_Draw(ctxt, _gCtx);
+        GameState_Draw(gamestate, _gCtx);
         func_801736DC(_gCtx);
     }
 }
 
-void Game_IncrementFrameCount(GameState* ctxt) {
-    Game_Nop80173534(ctxt);
-    ctxt->frames++;
+void Game_IncrementFrameCount(GameState* gamestate) {
+    Game_Nop80173534(gamestate);
+    gamestate->frames++;
 }
 
-void Game_InitHeap(GameState* ctxt, u32 size) {
+void Game_InitHeap(GameState* gamestate, u32 size) {
     GameState* _ctx;
     void* buf;
 
-    _ctx = ctxt;
+    _ctx = gamestate;
     buf = Gamealloc_Alloc(&_ctx->alloc, size);
 
     if (buf) {
-        THA_Ct(&ctxt->heap, buf, size);
+        THA_Ct(&gamestate->heap, buf, size);
         return;
     }
 
-    THA_Ct(&ctxt->heap, NULL, 0);
+    THA_Ct(&gamestate->heap, NULL, 0);
     assert_fail("../game.c", 0x40B);
 }
 
-void Game_ResizeHeap(GameState* ctxt, u32 size) {
+void Game_ResizeHeap(GameState* gamestate, u32 size) {
     GameAlloc* alloc;
     void* buf;
     u32 systemMaxFree;
@@ -167,9 +167,9 @@ void Game_ResizeHeap(GameState* ctxt, u32 size) {
     u32 bytesAllocated;
     void* heapStart;
 
-    heapStart = ctxt->heap.bufp;
-    alloc = &ctxt->alloc;
-    THA_Dt(&ctxt->heap);
+    heapStart = gamestate->heap.bufp;
+    alloc = &gamestate->alloc;
+    THA_Dt(&gamestate->heap);
     Gamealloc_Free(alloc, heapStart);
     StartHeap_AnalyzeArena(&systemMaxFree, &bytesFree, &bytesAllocated);
     size = ((systemMaxFree - (sizeof(ArenaNode))) < size) ? (0) : (size);
@@ -178,32 +178,32 @@ void Game_ResizeHeap(GameState* ctxt, u32 size) {
     }
 
     if (buf = Gamealloc_Alloc(alloc, size)) {
-        THA_Ct(&ctxt->heap, buf, size);
+        THA_Ct(&gamestate->heap, buf, size);
     } else {
-        THA_Ct(&ctxt->heap, 0, 0);
+        THA_Ct(&gamestate->heap, 0, 0);
         assert_fail("../game.c", 0x432);
     }
 }
 
-void Game_StateInit(GameState* ctxt, GameStateFunc gameStateInit, GraphicsContext* gfxCtx) {
-    ctxt->gfxCtx = gfxCtx;
-    ctxt->frames = 0U;
-    ctxt->main = NULL;
-    ctxt->destroy = NULL;
-    ctxt->running = 1;
+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;
     gfxCtx->viConfigFeatures = gViConfigFeatures;
     gfxCtx->viConfigXScale = gViConfigXScale;
     gfxCtx->viConfigYScale = gViConfigYScale;
-    ctxt->nextGameStateInit = NULL;
-    ctxt->nextGameStateSize = 0U;
+    gamestate->nextGameStateInit = NULL;
+    gamestate->nextGameStateSize = 0U;
 
 lblUnk:;
-    Gamealloc_Init(&ctxt->alloc);
-    Game_InitHeap(ctxt, 0x100000);
-    Game_SetFramerateDivisor(ctxt, 3);
+    Gamealloc_Init(&gamestate->alloc);
+    Game_InitHeap(gamestate, 0x100000);
+    Game_SetFramerateDivisor(gamestate, 3);
 
-    gameStateInit(ctxt);
+    gameStateInit(gamestate);
 
     func_80140CE0(&D_801F8010);
     func_801420C0(&D_801F8020);
@@ -212,16 +212,16 @@ lblUnk:;
     func_801773A0(&D_801F7FF0);
     func_8013ED9C();
 
-    osSendMesg(&ctxt->gfxCtx->unk5C, NULL, 1);
+    osSendMesg(&gamestate->gfxCtx->unk5C, NULL, 1);
 }
 
-void Game_StateFini(GameState* ctxt) {
+void Game_StateFini(GameState* gamestate) {
     func_80172BC0();
     func_8019E014();
-    osRecvMesg(&ctxt->gfxCtx->unk5C, 0, 1);
+    osRecvMesg(&gamestate->gfxCtx->unk5C, 0, 1);
 
-    if (ctxt->destroy != 0) {
-        ctxt->destroy(ctxt);
+    if (gamestate->destroy != 0) {
+        gamestate->destroy(gamestate);
     }
 
     func_8013EDD0();
@@ -230,28 +230,28 @@ void Game_StateFini(GameState* ctxt) {
     func_801420F4(&D_801F8020);
     func_80141900(&sMonoColors);
     func_80140900(&D_801F8048);
-    THA_Dt(&ctxt->heap);
-    Gamealloc_FreeAll(&ctxt->alloc);
+    THA_Dt(&gamestate->heap);
+    Gamealloc_FreeAll(&gamestate->alloc);
 }
 
-GameStateFunc Game_GetNextStateInit(GameState* ctxt) {
-    return ctxt->nextGameStateInit;
+GameStateFunc Game_GetNextStateInit(GameState* gamestate) {
+    return gamestate->nextGameStateInit;
 }
 
-u32 Game_GetNextStateSize(GameState* ctxt) {
-    return ctxt->nextGameStateSize;
+u32 Game_GetNextStateSize(GameState* gamestate) {
+    return gamestate->nextGameStateSize;
 }
 
-u32 Game_GetShouldContinue(GameState* ctxt) {
-    return ctxt->running;
+u32 Game_GetShouldContinue(GameState* gamestate) {
+    return gamestate->running;
 }
 
-s32 Game_GetHeapFreeSize(GameState* ctxt) {
-    return THA_GetSize(&ctxt->heap);
+s32 Game_GetHeapFreeSize(GameState* gamestate) {
+    return THA_GetSize(&gamestate->heap);
 }
 
-s32 func_80173B48(GameState* ctxt) {
+s32 func_80173B48(GameState* gamestate) {
     s32 result;
-    result = OS_CYCLES_TO_NSEC(ctxt->framerateDivisor * sIrqMgrRetraceTime) - OS_CYCLES_TO_NSEC(D_801FBAF0);
+    result = OS_CYCLES_TO_NSEC(gamestate->framerateDivisor * sIrqMgrRetraceTime) - OS_CYCLES_TO_NSEC(D_801FBAF0);
     return result;
 }
diff --git a/src/code/sys_matrix.c b/src/code/sys_matrix.c
index d626da4554..20283638a4 100644
--- a/src/code/sys_matrix.c
+++ b/src/code/sys_matrix.c
@@ -1,25 +1,25 @@
 #include <ultra64.h>
 #include <global.h>
 
-void Matrix_Init(GameState* state) {
-    sMatrixStack = (MtxF*)THA_AllocEndAlign16(&state->heap, 0x500);
+void SysMatrix_StateAlloc(GameState* gamestate) {
+    sMatrixStack = (MtxF*)THA_AllocEndAlign16(&gamestate->heap, 0x500);
     sCurrentMatrix = sMatrixStack;
 }
 
-void Matrix_Push(void) {
+void SysMatrix_StatePush(void) {
     MtxF* prev = sCurrentMatrix;
 
     sCurrentMatrix++;
     Matrix_MtxFCopy(sCurrentMatrix, prev);
 }
 
-void Matrix_Pop(void) {
+void SysMatrix_StatePop(void) {
     sCurrentMatrix--;
 }
 
 #pragma GLOBAL_ASM("./asm/non_matchings/code/sys_matrix/SysMatrix_CopyCurrentState.asm")
 
-#pragma GLOBAL_ASM("./asm/non_matchings/code/sys_matrix/Matrix_Put.asm")
+#pragma GLOBAL_ASM("./asm/non_matchings/code/sys_matrix/SysMatrix_SetCurrentState.asm")
 
 #pragma GLOBAL_ASM("./asm/non_matchings/code/sys_matrix/SysMatrix_GetCurrentState.asm")
 
diff --git a/src/code/z_actor.c b/src/code/z_actor.c
index 5162f95b2b..b0a92b62eb 100644
--- a/src/code/z_actor.c
+++ b/src/code/z_actor.c
@@ -54,7 +54,7 @@ void ActorShadow_Draw(Actor* actor, Lights* lights, GlobalContext* globalCtx, Gf
             }
 
             func_800C0094(actor->floorPoly, actor->world.pos.x, actor->floorHeight, actor->world.pos.z, &mtx);
-            Matrix_Put(&mtx);
+            SysMatrix_SetCurrentState(&mtx);
 
             if (dlist != D_04076BC0) {
                 Matrix_RotateY((f32)actor->shape.rot.y * (M_PI / 32768), MTXMODE_APPLY);
@@ -118,7 +118,7 @@ void func_800B40E0(GlobalContext* globalCtx, Light* light, MtxF* arg2, s32 arg3,
     sp58 = Math_FAtan2F(light->l.dir[0], light->l.dir[2]);
     arg6 *= (4.5f - (light->l.dir[1] * D_801DCA1C));
     arg6 = (arg6 < 1.0f) ? 1.0f : arg6;
-    Matrix_Put(arg2);
+    SysMatrix_SetCurrentState(arg2);
     Matrix_RotateY(sp58, MTXMODE_APPLY);
     Matrix_Scale(arg5, 1.0f, arg5 * arg6, MTXMODE_APPLY);
 
@@ -147,16 +147,16 @@ void func_800B40E0(GlobalContext* globalCtx, Light* light, MtxF* arg2, s32 arg3,
 
 #pragma GLOBAL_ASM("./asm/non_matchings/code/z_actor//func_800B5040.asm")
 
-void Actor_TargetContextInit(TargetContext* targetCtxt, Actor* actor, GlobalContext* globalCtx) {
-    targetCtxt->unk90 = NULL;
-    targetCtxt->unk8C = NULL;
-    targetCtxt->unk3C = NULL;
-    targetCtxt->unk38 = NULL;
-    targetCtxt->unk4B = 0;
-    targetCtxt->unk4C = 0;
-    targetCtxt->unk40 = 0;
-    func_800B5040(targetCtxt, actor, actor->category, globalCtx);
-    func_800B4F78(targetCtxt, actor->category, globalCtx);
+void Actor_TargetContextInit(TargetContext* targetCtx, Actor* actor, GlobalContext* globalCtx) {
+    targetCtx->unk90 = NULL;
+    targetCtx->unk8C = NULL;
+    targetCtx->unk3C = NULL;
+    targetCtx->unk38 = NULL;
+    targetCtx->unk4B = 0;
+    targetCtx->unk4C = 0;
+    targetCtx->unk40 = 0;
+    func_800B5040(targetCtx, actor, actor->category, globalCtx);
+    func_800B4F78(targetCtx, actor->category, globalCtx);
 }
 
 #pragma GLOBAL_ASM("./asm/non_matchings/code/z_actor//func_800B5208.asm")
@@ -235,34 +235,34 @@ void Actor_SetCollectibleFlag(GlobalContext* globalCtx, s32 index) {
     }
 }
 
-void Actor_TitleCardContextInit(GlobalContext* globalCtx, TitleCardContext* titleCtxt) {
-    titleCtxt->fadeOutDelay = 0;
-    titleCtxt->fadeInDelay = 0;
-    titleCtxt->color = 0;
-    titleCtxt->alpha = 0;
+void Actor_TitleCardContextInit(GlobalContext* globalCtx, TitleCardContext* titleCardCtx) {
+    titleCardCtx->fadeOutDelay = 0;
+    titleCardCtx->fadeInDelay = 0;
+    titleCardCtx->color = 0;
+    titleCardCtx->alpha = 0;
 }
 
-void Actor_TitleCardCreate(GlobalContext* globalCtx, TitleCardContext* titleCtxt, u32 texture, s16 param_4, s16 param_5,
+void Actor_TitleCardCreate(GlobalContext* globalCtx, TitleCardContext* titleCardCtx, u32 texture, s16 param_4, s16 param_5,
                            u8 param_6, u8 param_7) {
-    titleCtxt->texture = texture;
-    titleCtxt->unk4 = param_4;
-    titleCtxt->unk6 = param_5;
-    titleCtxt->unk8 = param_6;
-    titleCtxt->unk9 = param_7;
-    titleCtxt->fadeOutDelay = 80;
-    titleCtxt->fadeInDelay = 0;
+    titleCardCtx->texture = texture;
+    titleCardCtx->unk4 = param_4;
+    titleCardCtx->unk6 = param_5;
+    titleCardCtx->unk8 = param_6;
+    titleCardCtx->unk9 = param_7;
+    titleCardCtx->fadeOutDelay = 80;
+    titleCardCtx->fadeInDelay = 0;
 }
 
 #pragma GLOBAL_ASM("./asm/non_matchings/code/z_actor//Actor_Nop800B5E50.asm")
 
-void Actor_TitleCardUpdate(GlobalContext* globalCtx, TitleCardContext* titleCtxt) {
-    if (DECR(titleCtxt->fadeInDelay) == 0) {
-        if (DECR(titleCtxt->fadeOutDelay) == 0) {
-            Math_StepToS(&titleCtxt->alpha, 0, 30);
-            Math_StepToS(&titleCtxt->color, 0, 70);
+void Actor_TitleCardUpdate(GlobalContext* globalCtx, TitleCardContext* titleCardCtx) {
+    if (DECR(titleCardCtx->fadeInDelay) == 0) {
+        if (DECR(titleCardCtx->fadeOutDelay) == 0) {
+            Math_StepToS(&titleCardCtx->alpha, 0, 30);
+            Math_StepToS(&titleCardCtx->color, 0, 70);
         } else {
-            Math_StepToS(&titleCtxt->alpha, 255, 10);
-            Math_StepToS(&titleCtxt->color, 255, 20);
+            Math_StepToS(&titleCardCtx->alpha, 255, 10);
+            Math_StepToS(&titleCardCtx->color, 255, 20);
         }
     }
 }
diff --git a/src/code/z_bgcheck.c b/src/code/z_bgcheck.c
index 180a749c2e..17853d3b8a 100644
--- a/src/code/z_bgcheck.c
+++ b/src/code/z_bgcheck.c
@@ -162,8 +162,8 @@ void BgCheck_CreateVertexFromVec3f(Vec3s* vertex, Vec3f* vector) {
 
 #pragma GLOBAL_ASM("./asm/non_matchings/code/z_bgcheck/func_800C40B4.asm")
 
-f32 func_800C411C(CollisionContext* bgCtxt, CollisionPoly** arg1, s32* arg2, Actor* actor, Vec3f* pos) {
-    return func_800C3D50(0, bgCtxt, 2, arg1, arg2, pos, actor, 28, 1.0f, 0);
+f32 func_800C411C(CollisionContext* colCtx, CollisionPoly** arg1, s32* arg2, Actor* actor, Vec3f* pos) {
+    return func_800C3D50(0, colCtx, 2, arg1, arg2, pos, actor, 28, 1.0f, 0);
 }
 
 #pragma GLOBAL_ASM("./asm/non_matchings/code/z_bgcheck/func_800C4188.asm")
diff --git a/src/code/z_eff_footmark.c b/src/code/z_eff_footmark.c
index 538a98e7f9..279b65a604 100644
--- a/src/code/z_eff_footmark.c
+++ b/src/code/z_eff_footmark.c
@@ -107,7 +107,7 @@ void EffFootmark_Draw(GlobalContext* globalCtx) {
 
     for (footmark = globalCtx->footmarks, i = 0; i < 100; i++, footmark++) {
         if (footmark->actor != NULL) {
-            Matrix_Put(&footmark->displayMatrix);
+            SysMatrix_SetCurrentState(&footmark->displayMatrix);
             Matrix_Scale(footmark->size * 0.00390625f * 0.7f, 1, footmark->size * 0.00390625f, 1);
 
             gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD);
diff --git a/src/code/z_effect.c b/src/code/z_effect.c
index 8f8b99efe7..be1225bb90 100644
--- a/src/code/z_effect.c
+++ b/src/code/z_effect.c
@@ -187,7 +187,7 @@ void Effect_Add(GlobalContext* globalCtx, s32* index, s32 type, u8 param_4, u8 p
 void Effect_DrawAll(GraphicsContext* gfxCtx) {
     s32 i;
 
-    for (i = 0; i < SPARK_COUNT; i++) { 
+    for (i = 0; i < SPARK_COUNT; i++) {
         if (1) {} // necessary to match
         if (sEffTable.sparks[i].base.active) {
             sEffInfoTable[0].draw(&sEffTable.sparks[i].params, gfxCtx);
@@ -195,8 +195,10 @@ void Effect_DrawAll(GraphicsContext* gfxCtx) {
     }
 
     for (i = 0; i < BLURE_COUNT; i++) {
-        if (1) { if (gfxCtx) {} } // necessary to match
-        if (sEffTable.blures[i].base.active) { 
+        if (1) {
+            if (gfxCtx) {}
+        } // necessary to match
+        if (sEffTable.blures[i].base.active) {
             sEffInfoTable[1].draw(&sEffTable.blures[i].params, gfxCtx);
         }
     }
diff --git a/src/code/z_effect_soft_sprite.c b/src/code/z_effect_soft_sprite.c
index 7546f6ed91..73bd5b4bdb 100644
--- a/src/code/z_effect_soft_sprite.c
+++ b/src/code/z_effect_soft_sprite.c
@@ -10,7 +10,8 @@ void EffectSS_Init(GlobalContext* globalCtx, s32 numEntries) {
     EffectSS2Info.searchIndex = 0;
     EffectSS2Info.size = numEntries;
 
-    for (effectsSs = &EffectSS2Info.data_table[0]; effectsSs < &EffectSS2Info.data_table[EffectSS2Info.size]; effectsSs++) {
+    for (effectsSs = &EffectSS2Info.data_table[0]; effectsSs < &EffectSS2Info.data_table[EffectSS2Info.size];
+         effectsSs++) {
         EffectSS_ResetEntry(effectsSs);
     }
 
@@ -97,7 +98,7 @@ s32 EffectSS_FindFreeSpace(s32 priority, s32* tableEntry) {
     // Search for a unused entry
     i = EffectSS2Info.searchIndex;
     foundFree = false;
-    while(true) {
+    while (true) {
         if (EffectSS2Info.data_table[i].life == -1) {
             foundFree = true;
             break;
@@ -118,12 +119,12 @@ s32 EffectSS_FindFreeSpace(s32 priority, s32* tableEntry) {
     if (foundFree == true) {
         *tableEntry = i;
         return false;
-    } 
-    
+    }
+
     // If all slots are in use, search for a slot with a lower priority
     // Note that a lower priority is representend by a higher value
     i = EffectSS2Info.searchIndex;
-    while(true) {
+    while (true) {
         // Equal priority should only be considered "lower" if flag 0 is set
         if ((priority <= EffectSS2Info.data_table[i].priority) &&
             !((priority == EffectSS2Info.data_table[i].priority) && (EffectSS2Info.data_table[i].flags & 1))) {
@@ -181,14 +182,13 @@ void EffectSs_Spawn(GlobalContext* globalCtx, s32 type, s32 priority, void* init
                 return;
             }
 
-            Load2_LoadOverlay(entry->vromStart, entry->vromEnd, entry->vramStart, entry->vramEnd,
-                                      entry->loadedRamAddr);
+            Load2_LoadOverlay(entry->vromStart, entry->vromEnd, entry->vramStart, entry->vramEnd, entry->loadedRamAddr);
         }
 
-        overlayInfo = (void*)(u32)(entry->overlayInfo != NULL
-                                       ? (ParticleOverlayInfo*)(-((u32)entry->vramStart - (u32)entry->loadedRamAddr) +
-                                                                (u32)entry->overlayInfo)
-                                       : NULL);
+        overlayInfo = (void*)(u32)(
+            entry->overlayInfo != NULL
+                ? (ParticleOverlayInfo*)(-((u32)entry->vramStart - (u32)entry->loadedRamAddr) + (u32)entry->overlayInfo)
+                : NULL);
     }
 
     if (overlayInfo->init != NULL) {
diff --git a/src/code/z_room.c b/src/code/z_room.c
index 84f93b7780..eda1b6e76c 100644
--- a/src/code/z_room.c
+++ b/src/code/z_room.c
@@ -63,39 +63,39 @@ void Room_DrawType1Mesh(GlobalContext* globalCtx, Room* room, u32 flags) {
     }
 }
 
-void Room_Init(GlobalContext* globalCtx, RoomContext* roomCtxt) {
+void Room_Init(GlobalContext* globalCtx, RoomContext* roomCtx) {
     s32 i;
-    roomCtxt->currRoom.num = -1;
-    roomCtxt->currRoom.segment = NULL;
-    roomCtxt->unk78 = 1;
-    roomCtxt->unk79 = 0;
+    roomCtx->currRoom.num = -1;
+    roomCtx->currRoom.segment = NULL;
+    roomCtx->unk78 = 1;
+    roomCtx->unk79 = 0;
     for (i = 0; i < 3; i++) {
-        roomCtxt->unk7A[i] = 0;
+        roomCtx->unk7A[i] = 0;
     }
 }
 
 #pragma GLOBAL_ASM("./asm/non_matchings/code/z_room/Room_AllocateAndLoad.asm")
 
 #ifdef NON_MATCHING
-s32 Room_StartRoomTransition(GlobalContext* globalCtx, RoomContext* roomCtxt, s32 index) {
+s32 Room_StartRoomTransition(GlobalContext* globalCtx, RoomContext* roomCtx, s32 index) {
     u32 size;
 
     // XXX: this should use a branch-likely
-    if (roomCtxt->unk31 == 0) {
-        roomCtxt->prevRoom = roomCtxt->currRoom;
-        roomCtxt->currRoom.num = index;
-        roomCtxt->currRoom.segment = NULL;
-        roomCtxt->unk31 = 1;
+    if (roomCtx->unk31 == 0) {
+        roomCtx->prevRoom = roomCtx->currRoom;
+        roomCtx->currRoom.num = index;
+        roomCtx->currRoom.segment = NULL;
+        roomCtx->unk31 = 1;
 
         size = globalCtx->roomAddrs[index].vromEnd - globalCtx->roomAddrs[index].vromStart;
-        roomCtxt->activeRoomVram =
-            (void*)((s32)roomCtxt->roomMemPages[roomCtxt->activeMemPage] - (size + 8) * roomCtxt->activeMemPage + 8) &
+        roomCtx->activeRoomVram =
+            (void*)((s32)roomCtx->roomMemPages[roomCtx->activeMemPage] - (size + 8) * roomCtx->activeMemPage + 8) &
             0xfffffff0;
 
-        osCreateMesgQueue(&roomCtxt->loadQueue, roomCtxt->loadMsg, 1);
-        DmaMgr_SendRequestImpl(&roomCtxt->dmaRequest, roomCtxt->activeRoomVram, globalCtx->roomAddrs[index].vromStart,
-                               size, 0, &roomCtxt->loadQueue, NULL);
-        roomCtxt->activeMemPage ^= 1;
+        osCreateMesgQueue(&roomCtx->loadQueue, roomCtx->loadMsg, 1);
+        DmaMgr_SendRequestImpl(&roomCtx->dmaRequest, roomCtx->activeRoomVram, globalCtx->roomAddrs[index].vromStart,
+                               size, 0, &roomCtx->loadQueue, NULL);
+        roomCtx->activeMemPage ^= 1;
 
         return 1;
     }
@@ -106,19 +106,19 @@ s32 Room_StartRoomTransition(GlobalContext* globalCtx, RoomContext* roomCtxt, s3
 #pragma GLOBAL_ASM("./asm/non_matchings/code/z_room/Room_StartRoomTransition.asm")
 #endif
 
-s32 Room_HandleLoadCallbacks(GlobalContext* globalCtx, RoomContext* roomCtxt) {
-    if (roomCtxt->unk31 == 1) {
-        if (!osRecvMesg(&roomCtxt->loadQueue, NULL, OS_MESG_NOBLOCK)) {
-            roomCtxt->unk31 = 0;
-            roomCtxt->currRoom.segment = roomCtxt->activeRoomVram;
+s32 Room_HandleLoadCallbacks(GlobalContext* globalCtx, RoomContext* roomCtx) {
+    if (roomCtx->unk31 == 1) {
+        if (!osRecvMesg(&roomCtx->loadQueue, NULL, OS_MESG_NOBLOCK)) {
+            roomCtx->unk31 = 0;
+            roomCtx->currRoom.segment = roomCtx->activeRoomVram;
             // TODO: Segment number enum
-            gSegments[3] = PHYSICAL_TO_VIRTUAL(roomCtxt->activeRoomVram);
+            gSegments[3] = PHYSICAL_TO_VIRTUAL(roomCtx->activeRoomVram);
 
-            Scene_ProcessHeader(globalCtx, (SceneCmd*)roomCtxt->currRoom.segment);
+            Scene_ProcessHeader(globalCtx, (SceneCmd*)roomCtx->currRoom.segment);
             func_80123140(globalCtx, PLAYER);
             Actor_SpawnTransitionActors(globalCtx, &globalCtx->actorCtx);
 
-            if (((globalCtx->sceneNum != SCENE_IKANA) || (roomCtxt->currRoom.num != 1)) &&
+            if (((globalCtx->sceneNum != SCENE_IKANA) || (roomCtx->currRoom.num != 1)) &&
                 (globalCtx->sceneNum != SCENE_IKNINSIDE)) {
                 globalCtx->kankyoContext.unkC3 = 0xff;
                 globalCtx->kankyoContext.unkE0 = 0;
@@ -144,13 +144,13 @@ void Room_Draw(GlobalContext* globalCtx, Room* room, u32 flags) {
     return;
 }
 
-void func_8012EBF8(GlobalContext* globalCtx, RoomContext* roomCtxt) {
-    roomCtxt->prevRoom.num = -1;
-    roomCtxt->prevRoom.segment = NULL;
+void func_8012EBF8(GlobalContext* globalCtx, RoomContext* roomCtx) {
+    roomCtx->prevRoom.num = -1;
+    roomCtx->prevRoom.segment = NULL;
     func_800BA798(globalCtx, &globalCtx->actorCtx);
     Actor_SpawnTransitionActors(globalCtx, &globalCtx->actorCtx);
-    if (-1 < roomCtxt->currRoom.num) {
-        func_8010A33C(globalCtx, roomCtxt->currRoom.num);
+    if (-1 < roomCtx->currRoom.num) {
+        func_8010A33C(globalCtx, roomCtx->currRoom.num);
         func_8010A2DC(globalCtx);
     }
     func_801A3CD8(globalCtx->roomContext.currRoom.echo);
diff --git a/src/code/z_scene.c b/src/code/z_scene.c
index 78c57d4780..c6ff043911 100644
--- a/src/code/z_scene.c
+++ b/src/code/z_scene.c
@@ -24,8 +24,8 @@ s32 Object_Spawn(ObjectContext* objectCtx, s16 id) {
     return objectCtx->num - 1;
 }
 
-void Object_InitBank(GameState* state, ObjectContext* objectCtx) {
-    GlobalContext* globalCtx = (GlobalContext*)state;
+void Object_InitBank(GameState* gamestate, ObjectContext* objectCtx) {
+    GlobalContext* globalCtx = (GlobalContext*)gamestate;
     s32 pad;
     u32 spaceSize;
     s32 i;
@@ -50,7 +50,7 @@ void Object_InitBank(GameState* state, ObjectContext* objectCtx) {
     for (i = 0; i < OBJECT_EXCHANGE_BANK_MAX; i++) { objectCtx->status[i].id = 0; }
     // clang-format on
 
-    objectCtx->spaceStart = objectCtx->status[0].segment = THA_AllocEndAlign16(&state->heap, spaceSize);
+    objectCtx->spaceStart = objectCtx->status[0].segment = THA_AllocEndAlign16(&gamestate->heap, spaceSize);
     objectCtx->spaceEnd = (void*)((u32)objectCtx->spaceStart + spaceSize);
     objectCtx->mainKeepIndex = Object_Spawn(objectCtx, GAMEPLAY_KEEP);
 
@@ -328,7 +328,7 @@ void Scene_HeaderCmdTransiActorList(GlobalContext* globalCtx, SceneCmd* cmd) {
 }
 
 // Init function for the transition system.
-void Transition_Init(GameState* state, TransitionContext* transitionCtx) {
+void Transition_Init(GameState* gamestate, TransitionContext* transitionCtx) {
     transitionCtx->nbTransitionActors = 0;
 }
 
diff --git a/src/code/z_skelanime.c b/src/code/z_skelanime.c
index 07ab415ad4..5dabb6a276 100644
--- a/src/code/z_skelanime.c
+++ b/src/code/z_skelanime.c
@@ -40,7 +40,7 @@ void SkelAnime_LodDrawLimb(GlobalContext* globalCtx, s32 limbIndex, void** skele
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     s32 pad;
 
-    Matrix_Push();
+    SysMatrix_StatePush();
     limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
     limbIndex++;
     rot = limbDrawTable[limbIndex];
@@ -71,7 +71,7 @@ void SkelAnime_LodDrawLimb(GlobalContext* globalCtx, s32 limbIndex, void** skele
                               postLimbDraw, actor, dListIndex);
     }
 
-    Matrix_Pop();
+    SysMatrix_StatePop();
 
     if (limbEntry->nextLimbIndex != LIMB_DONE) {
         SkelAnime_LodDrawLimb(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw,
@@ -98,7 +98,7 @@ void SkelAnime_LodDraw(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDra
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    Matrix_Push();
+    SysMatrix_StatePush();
 
     limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
     pos.x = limbDrawTable[0].x;
@@ -130,7 +130,7 @@ void SkelAnime_LodDraw(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDra
                               postLimbDraw, actor, dListIndex);
     }
 
-    Matrix_Pop();
+    SysMatrix_StatePop();
 }
 
 /*
@@ -147,7 +147,7 @@ void SkelAnime_LodDrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, void** ske
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     s32 pad;
 
-    Matrix_Push();
+    SysMatrix_StatePush();
 
     limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
     limbIndex++;
@@ -183,7 +183,7 @@ void SkelAnime_LodDrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, void** ske
                                 postLimbDraw, actor, dListIndex, mtx);
     }
 
-    Matrix_Pop();
+    SysMatrix_StatePop();
 
     if (limbEntry->nextLimbIndex != LIMB_DONE) {
         SkelAnime_LodDrawLimbSV(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw,
@@ -217,7 +217,7 @@ void SkelAnime_LodDrawSV(GlobalContext* globalCtx, void** skeleton, Vec3s* limbD
     gfxCtx = globalCtx->state.gfxCtx;
 
     gSPSegment(gfxCtx->polyOpa.p++, 0xD, mtx);
-    Matrix_Push();
+    SysMatrix_StatePush();
 
     limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
     pos.x = limbDrawTable[0].x;
@@ -253,7 +253,7 @@ void SkelAnime_LodDrawSV(GlobalContext* globalCtx, void** skeleton, Vec3s* limbD
                                 postLimbDraw, actor, dListIndex, &mtx);
     }
 
-    Matrix_Pop();
+    SysMatrix_StatePop();
 }
 
 /*
@@ -268,7 +268,7 @@ void SkelAnime_DrawLimb(GlobalContext* globalCtx, s32 limbIndex, void** skeleton
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     s32 pad;
 
-    Matrix_Push();
+    SysMatrix_StatePush();
 
     limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
     limbIndex++;
@@ -298,7 +298,7 @@ void SkelAnime_DrawLimb(GlobalContext* globalCtx, s32 limbIndex, void** skeleton
                            postLimbDraw, actor);
     }
 
-    Matrix_Pop();
+    SysMatrix_StatePop();
 
     if (limbEntry->nextLimbIndex != LIMB_DONE) {
         SkelAnime_DrawLimb(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw, postLimbDraw,
@@ -322,7 +322,7 @@ void SkelAnime_Draw(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTa
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    Matrix_Push();
+    SysMatrix_StatePush();
     rootLimb = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
 
     pos.x = limbDrawTable[0].x;
@@ -352,7 +352,7 @@ void SkelAnime_Draw(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTa
                            postLimbDraw, actor);
     }
 
-    Matrix_Pop();
+    SysMatrix_StatePop();
 }
 
 void SkelAnime_DrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* limbDrawTable,
@@ -365,7 +365,7 @@ void SkelAnime_DrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, void** skelet
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     s32 pad;
 
-    Matrix_Push();
+    SysMatrix_StatePush();
 
     limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
     limbIndex++;
@@ -400,7 +400,7 @@ void SkelAnime_DrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, void** skelet
                              postLimbDraw, actor, limbMatricies);
     }
 
-    Matrix_Pop();
+    SysMatrix_StatePop();
 
     if (limbEntry->nextLimbIndex != LIMB_DONE) {
         SkelAnime_DrawLimbSV(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw,
@@ -429,7 +429,7 @@ void SkelAnime_DrawSV(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDraw
 
     gSPSegment(gfxCtx->polyOpa.p++, 0xD, mtx);
 
-    Matrix_Push();
+    SysMatrix_StatePush();
 
     limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
 
@@ -467,7 +467,7 @@ void SkelAnime_DrawSV(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDraw
                              postLimbDraw, actor, &mtx);
     }
 
-    Matrix_Pop();
+    SysMatrix_StatePop();
 }
 
 void func_80134148(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* limbDrawTable,
@@ -480,7 +480,7 @@ void func_80134148(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     s32 pad2;
 
-    Matrix_Push();
+    SysMatrix_StatePush();
 
     limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
     limbIndex++;
@@ -495,7 +495,7 @@ void func_80134148(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec
 
     if ((overrideLimbDraw == NULL) || (overrideLimbDraw(globalCtx, limbIndex, &dList[1], &pos, &rot, actor) == 0)) {
         SysMatrix_RotateAndTranslateState(&pos, &rot);
-        Matrix_Push();
+        SysMatrix_StatePush();
         unkDraw(globalCtx, limbIndex, actor);
         if (dList[1] != NULL) {
             Gfx* polyTemp = gfxCtx->polyOpa.p;
@@ -510,7 +510,7 @@ void func_80134148(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec
                 (*mtx)++;
             }
         }
-        Matrix_Pop();
+        SysMatrix_StatePop();
     }
 
     if (postLimbDraw != NULL) {
@@ -522,7 +522,7 @@ void func_80134148(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec
                       unkDraw, actor, mtx);
     }
 
-    Matrix_Pop();
+    SysMatrix_StatePop();
 
     if (limbEntry->nextLimbIndex != LIMB_DONE) {
         func_80134148(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw, postLimbDraw,
@@ -551,7 +551,7 @@ void func_801343C0(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTab
 
     gSPSegment(gfxCtx->polyOpa.p++, 0xD, mtx);
 
-    Matrix_Push();
+    SysMatrix_StatePush();
 
     limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
 
@@ -565,7 +565,7 @@ void func_801343C0(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTab
 
     if ((overrideLimbDraw == NULL) || (overrideLimbDraw(globalCtx, 1, &dList[1], &pos, &rot, actor) == 0)) {
         SysMatrix_RotateAndTranslateState(&pos, &rot);
-        Matrix_Push();
+        SysMatrix_StatePush();
         unkDraw(globalCtx, 1, actor);
         if (dList[1] != NULL) {
             Gfx* polyTemp = gfxCtx->polyOpa.p;
@@ -579,7 +579,7 @@ void func_801343C0(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTab
                 SysMatrix_GetStateAsRSPMatrix(mtx++);
             }
         }
-        Matrix_Pop();
+        SysMatrix_StatePop();
     }
 
     if (postLimbDraw != NULL) {
@@ -591,7 +591,7 @@ void func_801343C0(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTab
                       unkDraw, actor, &mtx);
     }
 
-    Matrix_Pop();
+    SysMatrix_StatePop();
 }
 
 /*
@@ -641,7 +641,7 @@ Gfx* SkelAnime_Draw2Limb(GlobalContext* globalCtx, s32 limbIndex, void** skeleto
     Vec3f pos;
     Vec3s rot;
 
-    Matrix_Push();
+    SysMatrix_StatePush();
 
     limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
     limbIndex++;
@@ -671,7 +671,7 @@ Gfx* SkelAnime_Draw2Limb(GlobalContext* globalCtx, s32 limbIndex, void** skeleto
                                   postLimbDraw, actor, gfx);
     }
 
-    Matrix_Pop();
+    SysMatrix_StatePop();
 
     if (limbEntry->nextLimbIndex != LIMB_DONE) {
         gfx = SkelAnime_Draw2Limb(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw,
@@ -697,7 +697,7 @@ Gfx* SkelAnime_Draw2(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawT
         return NULL;
     }
 
-    Matrix_Push();
+    SysMatrix_StatePush();
 
     limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
 
@@ -726,7 +726,7 @@ Gfx* SkelAnime_Draw2(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawT
                                   postLimbDraw, actor, gfx);
     }
 
-    Matrix_Pop();
+    SysMatrix_StatePop();
 
     return gfx;
 }
@@ -744,7 +744,7 @@ Gfx* SkelAnime_DrawLimbSV2(GlobalContext* globalCtx, s32 limbIndex, void** skele
     Vec3f pos;
     Vec3s rot;
 
-    Matrix_Push();
+    SysMatrix_StatePush();
 
     limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
     limbIndex++;
@@ -780,7 +780,7 @@ Gfx* SkelAnime_DrawLimbSV2(GlobalContext* globalCtx, s32 limbIndex, void** skele
                                     postLimbDraw, actor, mtx, gfx);
     }
 
-    Matrix_Pop();
+    SysMatrix_StatePop();
 
     if (limbEntry->nextLimbIndex != LIMB_DONE) {
         gfx = SkelAnime_DrawLimbSV2(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw,
@@ -808,7 +808,7 @@ Gfx* SkelAnime_DrawSV2(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDra
 
     gSPSegment(gfx++, 0xD, mtx);
 
-    Matrix_Push();
+    SysMatrix_StatePush();
 
     limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
 
@@ -844,7 +844,7 @@ Gfx* SkelAnime_DrawSV2(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDra
                                     postLimbDraw, actor, &mtx, gfx);
     }
 
-    Matrix_Pop();
+    SysMatrix_StatePop();
 
     return gfx;
 }
diff --git a/src/code/z_view.c b/src/code/z_view.c
index ad8dfad5da..7e2d7d62c4 100644
--- a/src/code/z_view.c
+++ b/src/code/z_view.c
@@ -258,7 +258,7 @@ s32 View_StepQuake(View* view, RSPMatrix* matrix) {
     }
 
     SysMatrix_FromRSPMatrix(matrix, &mf);
-    Matrix_Put(&mf);
+    SysMatrix_SetCurrentState(&mf);
     SysMatrix_RotateStateAroundXAxis(view->currQuakeRot.x);
     SysMatrix_InsertYRotation_f(view->currQuakeRot.y, 1);
     SysMatrix_InsertZRotation_f(view->currQuakeRot.z, 1);
diff --git a/src/code/z_vr_box.c b/src/code/z_vr_box.c
index cfed6f7836..9f413f3fe1 100644
--- a/src/code/z_vr_box.c
+++ b/src/code/z_vr_box.c
@@ -38,7 +38,7 @@ void func_80143148(SkyboxContext* skyboxCtx, s32 arg1) {
 
 #ifdef NON_MATCHING
 // Matches besides rodata, since rodata is not merged into the asm in code files yet.
-void func_801431E8(GameState* state, SkyboxContext* skyboxCtx, s16 skyType) {
+void func_801431E8(GameState* gamestate, SkyboxContext* skyboxCtx, s16 skyType) {
     GlobalContext* globalCtx = (GlobalContext*)state;
     u32 size;
     void* offset;
@@ -139,22 +139,22 @@ void func_80143324(GlobalContext* globalCtx, SkyboxContext* skyboxCtx, s16 skyTy
     }
 }
 
-void func_801434E4(GameState* state, SkyboxContext* skyboxCtx, s16 skyType) {
+void func_801434E4(GameState* gamestate, SkyboxContext* skyboxCtx, s16 skyType) {
     skyboxCtx->skyboxShouldDraw = 0;
     skyboxCtx->rotX = skyboxCtx->rotY = skyboxCtx->rotZ = 0.0f;
 
-    func_801431E8(state, skyboxCtx, skyType);
+    func_801431E8(gamestate, skyboxCtx, skyType);
 
     if (skyType != 0) {
-        skyboxCtx->unk17C = THA_AllocEndAlign16(&state->heap, 0x3840);
+        skyboxCtx->unk17C = THA_AllocEndAlign16(&gamestate->heap, 0x3840);
 
         if (skyType == 5) {
             // Allocate enough space for the vertices for a 6 sided skybox (cube)
-            skyboxCtx->roomVtx = THA_AllocEndAlign16(&state->heap, sizeof(Vtx) * 32 * 6);
+            skyboxCtx->roomVtx = THA_AllocEndAlign16(&gamestate->heap, sizeof(Vtx) * 32 * 6);
             func_80143148(skyboxCtx, 6);
         } else {
             // Allocate enough space for the vertices for a 5 sided skybox (bottom is missing)
-            skyboxCtx->roomVtx = THA_AllocEndAlign16(&state->heap, sizeof(Vtx) * 32 * 5);
+            skyboxCtx->roomVtx = THA_AllocEndAlign16(&gamestate->heap, sizeof(Vtx) * 32 * 5);
             func_80143148(skyboxCtx, 5);
         }
     }
diff --git a/src/overlays/actors/ovl_Arms_Hook/z_arms_hook.c b/src/overlays/actors/ovl_Arms_Hook/z_arms_hook.c
index 8e4aa39da5..63f928c143 100644
--- a/src/overlays/actors/ovl_Arms_Hook/z_arms_hook.c
+++ b/src/overlays/actors/ovl_Arms_Hook/z_arms_hook.c
@@ -135,7 +135,7 @@ void ArmsHook_Shoot(ArmsHook* this, GlobalContext* globalCtx) {
         return;
     }
 
-    func_800B8F98(&player->base, 0x100B);
+    func_800B8F98(&player->base, NA_SE_IT_HOOKSHOT_CHAIN - SFX_FLAG);
     ArmsHook_CheckForCancel(this);
 
     if (this->timer != 0 && (this->collider.base.atFlags & AT_HIT) &&
diff --git a/src/overlays/actors/ovl_Bg_Iknin_Susceil/z_bg_iknin_susceil.c b/src/overlays/actors/ovl_Bg_Iknin_Susceil/z_bg_iknin_susceil.c
index 781f909013..e4daa27c29 100644
--- a/src/overlays/actors/ovl_Bg_Iknin_Susceil/z_bg_iknin_susceil.c
+++ b/src/overlays/actors/ovl_Bg_Iknin_Susceil/z_bg_iknin_susceil.c
@@ -223,7 +223,7 @@ void BgIkninSusceil_Update(Actor* thisx, GlobalContext* globalCtx) {
     if ((this->unk168 == 0) && (this->unk166 > 0) && ((player->unkA74 & 0x100) != 0) && (player->unkB48 > 1000.0f)) {
         this->unk168 = 2;
         if ((func_80C0A95C(this, globalCtx) != 0) && (this->actionFunc != func_80C0AE5C)) {
-            func_800B8E58(player, 0x83E);
+            func_800B8E58(&player->base, NA_SE_PL_BODY_HIT);
             func_80C0AE3C(this);
         }
     }
diff --git a/src/overlays/actors/ovl_En_Fg/z_en_fg.c b/src/overlays/actors/ovl_En_Fg/z_en_fg.c
index 40233fc696..413889a0ed 100644
--- a/src/overlays/actors/ovl_En_Fg/z_en_fg.c
+++ b/src/overlays/actors/ovl_En_Fg/z_en_fg.c
@@ -360,11 +360,11 @@ void EnFg_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec
 
     if ((limbIndex == 7) || (limbIndex == 8)) {
         OPEN_DISPS(globalCtx->state.gfxCtx);
-        Matrix_Push();
+        SysMatrix_StatePush();
         SysMatrix_NormalizeXYZ(&globalCtx->unk187FC);
         gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
         gSPDisplayList(POLY_OPA_DISP++, *dList);
-        Matrix_Pop();
+        SysMatrix_StatePop();
         CLOSE_DISPS(globalCtx->state.gfxCtx);
     }
 
@@ -381,9 +381,9 @@ void EnFg_Draw(Actor* thisx, GlobalContext* globalCtx) {
         { 120, 130, 230, 255 }, { 190, 190, 190, 255 }, { 0, 0, 0, 255 },
     };
 
-    Matrix_Push();
+    SysMatrix_StatePush();
     EnFg_DrawDust(globalCtx, &this->dustEffect[0]);
-    Matrix_Pop();
+    SysMatrix_StatePop();
 
     OPEN_DISPS(globalCtx->state.gfxCtx);
     func_8012C28C(globalCtx->state.gfxCtx);
diff --git a/src/overlays/actors/ovl_En_Ginko_Man/z_en_ginko_man.c b/src/overlays/actors/ovl_En_Ginko_Man/z_en_ginko_man.c
index 22e702baff..1a09b807e1 100644
--- a/src/overlays/actors/ovl_En_Ginko_Man/z_en_ginko_man.c
+++ b/src/overlays/actors/ovl_En_Ginko_Man/z_en_ginko_man.c
@@ -143,7 +143,8 @@ void EnGinkoMan_DepositDialogue(EnGinkoMan* this, GlobalContext* globalCtx) {
                 this->curTextId = 0x44E; //" ...So, what'll it be?  Deposit Rupees Don't deposit Rupees"
             } else {
                 func_801518B0(globalCtx, 0x44D, &this->actor);
-                this->curTextId = 0x44D; // "For example, if you deposit 200 Rupees, you'll get an item that holds a lot of Rupees."
+                this->curTextId =
+                    0x44D; // "For example, if you deposit 200 Rupees, you'll get an item that holds a lot of Rupees."
             }
             break;
         case 0x44D: // "For example, if you deposit 200 Rupees, you'll get an item that holds a lot of Rupees."
@@ -189,7 +190,7 @@ void EnGinkoMan_DepositDialogue(EnGinkoMan* this, GlobalContext* globalCtx) {
                 func_801518B0(globalCtx, 0x45B, &this->actor);
                 this->curTextId = 0x45B; // "What's this? You've already saved up 200 Rupees!?!
             } else if (((gSaveContext.roomInf[127][0] & 0xFFFF) >= 1000) && ((this->previousBankValue) < 1000) &&
-                !(gSaveContext.weekEventReg[59] & 0x80)) {
+                       !(gSaveContext.weekEventReg[59] & 0x80)) {
                 gSaveContext.weekEventReg[59] |= 0x80;
                 func_801518B0(globalCtx, 0x45C, &this->actor);
                 this->curTextId = 0x45C; // "What's this? You've already saved up 1000 Rupees!?!
@@ -201,7 +202,8 @@ void EnGinkoMan_DepositDialogue(EnGinkoMan* this, GlobalContext* globalCtx) {
                 } else if (this->previousBankValue < (s16)(gSaveContext.roomInf[127][0] & 0xFFFF)) {
                     func_800BDC5C(&this->skelAnime, animations, GINKO_SITTING);
                     func_801518B0(globalCtx, 0x45E, &this->actor);
-                    this->curTextId = 0x45E; // "...Hang on there, little guy.  I can't take any more deposits.  Sorry..."
+                    this->curTextId =
+                        0x45E; // "...Hang on there, little guy.  I can't take any more deposits.  Sorry..."
                 } else {
                     func_800BDC5C(&this->skelAnime, animations, GINKO_FLOORSMACKING);
                     func_801518B0(globalCtx, 0x460, &this->actor);
@@ -248,7 +250,7 @@ void EnGinkoMan_DepositDialogue(EnGinkoMan* this, GlobalContext* globalCtx) {
             func_801518B0(globalCtx, 0x468, &this->actor);
             this->curTextId = 0x468; // " Deposit Rupees Withdraw Rupees Nothing really"
             break;
-        case 0x469: // "Excuse me, but let me take a look at you..."
+        case 0x469:                      // "Excuse me, but let me take a look at you..."
             EnGinkoMan_SetupStamp(this); // stamp player
             break;
         case 0x46A: // "Ah, yes...[Link].  If I remember, you're the little guy who deposited [rupees]."
@@ -281,7 +283,8 @@ void EnGinkoMan_DepositDialogue(EnGinkoMan* this, GlobalContext* globalCtx) {
             func_801518B0(globalCtx, 0x46E, &this->actor);
             this->curTextId = 0x46E; // "How much do you want?  [rupee prompt]
             break;
-        case 0x46D: // "Look, little guy, if it's 'cause of the bad rumors going around, forget it! They're just rumors!"
+        case 0x46D: // "Look, little guy, if it's 'cause of the bad rumors going around, forget it! They're just
+                    // rumors!"
             func_801518B0(globalCtx, 0x46B, &this->actor);
             this->curTextId = 0x46B; // So...
             break;
@@ -292,7 +295,8 @@ void EnGinkoMan_DepositDialogue(EnGinkoMan* this, GlobalContext* globalCtx) {
                 EnGinkoMan_SetupIdle(this); // change to waiting for approach
             }
             break;
-        case 0x476: // "...You haven't deposited that many Rupees, so that much isn't available for withdrawal. Do the math!
+        case 0x476: // "...You haven't deposited that many Rupees, so that much isn't available for withdrawal. Do the
+                    // math!
             func_800BDC5C(&this->skelAnime, animations, GINKO_SITTING);
         case 0x475: // "What's this?  Look, little guy, you can't hold this many rupees! You got that?"
         case 0x47C: // "Is that so?  Think it over, little guy!  So what are you gonna do?"
@@ -302,7 +306,8 @@ void EnGinkoMan_DepositDialogue(EnGinkoMan* this, GlobalContext* globalCtx) {
             break;
         case 0x472: // "What's this? It's a waste to take out such a tiny bit!  ...But if you say so!"
         case 0x473: // Use it wisely...
-        case 0x474: // "Aw, you're taking out all that?  If you spend it like that, it'll all be gone before you know it!"
+        case 0x474: // "Aw, you're taking out all that?  If you spend it like that, it'll all be gone before you know
+                    // it!"
             if ((gSaveContext.roomInf[127][0] & 0xFFFF) == 0) {
                 func_801518B0(globalCtx, 0x478, &this->actor);
                 //  "Look, little guy, all the Rupees you deposited are gone, so you can't use that stamp anymore."
@@ -375,16 +380,17 @@ void EnGinkoMan_WaitForDialogueInput(EnGinkoMan* this, GlobalContext* globalCtx)
                         func_801518B0(globalCtx, 0x453, &this->actor);
                         this->curTextId = 0x453; // That's it? That aint nothing at all
                     }
-                    
+
                     if ((gSaveContext.roomInf[127][0] & 0xFFFF) == 0) {
                         this->isNewAccount = true;
                     }
 
-                    func_801159EC((s16) -globalCtx->msgCtx.bankRupeesSelected);
+                    func_801159EC((s16)-globalCtx->msgCtx.bankRupeesSelected);
                     this->previousBankValue = gSaveContext.roomInf[127][0] & 0xFFFF;
                     if (1) {} // Needed to match
                     gSaveContext.roomInf[127][0] =
-                        (gSaveContext.roomInf[127][0] & 0xFFFF0000) | ((gSaveContext.roomInf[127][0] & 0xFFFF) + globalCtx->msgCtx.bankRupeesSelected);
+                        (gSaveContext.roomInf[127][0] & 0xFFFF0000) |
+                        ((gSaveContext.roomInf[127][0] & 0xFFFF) + globalCtx->msgCtx.bankRupeesSelected);
                 }
             } else { // GINKOMAN_CHOICE_NO
                 func_8019F230();
@@ -444,7 +450,9 @@ void EnGinkoMan_WaitForDialogueInput(EnGinkoMan* this, GlobalContext* globalCtx)
 
                     this->previousBankValue = (s16)(gSaveContext.roomInf[127][0] & 0xFFFF);
                     gSaveContext.roomInf[127][0] =
-                        (gSaveContext.roomInf[127][0] & 0xFFFF0000) | (((gSaveContext.roomInf[127][0] & 0xFFFF) - globalCtx->msgCtx.bankRupeesSelected) - this->serviceFee);
+                        (gSaveContext.roomInf[127][0] & 0xFFFF0000) |
+                        (((gSaveContext.roomInf[127][0] & 0xFFFF) - globalCtx->msgCtx.bankRupeesSelected) -
+                         this->serviceFee);
                     func_801159EC(globalCtx->msgCtx.bankRupeesSelected);
                 }
             } else {
@@ -554,7 +562,8 @@ void EnGinkoMan_SetupBankAward2(EnGinkoMan* this) {
 void EnGinkoMan_BankAward2(EnGinkoMan* this, GlobalContext* globalCtx) {
     if (func_800B84D0(&this->actor, globalCtx)) {
         if (!(gSaveContext.weekEventReg[10] & 8) && (this->curTextId == 0x45B)) {
-            // "What's this? You've already saved up 200 Rupees!?!  Well, little guy, here's your special gift. Take it!"
+            // "What's this? You've already saved up 200 Rupees!?!  Well, little guy, here's your special gift. Take
+            // it!"
             gSaveContext.weekEventReg[10] |= 8;
             func_801518B0(globalCtx, 0x47A, &this->actor);
             this->curTextId = 0x47A; // "See! Doesn't it hold more than your old one?
@@ -646,7 +655,8 @@ void EnGinkoMan_Update(Actor* thisx, GlobalContext* globalCtx) {
     EnGinkoMan_FacePlayer(this, globalCtx);
 }
 
-s32 EnGinkoMan_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* thisx) {
+s32 EnGinkoMan_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
+                                Actor* thisx) {
     EnGinkoMan* this = THIS;
 
     if (limbIndex == 15) {
diff --git a/src/overlays/actors/ovl_En_Minifrog/z_en_minifrog.c b/src/overlays/actors/ovl_En_Minifrog/z_en_minifrog.c
index c50714a636..0472092ce0 100644
--- a/src/overlays/actors/ovl_En_Minifrog/z_en_minifrog.c
+++ b/src/overlays/actors/ovl_En_Minifrog/z_en_minifrog.c
@@ -75,7 +75,7 @@ static UNK_TYPE4* D_808A4D74[] = {
 // gSaveContext.weekEventReg[KEY] = VALUE
 // KEY | VALUE
 static u16 isFrogReturnedFlags[] = {
-    (0 << 8)  | 0x00, // NULL
+    (0 << 8) | 0x00,  // NULL
     (32 << 8) | 0x40, // Woodfall Temple Frog Returned
     (32 << 8) | 0x80, // Great Bay Temple Frog Returned
     (33 << 8) | 0x01, // Southern Swamp Frog Returned
@@ -94,7 +94,8 @@ void EnMinifrog_Init(Actor* thisx, GlobalContext* globalCtx) {
 
     Actor_ProcessInitChain(&this->actor, sInitChain);
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 15.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600B538, &D_06001534, this->limbDrawTable, this->transitionDrawTable, 24);
+    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600B538, &D_06001534, this->limbDrawTable,
+                     this->transitionDrawTable, 24);
     CollisionCheck_SetInfo(&this->actor.colChkInfo, NULL, &sColChkInfoInit);
     Collider_InitAndSetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
 
@@ -118,7 +119,9 @@ void EnMinifrog_Init(Actor* thisx, GlobalContext* globalCtx) {
 
     if (1) {}
     if (!EN_MINIFROG_IS_RETURNED(this)) {
-        if ((this->frogIndex == MINIFROG_YELLOW) || ((gSaveContext.weekEventReg[isFrogReturnedFlags[this->frogIndex] >> 8] & (u8)isFrogReturnedFlags[this->frogIndex]))) {
+        if ((this->frogIndex == MINIFROG_YELLOW) ||
+            ((gSaveContext.weekEventReg[isFrogReturnedFlags[this->frogIndex] >> 8] &
+              (u8)isFrogReturnedFlags[this->frogIndex]))) {
             Actor_MarkForDeath(&this->actor);
         } else {
             this->timer = 30;
@@ -143,7 +146,8 @@ void EnMinifrog_Init(Actor* thisx, GlobalContext* globalCtx) {
             this->actor.flags &= ~1;
 
             // Frog has been returned
-            if ((gSaveContext.weekEventReg[isFrogReturnedFlags[this->frogIndex] >> 8] & (u8)isFrogReturnedFlags[this->frogIndex])) {
+            if ((gSaveContext.weekEventReg[isFrogReturnedFlags[this->frogIndex] >> 8] &
+                 (u8)isFrogReturnedFlags[this->frogIndex])) {
                 this->actionFunc = EnMinifrog_SetupNextFrogInit;
             } else {
                 this->actor.draw = NULL;
@@ -272,7 +276,7 @@ void EnMinifrog_ReturnFrogCutscene(EnMinifrog* this, GlobalContext* globalCtx) {
             case 0xD87: // "Ah! You need not say a thing. Upon seeing that face, I understand!" ...
                 func_80151938(globalCtx, globalCtx->msgCtx.unk11F04 + 1);
                 break;
-            case 0xD82:                                          // "What has brought you all this way?"
+            case 0xD82:                                     // "What has brought you all this way?"
                 if (gSaveContext.weekEventReg[33] & 0x80) { // Mountain village is unfrozen
                     func_80151938(globalCtx, 0xD83); // "Could it be... Has spring finally come to the mountains?"
                 } else {
@@ -280,7 +284,8 @@ void EnMinifrog_ReturnFrogCutscene(EnMinifrog* this, GlobalContext* globalCtx) {
                 }
 
                 flag = gSaveContext.weekEventReg[isFrogReturnedFlags[this->frogIndex] >> 8];
-                gSaveContext.weekEventReg[isFrogReturnedFlags[this->frogIndex] >> 8] = flag | (u8)isFrogReturnedFlags[this->frogIndex];
+                gSaveContext.weekEventReg[isFrogReturnedFlags[this->frogIndex] >> 8] =
+                    flag | (u8)isFrogReturnedFlags[this->frogIndex];
                 break;
             case 0xD85: // "I understand. I shall head for the mountains immediately."
             default:
@@ -332,7 +337,8 @@ void EnMinifrog_Idle(EnMinifrog* this, GlobalContext* globalCtx) {
         if (this->actor.cutscene != -1) {
             this->flags |= 1;
         }
-    } else if ((this->actor.xzDistToPlayer < 100.0f) && Actor_IsLinkFacingActor(&this->actor, 0x3000, globalCtx) && (func_8012403C(globalCtx) == 0xD)) {
+    } else if ((this->actor.xzDistToPlayer < 100.0f) && Actor_IsLinkFacingActor(&this->actor, 0x3000, globalCtx) &&
+               (func_8012403C(globalCtx) == 0xD)) {
         func_800B8614(&this->actor, globalCtx, 110.0f);
     }
 }
@@ -346,7 +352,8 @@ void EnMinifrog_SetupNextFrogInit(EnMinifrog* this, GlobalContext* globalCtx) {
     if (nextFrog != NULL) {
         missingFrog = nextFrog->frog;
         if (nextFrog->frog != NULL) {
-            this->actor.home.rot.y = (s16)Actor_YawBetweenActors(&this->actor, &missingFrog->actor); // Set home to missing frog
+            this->actor.home.rot.y =
+                (s16)Actor_YawBetweenActors(&this->actor, &missingFrog->actor); // Set home to missing frog
             EnMinifrog_TurnToMissingFrog(this);
         } else {
             EnMinifrog_TurnToPlayer(this);
@@ -364,7 +371,8 @@ void EnMinifrog_CheckChoirSuccess(EnMinifrog* this, GlobalContext* globalCtx) {
     if (this->frog != NULL) {
         func_80151938(globalCtx, 0xD78); // "Unfortunately, it seems not all of our members have gathered."
     } else {
-        func_80151938(globalCtx, 0xD7C); // "The conducting was spectacular. And all of our members rose to the occasion!"
+        func_80151938(globalCtx,
+                      0xD7C); // "The conducting was spectacular. And all of our members rose to the occasion!"
     }
 
     EnMinifrog_SetJumpState(this);
@@ -562,13 +570,17 @@ void EnMinifrog_SetupYellowFrogDialog(EnMinifrog* this, GlobalContext* globalCtx
     EnMinifrog_JumpTimer(this);
     if (func_800B84D0(&this->actor, globalCtx)) {
         this->actionFunc = EnMinifrog_YellowFrogDialog;
-        if (!(gSaveContext.weekEventReg[34] & 1)) {         // Not spoken with MINIFROG_YELLOW
-            func_801518B0(globalCtx, 0xD76, &this->actor);  // "I have been waiting for you, Don Gero. Forgive me if I'm mistaken, but it
-                                                            // looks like you've lost a little weight..."
+        if (!(gSaveContext.weekEventReg[34] & 1)) { // Not spoken with MINIFROG_YELLOW
+            func_801518B0(globalCtx, 0xD76,
+                          &this->actor); // "I have been waiting for you, Don Gero. Forgive me if I'm mistaken, but it
+                                         // looks like you've lost a little weight..."
         } else {
             func_801518B0(globalCtx, 0xD7F, &this->actor); // "Well, if it isn't the great Don Gero."
         }
-    } else if ((this->actor.xzDistToPlayer < 150.0f) && (Actor_IsLinkFacingActor(&this->actor, 0x3000, globalCtx) || ((this->actor.flags & 0x10000) == 0x10000)) && func_8012403C(globalCtx) == 0xD) {
+    } else if ((this->actor.xzDistToPlayer < 150.0f) &&
+               (Actor_IsLinkFacingActor(&this->actor, 0x3000, globalCtx) ||
+                ((this->actor.flags & 0x10000) == 0x10000)) &&
+               func_8012403C(globalCtx) == 0xD) {
         func_800B8614(&this->actor, globalCtx, 160.0f);
     }
 }
@@ -595,7 +607,8 @@ void EnMinifrog_UpdateMissingFrog(Actor* thisx, GlobalContext* globalCtx) {
     }
 }
 
-s32 EnMinifrog_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* thisx) {
+s32 EnMinifrog_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
+                                Actor* thisx) {
     if (limbIndex == 1) {
         pos->z -= 500.0f;
     }
@@ -617,7 +630,7 @@ void EnMinifrog_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dLis
         gSPDisplayList(POLY_OPA_DISP++, *dList);
         CLOSE_DISPS(globalCtx->state.gfxCtx);
     }
-    
+
     if (limbIndex == 4) {
         SysMatrix_GetStateTranslation(&this->actor.focus.pos);
     }
diff --git a/src/overlays/actors/ovl_En_Nutsball/z_en_nutsball.c b/src/overlays/actors/ovl_En_Nutsball/z_en_nutsball.c
index 4fd17c07a8..ec4bb40b82 100644
--- a/src/overlays/actors/ovl_En_Nutsball/z_en_nutsball.c
+++ b/src/overlays/actors/ovl_En_Nutsball/z_en_nutsball.c
@@ -112,8 +112,7 @@ void EnNutsball_Update(Actor* thisx, GlobalContext* globalCtx) {
                 spawnBurstPos.x = this->actor.world.pos.x;
                 spawnBurstPos.y = this->actor.world.pos.y + 4.0f;
                 spawnBurstPos.z = this->actor.world.pos.z;
-                EffectSsHahen_SpawnBurst(globalCtx, &spawnBurstPos, 0x40C00000, 0, 7, 3, 15, HAHEN_OBJECT_DEFAULT, 10,
-                                         NULL);
+                EffectSsHahen_SpawnBurst(globalCtx, &spawnBurstPos, 6.0f, 0, 7, 3, 15, HAHEN_OBJECT_DEFAULT, 10, NULL);
                 if (this->actor.params == 1) {
                     func_800F0568(globalCtx, &this->actor.world.pos, 20, NA_SE_EV_NUTS_BROKEN);
                 } else {
diff --git a/src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.c b/src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.c
index 85a3f4a04e..3c918bd943 100644
--- a/src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.c
+++ b/src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.c
@@ -174,7 +174,7 @@ void EnPametfrog_Init(Actor* thisx, GlobalContext* globalCtx) {
     if (Actor_GetRoomCleared(globalCtx, globalCtx->roomContext.currRoom.num)) {
         Actor_MarkForDeath(&this->actor);
         if (!(gSaveContext.weekEventReg[isFrogReturnedFlags[this->actor.params - 1] >> 8] &
-             (u8)isFrogReturnedFlags[this->actor.params - 1])) {
+              (u8)isFrogReturnedFlags[this->actor.params - 1])) {
             Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_MINIFROG, this->actor.world.pos.x,
                         this->actor.world.pos.y, this->actor.world.pos.z, 0, this->actor.shape.rot.y, 0, this->params);
         }
@@ -469,7 +469,8 @@ void EnPametfrog_RearOnSnapperRise(EnPametfrog* this, GlobalContext* globalCtx)
     if (this->timer == 0) {
         EnPametfrog_SetupRearOnSnapper(this);
     } else {
-        this->actor.world.pos.y = Math_SinS(this->timer * 0xCCC) * 100.0f + (((EnBigpamet*)this->actor.child)->unk_2AC + 46.0f);
+        this->actor.world.pos.y =
+            Math_SinS(this->timer * 0xCCC) * 100.0f + (((EnBigpamet*)this->actor.child)->unk_2AC + 46.0f);
     }
 }
 
@@ -505,7 +506,7 @@ void EnPametfrog_FallOffSnapper(EnPametfrog* this, GlobalContext* globalCtx) {
         this->timer--;
     }
 
-    sin = sin_rad(this->timer * (M_PI/3.0f)) * ((0.02f * (this->timer * (1.0f/6.0f))) + 0.005f) + 1.0f;
+    sin = sin_rad(this->timer * (M_PI / 3.0f)) * ((0.02f * (this->timer * (1.0f / 6.0f))) + 0.005f) + 1.0f;
     EnPametfrog_ShakeCamera(this, globalCtx, 300.0f * sin, 100.0f * sin);
     if (this->actor.bgCheckFlags & 1) {
         EnPametfrog_StopCutscene(this, globalCtx);
@@ -643,7 +644,7 @@ void EnPametfrog_SetupWallPause(EnPametfrog* this) {
     this->actor.speedXZ = 0.0f;
     this->skelAnime.animPlaybackSpeed = 1.5f;
     if (this->timer != 0) {
-        this->wallRotation = this->unk_2E8.y > 0.0f ? (M_PI/30.0f) : (-M_PI/30.0f);
+        this->wallRotation = this->unk_2E8.y > 0.0f ? (M_PI / 30.0f) : (-M_PI / 30.0f);
     } else {
         randFloat = Rand_ZeroFloat(0x2000);
         this->wallRotation = (Rand_ZeroOne() < 0.5f ? -1 : 1) * (0x1000 + randFloat) * (M_PI / (15 * 0x8000));
@@ -959,7 +960,7 @@ void EnPametfrog_SpawnFrog(EnPametfrog* this, GlobalContext* globalCtx) {
     f32 magShake;
 
     this->timer--;
-    magShake = (sin_rad(this->timer * (M_PI/5.0f)) * ((0.04f * (this->timer * 0.1f)) + 0.02f)) + 1.0f;
+    magShake = (sin_rad(this->timer * (M_PI / 5.0f)) * ((0.04f * (this->timer * 0.1f)) + 0.02f)) + 1.0f;
     EnPametfrog_ShakeCamera(this, globalCtx, 75.0f * magShake, 10.0f * magShake);
     if (this->timer == 0) {
         EnPametfrog_StopCutscene(this, globalCtx);
@@ -1212,7 +1213,7 @@ void EnPametfrog_SetupSnapperSpawn(EnPametfrog* this, GlobalContext* globalCtx)
 void EnPametfrog_SnapperSpawn(EnPametfrog* this, GlobalContext* globalCtx) {
     this->timer--;
     EnPametfrog_ShakeCamera(this, globalCtx, (f32)(this->timer * 7.5f) + 200.0f,
-                            ((f32)(this->timer * 2) * (15.0f/16.0f)) + -20.0f);
+                            ((f32)(this->timer * 2) * (15.0f / 16.0f)) + -20.0f);
     if (this->timer != 0) {
         func_8013ECE0(this->actor.xyzDistToPlayerSq, 120, 20, 10);
     } else {
@@ -1338,7 +1339,7 @@ void EnPametfrog_Update(Actor* thisx, GlobalContext* globalCtx) {
             unk2C4 = ((this->unk_2C4 + 1.0f) * 0.375f);
             this->unk_2C8 = unk2C4;
             this->unk_2C8 = unk2C4 > 0.75f ? 0.75f : this->unk_2C8;
-        } else if (!Math_StepToF(&this->unk_2CC, 0.75f, (3.0f/160.0f))) {
+        } else if (!Math_StepToF(&this->unk_2CC, 0.75f, (3.0f / 160.0f))) {
             func_800B9010(&this->actor, NA_SE_EV_ICE_FREEZE - SFX_FLAG);
         }
     }
diff --git a/src/overlays/actors/ovl_En_Torch2/z_en_torch2.c b/src/overlays/actors/ovl_En_Torch2/z_en_torch2.c
index 14c5aadf72..f1a07ea56e 100644
--- a/src/overlays/actors/ovl_En_Torch2/z_en_torch2.c
+++ b/src/overlays/actors/ovl_En_Torch2/z_en_torch2.c
@@ -77,7 +77,7 @@ void EnTorch2_Destroy(Actor* thisx, GlobalContext* globalCtx) {
     EnTorch2* this = THIS;
 
     Collider_DestroyCylinder(globalCtx, &this->collider);
-    func_80169DCC(globalCtx, this->actor.params + 3, 0xFF, 0, 0xBFF, &this->actor.world, this->actor.shape.rot.y);
+    func_80169DCC(globalCtx, this->actor.params + 3, 0xFF, 0, 0xBFF, &this->actor.world.pos, this->actor.shape.rot.y);
     globalCtx->actorCtx.unk254[this->actor.params] = 0;
 }
 
diff --git a/src/overlays/actors/ovl_Obj_Ghaka/z_obj_ghaka.c b/src/overlays/actors/ovl_Obj_Ghaka/z_obj_ghaka.c
index 9b23336819..4bec51d33c 100644
--- a/src/overlays/actors/ovl_Obj_Ghaka/z_obj_ghaka.c
+++ b/src/overlays/actors/ovl_Obj_Ghaka/z_obj_ghaka.c
@@ -46,7 +46,6 @@ extern Gfx D_06001A20[];
 extern Gfx D_06001980[];
 extern CollisionHeader D_06003CD0;
 
-
 void func_80B3C260(ObjGhaka* this) {
     if (gSaveContext.weekEventReg[20] & 0x20) {
         this->dyna.actor.world.pos.z = this->dyna.actor.home.pos.z + 100.0f;
diff --git a/src/overlays/actors/ovl_Obj_Kibako/z_obj_kibako.c b/src/overlays/actors/ovl_Obj_Kibako/z_obj_kibako.c
index 7ee106ed26..0d390df513 100644
--- a/src/overlays/actors/ovl_Obj_Kibako/z_obj_kibako.c
+++ b/src/overlays/actors/ovl_Obj_Kibako/z_obj_kibako.c
@@ -79,8 +79,7 @@ void ObjKibako_SpawnCollectible(ObjKibako* this, GlobalContext* globalCtx) {
     if (this->isDropCollected == 0) {
         collectible = func_800A8150(this->actor.params & 0x3F);
         if (collectible >= 0) {
-            Item_DropCollectible(globalCtx, &this->actor.world.pos,
-                                 collectible | GET_KIBAKO_COLLECTIBLE_ID(this));
+            Item_DropCollectible(globalCtx, &this->actor.world.pos, collectible | GET_KIBAKO_COLLECTIBLE_ID(this));
             this->isDropCollected = 1;
         }
     }
@@ -188,10 +187,9 @@ void ObjKibako_AirBreak(ObjKibako* this, GlobalContext* globalCtx) {
             phi_s0 = 0x20;
         }
 
-        EffectSsKakera_Spawn(globalCtx, &pos, &velocity, worldPos, -200, phi_s0, 20, 0, 0,
-                             (Rand_ZeroOne() * 38.0f) + 10.0f, 0, 0, 60, -1,
-                             sObjectIdList[(this->actor.params >> 0xF) & 1],
-                             sKakeraDisplayLists[(this->actor.params >> 0xF) & 1]);
+        EffectSsKakera_Spawn(
+            globalCtx, &pos, &velocity, worldPos, -200, phi_s0, 20, 0, 0, (Rand_ZeroOne() * 38.0f) + 10.0f, 0, 0, 60,
+            -1, sObjectIdList[(this->actor.params >> 0xF) & 1], sKakeraDisplayLists[(this->actor.params >> 0xF) & 1]);
     }
 
     func_800BBFB0(globalCtx, worldPos, 40.0f, 3, 0x32, 0x8C, 1);
@@ -233,10 +231,9 @@ void ObjKibako_WaterBreak(ObjKibako* this, GlobalContext* globalCtx) {
         temp_rand = Rand_ZeroOne();
         phi_s0 = (temp_rand < 0.2f) ? 0x40 : 0x20;
 
-        EffectSsKakera_Spawn(globalCtx, &pos, &velocity, worldPos, -180, phi_s0, 50, 5, 0,
-                             (Rand_ZeroOne() * 35.0f) + 10.0f, 0, 0, 70, -1,
-                             sObjectIdList[(this->actor.params >> 0xF) & 1],
-                             sKakeraDisplayLists[(this->actor.params >> 0xF) & 1]);
+        EffectSsKakera_Spawn(
+            globalCtx, &pos, &velocity, worldPos, -180, phi_s0, 50, 5, 0, (Rand_ZeroOne() * 35.0f) + 10.0f, 0, 0, 70,
+            -1, sObjectIdList[(this->actor.params >> 0xF) & 1], sKakeraDisplayLists[(this->actor.params >> 0xF) & 1]);
     }
 }
 
@@ -269,7 +266,7 @@ void ObjKibako_Idle(ObjKibako* this, GlobalContext* globalCtx) {
         if (func_800A817C(this->actor.params & 0x3F)) {
             ObjKibako_SpawnCollectible(this, globalCtx);
         }
-        func_800B8E58(this, 0x878);
+        func_800B8E58(&this->actor, NA_SE_PL_PULL_UP_WOODBOX);
     } else if ((this->actor.bgCheckFlags & 0x20) && (this->actor.yDistToWater > 19.0f)) {
         ObjKibako_WaterBreak(this, globalCtx);
         ObjKibako_SpawnCollectible(this, globalCtx);
diff --git a/src/overlays/actors/ovl_Obj_Lightswitch/z_obj_lightswitch.c b/src/overlays/actors/ovl_Obj_Lightswitch/z_obj_lightswitch.c
index 9d12535efd..40fdbaac48 100644
--- a/src/overlays/actors/ovl_Obj_Lightswitch/z_obj_lightswitch.c
+++ b/src/overlays/actors/ovl_Obj_Lightswitch/z_obj_lightswitch.c
@@ -174,6 +174,7 @@ void ObjLightswitch_SpawnEffects(ObjLightswitch* this, GlobalContext* globalCtx)
     }
 }
 #else
+void ObjLightswitch_SpawnEffects(ObjLightswitch* this, GlobalContext* globalCtx);
 #pragma GLOBAL_ASM("./asm/non_matchings/overlays/ovl_Obj_Lightswitch_0x8095FBF0/ObjLightswitch_SpawnEffects.asm")
 #endif
 
@@ -446,6 +447,7 @@ void ObjLightSwitch_DrawOpa(ObjLightswitch* this, GlobalContext* globalCtx) {
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
 #else
+void ObjLightSwitch_DrawOpa(ObjLightswitch* this, GlobalContext* globalCtx);
 #pragma GLOBAL_ASM("./asm/non_matchings/overlays/ovl_Obj_Lightswitch_0x8095FBF0/ObjLightSwitch_DrawOpa.asm")
 #endif
 
@@ -498,6 +500,7 @@ void ObjLightSwitch_DrawXlu(ObjLightswitch* this, GlobalContext* globalCtx) {
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
 #else
+void ObjLightSwitch_DrawXlu(ObjLightswitch* this, GlobalContext* globalCtx);
 #pragma GLOBAL_ASM("./asm/non_matchings/overlays/ovl_Obj_Lightswitch_0x8095FBF0/ObjLightSwitch_DrawXlu.asm")
 #endif
 
diff --git a/tables/functions.txt b/tables/functions.txt
index 62897e70ac..36d09164f4 100644
--- a/tables/functions.txt
+++ b/tables/functions.txt
@@ -3363,11 +3363,11 @@
     0x801800CC:("Math_Atan2F",),
     0x80180100:("Math_FAtan2F",),
     0x8018012C:("Math_Acot2F",),
-    0x80180160:("Matrix_Init",),
-    0x8018019C:("Matrix_Push",),
-    0x801801CC:("Matrix_Pop",),
+    0x80180160:("SysMatrix_StateAlloc",),
+    0x8018019C:("SysMatrix_StatePush",),
+    0x801801CC:("SysMatrix_StatePop",),
     0x801801E8:("SysMatrix_CopyCurrentState",),
-    0x8018020C:("Matrix_Put",),
+    0x8018020C:("SysMatrix_SetCurrentState",),
     0x80180234:("SysMatrix_GetCurrentState",),
     0x80180244:("SysMatrix_InsertMatrix",),
     0x8018029C:("SysMatrix_InsertTranslation",),
diff --git a/tools/actorfixer.py b/tools/actorfixer.py
index d40e34cada..199576761d 100755
--- a/tools/actorfixer.py
+++ b/tools/actorfixer.py
@@ -8,6 +8,10 @@ animdict ={
     "Actor_GetSwitchFlag": "Flags_GetSwitch",
     "atan_flip": "Math_Acot2F",
     "atans": "Math_Atan2S",
+    "Matrix_Pop": "SysMatrix_StatePop",
+    "Matrix_Push": "SysMatrix_StatePush",
+    "Matrix_Init": "SysMatrix_StateAlloc",
+    "Matrix_Put": "SysMatrix_SetCurrentState",
 }
 
 def replace_anim(file):