Merge branch 'main' into Caladius-patch-1Caladius-patch-1

54 files changed, 579 insertions, 699 deletions

diff --git a/src/actors/fake_item_box/render.inc.c b/src/actors/fake_item_box/render.inc.c
index 0b7ec41f3..e705a90ef 100644
--- a/src/actors/fake_item_box/render.inc.c
+++ b/src/actors/fake_item_box/render.inc.c
@@ -26,7 +26,7 @@ void render_actor_fake_item_box(Camera* camera, struct FakeItemBox* fakeItemBox)
     f32 someMultiplier;
 
     size_t actorIdx = CM_FindActorIndex((struct Actor*)fakeItemBox);
-    if (-1 == actorIdx) {
+    if (-1 == (s32) actorIdx) {
         printf("[render_actor_fake_item_box] Could not find fake item box for FI, skipping!\n");
         return;
     }
diff --git a/src/actors/green_shell/update.inc.c b/src/actors/green_shell/update.inc.c
index 15d4f4c15..53b89a492 100644
--- a/src/actors/green_shell/update.inc.c
+++ b/src/actors/green_shell/update.inc.c
@@ -183,7 +183,7 @@ void update_actor_green_shell(struct ShellActor* shell) {
             break;
         case GREEN_SHELL_HIT_A_RACER:
             // Somehow, this fake match affects stack management up in case 2
-            shell->velocity[1] -= (0, 0.3f);
+            shell->velocity[1] -= 0.3f;
             if (shell->velocity[1] < -5.0f) {
                 shell->velocity[1] = -5.0f;
             }
diff --git a/src/actors/item_box/render.inc.c b/src/actors/item_box/render.inc.c
index c1ea76b11..c9134b23e 100644
--- a/src/actors/item_box/render.inc.c
+++ b/src/actors/item_box/render.inc.c
@@ -28,7 +28,7 @@ void render_actor_item_box(Camera* camera, struct ItemBox* item_box) {
     f32 someMultiplier;
 
     size_t actorIdx = CM_FindActorIndex((struct Actor*)item_box);
-    if (-1 == actorIdx) {
+    if (-1 == (s32) actorIdx) {
         printf("[render_actor_item_box] Could not find item box for FI, skipping!\n");
         return;
     }
diff --git a/src/actors/kiwano_fruit/render.inc.c b/src/actors/kiwano_fruit/render.inc.c
index 9aea3b2e5..069030a68 100644
--- a/src/actors/kiwano_fruit/render.inc.c
+++ b/src/actors/kiwano_fruit/render.inc.c
@@ -34,13 +34,13 @@ void render_actor_kiwano_fruit(UNUSED Camera* camera, Mat4 arg1, struct Actor* a
     size_t idx = (actor->rot[0] << 0xA) / ResourceGetTexSizeByName(gTextureDksJungleParkwayKiwanoFruit1);
     switch(idx) {
         case 0:
-            addr = gTextureDksJungleParkwayKiwanoFruit1;
+            addr = (uintptr_t) gTextureDksJungleParkwayKiwanoFruit1;
             break;
         case 1:
-            addr = gTextureDksJungleParkwayKiwanoFruit2;
+            addr = (uintptr_t) gTextureDksJungleParkwayKiwanoFruit2;
             break;
         case 2:
-            addr = gTextureDksJungleParkwayKiwanoFruit3;
+            addr = (uintptr_t) gTextureDksJungleParkwayKiwanoFruit3;
             break;
     }
 
diff --git a/src/actors/piranha_plant/render.inc.c b/src/actors/piranha_plant/render.inc.c
index 2fba23716..2850dc0a7 100644
--- a/src/actors/piranha_plant/render.inc.c
+++ b/src/actors/piranha_plant/render.inc.c
@@ -26,7 +26,7 @@ const char* sPiranhaPlantTextures[] = {
  */
 void render_actor_piranha_plant(Camera* camera, Mat4 arg1, struct PiranhaPlant* arg2) {
     UNUSED s32 pad;
-    u8* addr;
+    UNUSED u8* addr;
     s16 temp_lo = camera - camera1;
     s16 animationFrame; // unconfirmed
     s16 temp = arg2->flags;
diff --git a/src/actors/yoshi_egg/render.inc.c b/src/actors/yoshi_egg/render.inc.c
index 7bb2cc884..2a1ed1dc6 100644
--- a/src/actors/yoshi_egg/render.inc.c
+++ b/src/actors/yoshi_egg/render.inc.c
@@ -20,7 +20,7 @@ void render_actor_yoshi_egg(Camera* camera, Mat4 arg1, struct YoshiValleyEgg* eg
     f32 temp_f0;
 
     size_t actorIdx = CM_FindActorIndex((struct Actor*) egg);
-    if (-1 == actorIdx) {
+    if (-1 == (s32) actorIdx) {
         printf("[render_actor_yoshi_egg] Could not find actor for FI, skipping\n");
         return;
     }
diff --git a/src/audio/data.c b/src/audio/data.c
index 03e470fcf..e9c87e413 100644
--- a/src/audio/data.c
+++ b/src/audio/data.c
@@ -224,9 +224,9 @@ u8 gDefaultShortNoteDurationTable[16] = {
 };
 
 struct AdsrEnvelope gDefaultEnvelope[] = {
-    { BSWAP16(4), BSWAP16(32000) },    // go from 0 to 32000 over the course of 16ms
-    { BSWAP16(1000), BSWAP16(32000) }, // stay there for 4.16 seconds
-    { BSWAP16(ADSR_HANG), 0 }          // then continue staying there
+    { BOMSWAP16_CONST(4), BOMSWAP16_CONST(32000) },    // go from 0 to 32000 over the course of 16ms
+    { BOMSWAP16_CONST(1000), BOMSWAP16_CONST(32000) }, // stay there for 4.16 seconds
+    { BOMSWAP16_CONST(ADSR_HANG), 0 }                  // then continue staying there
 };
 
 //! @todo 0x00000000800f624c                fill2
diff --git a/src/audio/effects.h b/src/audio/effects.h
index 8c7712825..a10673207 100644
--- a/src/audio/effects.h
+++ b/src/audio/effects.h
@@ -26,13 +26,7 @@
 #define ADSR_GOTO -2
 #define ADSR_RESTART -3
 
-// Envelopes are always stored as big endian, to match sequence files which are
-// byte blobs and can embed envelopes. Hence this byteswapping macro.
-#if IS_BIG_ENDIAN
-#define BSWAP16(x) (x)
-#else
-#define BSWAP16(x) (((x) & 0xff) << 8 | (((x) >> 8) & 0xff))
-#endif
+#include <macros.h>
 
 void sequence_channel_process_sound(struct SequenceChannel* seqChannel, s32 recalculateVolume);
 void sequence_player_process_sound(struct SequencePlayer* seqPlayer);
diff --git a/src/audio/external.c b/src/audio/external.c
index 564079a55..90ce0cb63 100644
--- a/src/audio/external.c
+++ b/src/audio/external.c
@@ -392,8 +392,8 @@ void func_800C19D0(u8 arg0, u8 arg1, u8 arg2) {
 
 struct Unk_8018EFD8* func_800C1C88(u8 arg0, Vec3f position, f32* velocity, f32* arg3, u8 arg4, u32 soundBits) {
     struct Unk_8018EFD8* temp_a1;
-    struct Unk_8018EFD8* temp_v1;
-    u8 temp_t7;
+    UNUSED struct Unk_8018EFD8* temp_v1;
+    UNUSED u8 temp_t7;
     u8 why1;
 
     if (D_8018EFD8[D_8018FB90].next != 0xFF) {
@@ -949,7 +949,7 @@ void func_800C3448(u32 arg0) {
 }
 
 void func_800C3478(void) {
-    for (D_800EA1E8; D_800EA1E4 != D_800EA1E8;) {
+    while (D_800EA1E4 != D_800EA1E8) {
         func_800C2A2C(D_80192CD0[D_800EA1E8++]);
     }
 }
@@ -1410,7 +1410,7 @@ void func_800C4398(void) {
         sSoundBanks[bank][soundIndex].cameraId = var_a2->cameraId;
         sSoundBanks[bank][soundIndex].unk10 = var_a2->unk0C;
         sSoundBanks[bank][soundIndex].unk14 = var_a2->unk10;
-        sSoundBanks[bank][0, soundIndex].unk18 = var_a2->unk14;
+        sSoundBanks[bank][soundIndex].unk18 = var_a2->unk14;
         sSoundBanks[bank][soundIndex].soundBits = var_a2->soundBits;
         sSoundBanks[bank][soundIndex].soundStatus = (u8) ((u32) (var_a2->soundBits & 0x01000000) >> 0x18);
         sSoundBanks[bank][soundIndex].freshness = 2;
@@ -1928,11 +1928,11 @@ void func_800C5E38(u8 playerId) {
                             if ((s32) D_800EA1C0 < 2) {
                                 play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF9, 0x26), &D_800E9F7C[playerId].pos, playerId,
                                            &D_800E9F7C[playerId].unk_38, &D_800E9F04[playerId],
-                                           (u8*) &D_800E9F7C[playerId].unk_14);
+                                           (s8*) &D_800E9F7C[playerId].unk_14);
                             } else {
                                 play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0x80, 0x26), &D_800E9F7C[playerId].pos, playerId,
                                            &D_800E9F7C[playerId].unk_38, &D_800E9F04[playerId],
-                                           (u8*) &D_800E9F7C[playerId].unk_14);
+                                           (s8*) &D_800E9F7C[playerId].unk_14);
                             }
                         }
                         break;
@@ -2097,144 +2097,144 @@ void func_800C683C(u8 cameraId) {
             switch (D_800E9E74[cameraId]) {
                 case 3:
                     play_sound(SOUND_ACTION_TYRE_SQUEAL, &D_800E9F7C[cameraId].pos, cameraId, &D_800E9F14[cameraId],
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ACTION_TYRE_SQUEAL;
                     break;
                 case 18:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF8, 0x1D), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF8, 0x1D);
                     break;
                 case 19:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF8, 0x22), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF8, 0x22);
                     break;
                 case 1:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x09), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x09);
                     break;
                 case 2:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF4, 0x0A), &D_800E9F7C[cameraId].pos, cameraId,
-                               &D_800E9F14[cameraId], &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9F14[cameraId], &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF4, 0x0A);
                     break;
                 case 17:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x1E), &D_800E9F7C[cameraId].pos, cameraId,
-                               &D_800E9F14[cameraId], &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9F14[cameraId], &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x1E);
                     break;
                 case 15:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x1F), &D_800E9F7C[cameraId].pos, cameraId,
-                               &D_800E9F14[cameraId], &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9F14[cameraId], &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x1F);
                     break;
                 case 16:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x21), &D_800E9F7C[cameraId].pos, cameraId,
-                               &D_800E9F14[cameraId], &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9F14[cameraId], &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x21);
                     break;
                 case 20:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x27), &D_800E9F7C[cameraId].pos, cameraId,
-                               &D_800E9F14[cameraId], &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9F14[cameraId], &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x27);
                     break;
                 case 25:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x20), &D_800E9F7C[cameraId].pos, cameraId,
-                               &D_800E9F14[cameraId], &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9F14[cameraId], &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x20);
                     break;
                 case 26:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x23), &D_800E9F7C[cameraId].pos, cameraId,
-                               &D_800E9F14[cameraId], &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9F14[cameraId], &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x23);
                     break;
                 case 27:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0x80, 0x46), &D_800E9F7C[cameraId].pos, cameraId,
-                               &D_800E9F14[cameraId], &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9F14[cameraId], &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0x80, 0x46);
                     break;
                 case 28:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x25), &D_800E9F7C[cameraId].pos, cameraId,
-                               &D_800E9F14[cameraId], &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9F14[cameraId], &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x25);
                     break;
                 case 4:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0B), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0B);
                     break;
                 case 5:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0C), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0C);
                     break;
                 case 6:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0D), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0D);
                     break;
                 case 7:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0E), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0E);
                     break;
                 case 8:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0F), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0F);
                     break;
                 case 9:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x10), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x10);
                     break;
                 case 10:
                 case 14:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x11), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x11);
                     break;
                 case 11:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x12), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x12);
                     break;
                 case 12:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x13), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x13);
                     break;
                 case 29:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x48), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x48);
                     break;
                 case 30:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x49), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x49);
                     break;
                 case 31:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x4A), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x4A);
                     break;
                 case 13:
                 case 22:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x29), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x29);
                     break;
                 case 23:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x2A), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x2A);
                     break;
                 case 24:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x2B), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x2B);
                     break;
                 default:
@@ -2751,7 +2751,7 @@ void func_800C847C(u8 playerId) {
                 (D_800EA0EC[playerId] == 0)) {
                 play_sound((gPlayers[playerId].characterId * 0x10) + SOUND_ARG_LOAD(0x29, 0x00, 0x80, 0x05),
                            &D_800E9F7C[playerId].pos, playerId, &D_800EA1D4, &D_800EA1D4,
-                           (u8*) &D_800E9F7C[playerId].unk_14);
+                           (s8*) &D_800E9F7C[playerId].unk_14);
             }
         }
     } else {
@@ -2763,7 +2763,7 @@ void func_800C847C(u8 playerId) {
             if ((IsKoopaTroopaBeach()) && (D_800EA0EC[playerId] == 0)) {
                 play_sound((gPlayers[playerId].characterId * 0x10) + SOUND_ARG_LOAD(0x29, 0x00, 0x80, 0x08),
                            &D_800E9F7C[playerId].pos, playerId, &D_800EA1D4, &D_800EA1D4,
-                           (u8*) &D_800E9F7C[playerId].unk_14);
+                           (s8*) &D_800E9F7C[playerId].unk_14);
             }
         }
     }
@@ -2927,7 +2927,7 @@ void play_sound2(s32 soundBits) {
     if ((soundBits == SOUND_ACTION_REV_ENGINE_2) && (IsDkJungle())) {
         soundBits = SOUND_ARG_LOAD(0x49, 0x00, 0x80, 0x28);
     }
-    play_sound(soundBits, &D_800EA1C8, 4, &D_800EA1D4, &D_800EA1D4, &D_800EA1DC);
+    play_sound(soundBits, &D_800EA1C8, 4, &D_800EA1D4, &D_800EA1D4, (s8*) &D_800EA1DC);
 }
 
 void play_sequence(u16 arg0) {
@@ -2957,7 +2957,7 @@ void func_800C8F80(u8 arg0, u32 soundBits) {
             case 2:
                 D_800EA0EC[arg0] = 1;
             case 0:
-                play_sound(soundBits, &D_800E9F7C[arg0].pos, arg0, &D_800EA1D4, &D_800EA1D4, &D_800EA1DC);
+                play_sound(soundBits, &D_800E9F7C[arg0].pos, arg0, &D_800EA1D4, &D_800EA1D4, (s8*) &D_800EA1DC);
                 break;
         }
     }
@@ -2974,7 +2974,7 @@ void func_800C9060(u8 playerId, u32 soundBits) {
                 D_800EA0EC[playerId] = 1;
             case 0:
                 play_sound(soundBits, &D_800E9F7C[playerId].pos, playerId, &D_800EA1D4, &D_800EA1D4,
-                           (u8*) &D_800E9F7C[playerId].unk_14);
+                           (s8*) &D_800E9F7C[playerId].unk_14);
                 break;
         }
     }
@@ -2993,10 +2993,10 @@ void func_800C90F4(u8 playerId, u32 soundBits) {
                 }
                 if (((gPlayers[playerId].effects & 0x40000000) == 0x40000000) && ((s32) D_800E9F2C[playerId] >= 0x1F)) {
                     play_sound(soundBits, &D_800E9F7C[playerId].pos, playerId, &D_800EA150, &D_800EA1D4,
-                               (u8*) &D_800E9F7C[playerId].unk_14);
+                               (s8*) &D_800E9F7C[playerId].unk_14);
                 } else {
                     play_sound(soundBits, &D_800E9F7C[playerId].pos, playerId, &D_800EA1D4, &D_800EA1D4,
-                               (u8*) &D_800E9F7C[playerId].unk_14);
+                               (s8*) &D_800E9F7C[playerId].unk_14);
                 }
                 break;
             default:
@@ -3022,10 +3022,10 @@ void func_800C92CC(u8 playerId, u32 soundBits) {
                 temp_v0->unk34 = 170.0f;
                 if (((gPlayers[playerId].effects & 0x40000000) == 0x40000000) && ((s32) D_800E9F2C[playerId] >= 0x1F)) {
                     play_sound((gPlayers[playerId].characterId * 0x10) + soundBits, &temp_v0->unk18, var_s0,
-                               &D_800EA150, &D_800EA1D4, &D_800EA06C[playerId].unk0C);
+                               &D_800EA150, &D_800EA1D4, (s8*) &D_800EA06C[playerId].unk0C);
                 } else {
                     play_sound((gPlayers[playerId].characterId * 0x10) + soundBits, &temp_v0->unk18, var_s0,
-                               &temp_v0->unk2C, &D_800EA1D4, &D_800EA06C[playerId].unk0C);
+                               &temp_v0->unk2C, &D_800EA1D4, (s8*) &D_800EA06C[playerId].unk0C);
                 }
             }
         }
@@ -3116,7 +3116,7 @@ void func_800C94A4(u8 playerId) {
                         break;
                 }
                 play_sound(var_a0, &D_800E9F7C[playerId].pos, playerId, &D_800E9F7C[playerId].unk_0C,
-                           &D_800E9F7C[playerId].unk_10, (u8*) &D_800E9F7C[playerId].unk_14);
+                           &D_800E9F7C[playerId].unk_10, (s8*) &D_800E9F7C[playerId].unk_14);
                 break;
             default:
                 break;
@@ -3141,7 +3141,7 @@ void func_800C98B8(Vec3f position, Vec3f velocity, u32 soundBits) {
             temp_v0 = func_800C1C88(0U, position, velocity, D_800EA1C8, (u8) var_s0, soundBits);
             if (temp_v0 != 0) {
                 temp_v0->unk34 = 170.0f;
-                play_sound(soundBits, &temp_v0->unk18, var_s0, &temp_v0->unk2C, &D_800EA1D4, &D_800EA1DC);
+                play_sound(soundBits, &temp_v0->unk18, var_s0, &temp_v0->unk2C, &D_800EA1D4, (s8*) &D_800EA1DC);
             }
         }
     }
@@ -3204,7 +3204,7 @@ void func_800C9A88(u8 playerId) {
                         if (temp_v0_6 != NULL) {
                             temp_v0_6->unk34 = 40.0f;
                             play_sound(soundBits, &temp_v0_6->unk18, var_s0, &temp_v0_6->unk2C,
-                                       &D_800EA06C[playerId].unk00[2], &D_800EA06C[playerId].unk0C);
+                                       &D_800EA06C[playerId].unk00[2], (s8*) &D_800EA06C[playerId].unk0C);
                         }
                     }
                 }
@@ -3230,9 +3230,9 @@ void func_800C9D80(Vec3f position, Vec3f velocity, u32 soundBits) {
             if (temp_v0 != 0) {
                 temp_v0->unk34 = 170.0f;
                 if (soundBits == SOUND_ARG_LOAD(0x51, 0x03, 0x70, 0x0B)) {
-                    play_sound(soundBits, &temp_v0->unk18, var_s0, &D_800EA178, &D_800EA17C, &D_800EA1DC);
+                    play_sound(soundBits, &temp_v0->unk18, var_s0, &D_800EA178, &D_800EA17C, (s8*) &D_800EA1DC);
                 } else {
-                    play_sound(soundBits, &temp_v0->unk18, var_s0, &temp_v0->unk2C, &D_800EA1D4, &D_800EA1DC);
+                    play_sound(soundBits, &temp_v0->unk18, var_s0, &temp_v0->unk2C, &D_800EA1D4, (s8*) &D_800EA1DC);
                 }
             }
         }
@@ -3415,7 +3415,7 @@ void func_800CA49C(u8 arg0) {
 void func_800CA59C(u8 playerId) {
     if ((D_800EA0EC[playerId] == 0) && (D_800EA108 == 0)) {
         play_sound((gPlayers[playerId].characterId * 0x10) + 0x29008001, &D_800E9F7C[playerId].pos, playerId,
-                   &D_800EA1D4, &D_800EA1D4, (u8*) &D_800E9F7C[playerId].unk_14);
+                   &D_800EA1D4, &D_800EA1D4, (s8*) &D_800E9F7C[playerId].unk_14);
         D_800EA164 = 1;
         if ((s32) D_800EA1C0 >= 2) {
             func_800C8F80(playerId, 0x0100FF2C);
@@ -3443,7 +3443,7 @@ void func_800CA730(u8 arg0) {
     if (D_800EA0EC[arg0] == 0) {
         if ((D_800EA108 == 0) && (D_800EA10C[arg0] != 0)) {
             play_sound(gPlayers[arg0].characterId * 0x10 + SOUND_ARG_LOAD(0x29, 0x00, 0x80, 0x08),
-                       &D_800E9F7C[arg0].pos, arg0, &D_800EA1D4, &D_800EA1D4, (u8*) &D_800E9F7C[arg0].unk_14);
+                       &D_800E9F7C[arg0].pos, arg0, &D_800EA1D4, &D_800EA1D4, (s8*) &D_800E9F7C[arg0].unk_14);
             if (D_800EA10C[arg0] != 0) {
                 if ((s32) D_800EA1C0 >= 2) {
                     func_800C9018(arg0, SOUND_ARG_LOAD(0x01, 0x00, 0xFF, 0x2C));
@@ -3490,7 +3490,7 @@ void func_800CA984(u8 arg0) {
             temp_v0_2 =
                 func_800C1C88(arg0, gPlayers[arg0].pos, D_800EA1C8, &gPlayers[arg0].unk_098, (u8) i, SOUND_ITEM_STAR);
             if (temp_v0_2) {
-                play_sound(SOUND_ITEM_STAR, &temp_v0_2->unk18, i, &D_800EA1D4, &D_800EA1D4, &D_800EA1DC);
+                play_sound(SOUND_ITEM_STAR, &temp_v0_2->unk18, i, &D_800EA1D4, &D_800EA1D4, (s8*) &D_800EA1DC);
             }
         }
     }
@@ -3513,7 +3513,7 @@ void func_800CAB4C(u8 arg0) {
             case 0:
                 func_800C36C4(0, 1U, 0x55U, 5);
                 func_800C9060(arg0, 0x1900F013U);
-                play_sound(SOUND_ITEM_THUNDERBOLT, &D_800EA1C8, 0U, &D_800EA1D4, &D_800EA1D4, &D_800EA1DC);
+                play_sound(SOUND_ITEM_THUNDERBOLT, &D_800EA1C8, 0U, &D_800EA1D4, &D_800EA1D4, (s8*) &D_800EA1DC);
                 break;
             default:
                 break;
@@ -3532,10 +3532,10 @@ void func_800CAC08() {
 
 void func_800CAC60(UNUSED s32 arg0) {
     if ((D_800EA108 == 0) && (D_800EA0F0 == 0)) {
-        play_sound(SOUND_ACTION_EXPLOSION_2, &D_800EA1C8, 0U, &D_800EA1D4, &D_800EA1D4, &D_800EA1DC);
+        play_sound(SOUND_ACTION_EXPLOSION_2, &D_800EA1C8, 0U, &D_800EA1D4, &D_800EA1D4, (s8*) &D_800EA1DC);
         if ((D_800EA10C[0] != 1) && (D_800EA10C[1] != 1)) {
             func_800C36C4(0, 1, 0x37U, 5);
-            play_sound(SOUND_ITEM_THUNDERBOLT, &D_800EA1C8, 0U, &D_800EA1D4, &D_800EA1D4, &D_800EA1DC);
+            play_sound(SOUND_ITEM_THUNDERBOLT, &D_800EA1C8, 0U, &D_800EA1D4, &D_800EA1D4, (s8*) &D_800EA1DC);
             D_800EA168 = 1;
         }
     }
@@ -3567,7 +3567,7 @@ void func_800CADD0(u8 playerId, f32 arg1) {
                 }
                 D_800EA110[playerId] = arg1;
                 play_sound(0x1900A209U, &D_800E9F7C[playerId].pos, playerId, &D_800EA1D4, &D_800EA110[playerId],
-                           (u8*) &D_800E9F7C[playerId].unk_14);
+                           (s8*) &D_800E9F7C[playerId].unk_14);
                 break;
             default:
                 break;
@@ -3593,7 +3593,7 @@ void func_800CAEC4(u8 playerId, f32 arg1) {
                 //! @warning this used to be gCurrentCourseId + 0x19007020
                 // This may not be equivallent.
                 play_sound(TrackBrowser_GetTrackIndex() + 0x19007020, &D_800E9F7C[playerId].pos, playerId, &D_800EA1D4,
-                           &D_800EA120[playerId], (u8*) &D_800E9F7C[playerId].unk_14);
+                           &D_800EA120[playerId], (s8*) &D_800E9F7C[playerId].unk_14);
                 break;
             default:
                 break;
diff --git a/src/audio/heap.c b/src/audio/heap.c
index 363a2fb52..269230109 100644
--- a/src/audio/heap.c
+++ b/src/audio/heap.c
@@ -418,7 +418,7 @@ void* alloc_bank_or_seq(struct SoundMultiPool* arg0, s32 arg1, s32 size, s32 arg
                 tp->entries[1].ptr = pool->start + pool->size - size - 0x10;
                 tp->entries[1].id = (s16) id;
                 tp->entries[1].size = (u32) size;
-                if ((u32) tp->entries[1].ptr < (u32) pool->cur) {
+                if ((uintptr_t) tp->entries[1].ptr < (uintptr_t) pool->cur) {
                     table[tp->entries[0].id] = 0;
                     switch (isSound) { /* switch 1; irregular */
                         case 0:        /* switch 1 */
@@ -710,61 +710,3 @@ void* unk_pool1_lookup(s32 poolIdx, s32 id) {
     }
     return NULL;
 }
-
-// SM64 does not appear to have a function
-// comparable to this one, not a clue what
-// this one is doing.
-void func_800BA8B0(s32 poolIdx, s32 id) {
-    ALSeqFile* sp3C;
-    s32 temp_a2;
-    u32 temp_a1;
-    u8* var_a3;
-    UNUSED u8* temp_v0;
-    UNUSED s32 pad;
-
-    switch (poolIdx) { /* irregular */
-        case 0:
-            sp3C = gSeqFileHeader;
-            break;
-        case 1:
-            sp3C = gAlCtlHeader;
-            break;
-        case 2:
-            sp3C = gAlTbl;
-            break;
-    }
-    if (sp3C->seqArray[id].len == 0) {
-        id = (s32) sp3C->seqArray[id].offset;
-    }
-    if (unk_pool1_lookup(poolIdx, id) == NULL) {
-        temp_a2 = gUnkPool1.pool.numAllocatedEntries;
-        temp_a1 = sp3C->seqArray[id].len;
-        var_a3 = sp3C->seqArray[id].offset;
-        if (poolIdx == 1) {
-            var_a3 += 0x10;
-        }
-        gUnkPool1.entries[temp_a2].ptr = soundAlloc(&gUnkPool1.pool, temp_a1);
-        if (gUnkPool1.entries[temp_a2].ptr != NULL) {
-            audio_dma_copy_immediate(var_a3, gUnkPool1.entries[temp_a2].ptr, temp_a1);
-            gUnkPool1.entries[temp_a2].poolIndex = poolIdx;
-            gUnkPool1.entries[temp_a2].id = id;
-            gUnkPool1.entries[temp_a2].size = temp_a1;
-            switch (poolIdx) { /* switch 1; irregular */
-                case 0:        /* switch 1 */
-                    if (gSeqLoadStatus[id] != 5) {
-                        gSeqLoadStatus[id] = 5;
-                    }
-                    break;
-                case 1: /* switch 1 */
-                    gCtlEntries[id].instruments = (struct Instrument**) (gUnkPool1.entries[temp_a2].ptr + 4);
-                    func_800BB584(id);
-                    if (gBankLoadStatus[id] != 5) {
-                        gBankLoadStatus[id] = 5;
-                    }
-                    break;
-                case 2: /* switch 1 */
-                    break;
-            }
-        }
-    }
-}
diff --git a/src/audio/heap.h b/src/audio/heap.h
index ae71257c4..26192292b 100644
--- a/src/audio/heap.h
+++ b/src/audio/heap.h
@@ -113,7 +113,6 @@ void decrease_reverb_gain(void);
 s32 audio_shut_down_and_reset_step(void);
 void audio_reset_session(void);
 void* unk_pool1_lookup(s32 poolIdx, s32 id);
-void func_800BA8B0(s32, s32);
 
 extern s32 D_800EA5D0;
 
diff --git a/src/audio/load.c b/src/audio/load.c
index b3555ed88..6499eda4a 100644
--- a/src/audio/load.c
+++ b/src/audio/load.c
@@ -602,7 +602,7 @@ void* sequence_dma_async(s32 seqId, s32 arg1, struct SequencePlayer* seqPlayer)
     return ptr;
 }
 
-uint8_t* load_sequence_immediate(s32 seqId, s32 arg1) {
+uint8_t* load_sequence_immediate(s32 seqId, UNUSED s32 arg1) {
     return GameEngine_LoadSequence(seqId)->data;
 }
 
@@ -660,7 +660,7 @@ void load_sequence(u32 player, u32 seqId, s32 loadAsync) {
     }
 }
 
-void load_sequence_internal(u32 player, u32 seqId, s32 loadAsync) {
+void load_sequence_internal(u32 player, u32 seqId, UNUSED s32 loadAsync) {
     struct SequencePlayer* seqPlayer = &gSequencePlayers[player];
 
     if (seqId >= gSequenceCount) {
@@ -707,13 +707,13 @@ void audio_init(void) {
     UNUSED s32 pad[2];
     s32 j;
     UNUSED s32 pad2[6];
-    u32 sp60[2];
+    UNUSED u32 sp60[2];
     UNUSED s32 pad1[2];
-    s32 aaa;
-    s32 size;
+    UNUSED s32 aaa;
+    UNUSED s32 size;
     UNUSED u64* ptr64;
     UNUSED s32 one = 1;
-    u8* test;
+    UNUSED u8* test;
 
     gAudioLoadLock = 0;
 
diff --git a/src/audio/mixer.c b/src/audio/mixer.c
index 9b8157ab5..729dc2949 100644
--- a/src/audio/mixer.c
+++ b/src/audio/mixer.c
@@ -7,6 +7,12 @@
 
 #include "mixer.h"
 
+// The Impl signatures mirror the RSP command layout, so unused parameters are expected here;
+// suppress the warning once for the file instead of tagging every signature.
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
 #ifndef __clang__
 #pragma GCC optimize("unroll-loops")
 #endif
@@ -133,15 +139,6 @@ static inline int16_t clamp16(int32_t v) {
     return (int16_t) v;
 }
 
-static inline int32_t clamp32(int64_t v) {
-    if (v < -0x7fffffff - 1) {
-        return -0x7fffffff - 1;
-    } else if (v > 0x7fffffff) {
-        return 0x7fffffff;
-    }
-    return (int32_t) v;
-}
-
 void aClearBufferImpl(uint16_t addr, int nbytes) {
     nbytes = ROUND_UP_16(nbytes);
     memset(BUF_U8(addr), 0, nbytes);
@@ -296,8 +293,7 @@ void aADPCMdecImpl(uint8_t flags, ADPCM_STATE state) {
     __m128i mask = _mm_loadl_epi64((__m128i*) lower_bit);
 
     while (nbytes > 0) {
-        int shift = *in >> 4; // should be in 0..12 or 0..14
-        __m128i shift_vec = _mm_set1_epi16(shift);
+        int shift = *in >> 4;          // should be in 0..12 or 0..14
         int table_index = *in++ & 0xf; // should be in 0..7
         int16_t(*tbl)[8] = rspa.adpcm_table[table_index];
 
@@ -734,7 +730,6 @@ void aMixImpl(int16_t gain, uint16_t in_addr, uint16_t out_addr, uint16_t count)
     int16_t* in = BUF_S16(in_addr);
     int16_t* out = BUF_S16(out_addr);
     int i;
-    int32_t sample;
 
     if (gain == -0x8000) {
         while (nbytes > 0) {
diff --git a/src/audio/port_eu.c b/src/audio/port_eu.c
index dfc9b12d2..1c4f0c11a 100644
--- a/src/audio/port_eu.c
+++ b/src/audio/port_eu.c
@@ -47,7 +47,7 @@ s32 D_800EA4A4 = 0;
 char port_eu_unused_string7[] = "Undefined Port Command %d\n";
 
 void create_next_audio_buffer(s16* samples, u32 num_samples) {
-    static s32 gMaxAbiCmdCnt = 128;
+    UNUSED static s32 gMaxAbiCmdCnt = 128;
     s32 abiCmdCount;
     OSMesg specId;
     OSMesg msg;
@@ -100,7 +100,7 @@ struct SPTask* create_next_audio_frame_task(void) {
     osSendMesg(D_800EA3A8, (OSMesg) gAudioFrameCount, OS_MESG_NOBLOCK);
 #else
     OSMesg audioMesg;
-    audioMesg.ptr = (void*) gAudioFrameCount;
+    audioMesg.ptr = (void*) (uintptr_t) gAudioFrameCount;
     osSendMesg(D_800EA3A8, audioMesg, OS_MESG_NOBLOCK);
 #endif
 
diff --git a/src/code_800029B0.c b/src/code_800029B0.c
index 801d2e32d..51a8a75d5 100644
--- a/src/code_800029B0.c
+++ b/src/code_800029B0.c
@@ -34,7 +34,7 @@
 extern s32 D_802BA038;
 extern s16 D_802BA048;
 s16 gCurrentCourseId = 0;
-uintptr_t gCurrentlyLoadedTrackAddr = NULL;
+uintptr_t gCurrentlyLoadedTrackAddr = 0;
 u16 D_800DC5A8 = 0;
 s32 D_800DC5AC = 0;
 u16 D_800DC5B0 = 1;
@@ -118,7 +118,7 @@ u16 D_8015F700;
 u16 D_8015F702;
 f32 D_8015F704;
 Vec3f D_8015F708;
-UNUSED u32 D_8015F718[3]; // Likely held ptrs to segmented data.
+UNUSED uintptr_t D_8015F718[3]; // Likely held ptrs to segmented data.
 size_t gFreeMemorySize;
 uintptr_t gNextFreeMemoryAddress;
 uintptr_t gHeapEndPtr;
@@ -337,9 +337,9 @@ void clear_nmi_buffer(void) {
  * Also spawns water features
  */
 void credits_spawn_actors(void) {
-    Vec3f position;
-    Vec3f velocity = { 0, 0, 0 };
-    Vec3s rotation = { 0, 0, 0 };
+    UNUSED Vec3f position;
+    UNUSED Vec3f velocity = { 0, 0, 0 };
+    UNUSED Vec3s rotation = { 0, 0, 0 };
 
     bFog = false;
     D_800DC5C8 = 0;
diff --git a/src/code_800029B0.h b/src/code_800029B0.h
index 4ea0028da..35c9bd73a 100644
--- a/src/code_800029B0.h
+++ b/src/code_800029B0.h
@@ -109,7 +109,7 @@ extern u16 D_8015F700;
 extern u16 D_8015F702;
 extern f32 D_8015F704;
 extern Vec3f D_8015F708;
-extern UNUSED u32 D_8015F718[3];
+extern UNUSED uintptr_t D_8015F718[3];
 extern size_t gFreeMemorySize;
 extern uintptr_t gNextFreeMemoryAddress;
 extern uintptr_t gHeapEndPtr;
diff --git a/src/code_80005FD0.c b/src/code_80005FD0.c
index 21e0a25bb..3c6a19ff2 100644
--- a/src/code_80005FD0.c
+++ b/src/code_80005FD0.c
@@ -1200,14 +1200,14 @@ bool func_800088D8(s32 playerId, s16 lapNum, s16 arg2) {
     s32 progress;
     f32 interp;
     s16 var_t1;
-    u16* var_a0_3;
+    UNUSED u16* var_a0_3;
     s16 temp;
     s16 temp2;
     s32 i;
     s32 var_a0;
     s16 var_v0;
     s16 var_a0_4;
-    s32* var_v1;
+    UNUSED s32* var_v1;
     s16 STEMP_V1;
     s16 STEMP_V0;
     s16 rank;
@@ -1553,7 +1553,7 @@ void update_player_path_completion(s32 playerId, Player* player) {
 }
 
 void update_vehicles(void) {
-    s32 i;
+    UNUSED s32 i;
     generate_player_smoke();
     // D_8016337C++;
 
@@ -4180,9 +4180,6 @@ void cpu_behaviour_start(s32 playerId, Player* player) {
     s16 pathPointStart;
     s16 pathPointEnd;
     s32 behaviourType;
-    UNUSED s32 test;
-
-    CPUBehaviour* beh = (CPUBehaviour*) LOAD_ASSET(CM_GetProps()->AIBehaviour);
 
     sCurrentCPUBehaviour = &((CPUBehaviour*) LOAD_ASSET(CM_GetProps()->AIBehaviour))[gCurrentCPUBehaviourId[playerId]];
 
@@ -5905,13 +5902,13 @@ void func_80016C3C(UNUSED s32 playerId, UNUSED f32 arg1, s32 cameraId) {
 
 void func_80017054(Camera* camera, UNUSED Player* player, UNUSED s32 index, s32 cameraId);
 void func_80017054(Camera* camera, UNUSED Player* player, UNUSED s32 index, s32 cameraId) {
-    s32 stackPadding0;
-    s32 stackPadding1;
+    UNUSED s32 stackPadding0;
+    UNUSED s32 stackPadding1;
     f32 spAC;
     f32 spA8;
     f32 spA4;
-    s32 stackPadding2;
-    s32 stackPadding3;
+    UNUSED s32 stackPadding2;
+    UNUSED s32 stackPadding3;
     f32 camX;
     f32 camY;
     f32 camZ;
@@ -5921,8 +5918,8 @@ void func_80017054(Camera* camera, UNUSED Player* player, UNUSED s32 index, s32
     f32 diffX;
     f32 diffY;
     f32 diffZ;
-    s32 stackPadding7;
-    s32 stackPadding8;
+    UNUSED s32 stackPadding7;
+    UNUSED s32 stackPadding8;
     s16 waypoint1;
     s16 waypoint2;
     f32 stackPadding9;
@@ -6632,7 +6629,6 @@ void func_80019C50(s32 arg0) {
 void look_behind_toggle(s32 cameraIdx) {
     static bool lookBehindActive[NUM_CAMERAS] = {0};
     bool pressed = gControllers[cameraIdx].button & L_CBUTTONS; // button held
-    Camera* camera = &cameras[cameraIdx];
     ScreenContext* screenCtx = NULL;
 
     if (CVarGetInteger("gLookBehind", false) == false) {
@@ -7335,7 +7331,7 @@ void cpu_use_item_strategy(s32 playerId) {
 
                 if (player->currentRank < highestHumanRank) {
                     // Code for backwards firing is the same for CPUs and humans
-                    Vec3f somePos2;
+                    UNUSED Vec3f somePos2;
                     Vec3f somePosVel;
                     f32 var_f2;
 
diff --git a/src/code_80057C60.c b/src/code_80057C60.c
index 3974c3fd2..37493e306 100644
--- a/src/code_80057C60.c
+++ b/src/code_80057C60.c
@@ -908,15 +908,16 @@ void render_hud_lap_3p_4p(s32 playerId) {
         if (D_801657F8 && gIsHUDVisible) {
             // draw_hud_2d_texture_32x8(playerHUD[playerId].lapX, playerHUD[playerId].lapY, (u8*)
             // common_texture_hud_lap);
-            draw_hud_2d_texture(playerHUD[playerId].lapX, playerHUD[playerId].lapY, 32, 8, common_texture_hud_lap);
+            draw_hud_2d_texture(playerHUD[playerId].lapX, playerHUD[playerId].lapY, 32, 8,
+                                (u8*) common_texture_hud_lap);
             draw_lap_count(playerHUD[playerId].lapX - 12, playerHUD[playerId].lapY + 4,
                            playerHUD[playerId].alsoLapCount);
         }
         if (gHUDModes == 2) {
             if (playerHUD[playerId].unk_74 && D_80165608) {
                 func_80047910(playerHUD[playerId].unk_6C, playerHUD[playerId].unk_6E, 0, 1.0f,
-                              (u8*) common_tlut_portrait_bomb_kart_and_question_mark, common_texture_portrait_bomb_kart,
-                              D_0D005AE0, 0x20, 0x20, 0x20, 0x20);
+                              (u8*) common_tlut_portrait_bomb_kart_and_question_mark,
+                              (u8*) common_texture_portrait_bomb_kart, D_0D005AE0, 0x20, 0x20, 0x20, 0x20);
             }
         }
     }
@@ -1233,7 +1234,7 @@ void func_8005A070(void) {
         }
     }
     func_8008C204();
-    func_8008C1E0(&D_80165678, (s32) &D_801655F0);
+    func_8008C1E0(&D_80165678, (s32) (uintptr_t) &D_801655F0);
 }
 
 void func_8005A14C(s32 playerId) {
@@ -2478,34 +2479,34 @@ void func_8005D1F4(s32 cameraId) {
 
 // Appears to load GP Mode race staging balloons and kart shadows.
 void func_8005D290(void) {
-    D_8018D420 = gTexture69B03C;
-    D_8018D424 = gTexture69B140;
-    D_8018D478 = gTexture69C1E8;
-    D_8018D480 = gTextureSpeechBubble;
-    D_8018D484 = gTextureMusicNote;
-    D_8018D48C = gTextureSmokePuff;
+    D_8018D420 = (u8*) gTexture69B03C;
+    D_8018D424 = (u8*) gTexture69B140;
+    D_8018D478 = (u8*) gTexture69C1E8;
+    D_8018D480 = (u8*) gTextureSpeechBubble;
+    D_8018D484 = (u8*) gTextureMusicNote;
+    D_8018D48C = (u8*) gTextureSmokePuff;
     D_8018D490 = D_8018D48C;
-    D_8018D4BC = gTextureBalloon1;
-    D_8018D4C0 = gTextureBalloon2;
-    D_8018D49C = gTexture69C9C4;
-    D_8018D4A0 = gTextureBoingExclamation;
-    D_8018D438 = gTexture69CB84;
-    D_8018D43C = gTexture69CCEC;
-    D_8018D440 = gTexture69CEB8;
-    D_8018D444 = gTexture69D148;
-    D_8018D448 = gTexture69D4E0;
-    D_8018D44C = gTexture69D8FC;
-    D_8018D450 = gTexture69DCB4;
-    D_8018D454 = gTexture69DFA0;
-    D_8018D458 = gTexture69E25C;
-    D_8018D45C = gTexture69E518;
-    D_8018D460 = gTexture69E7A8;
-    D_8018D464 = gTexture69EA18;
-    D_8018D468 = gTexture69EC54;
-    D_8018D46C = gTexture69EE38;
-    D_8018D470 = gTexture69EFE0;
-    gTextureLoadedLightningBolt0 = gTextureLightningBolt0;
-    gTextureLoadedLightningBolt1 = gTextureLightningBolt1;
+    D_8018D4BC = (u8*) gTextureBalloon1;
+    D_8018D4C0 = (u8*) gTextureBalloon2;
+    D_8018D49C = (u8*) gTexture69C9C4;
+    D_8018D4A0 = (u8*) gTextureBoingExclamation;
+    D_8018D438 = (u8*) gTexture69CB84;
+    D_8018D43C = (u8*) gTexture69CCEC;
+    D_8018D440 = (u8*) gTexture69CEB8;
+    D_8018D444 = (u8*) gTexture69D148;
+    D_8018D448 = (u8*) gTexture69D4E0;
+    D_8018D44C = (u8*) gTexture69D8FC;
+    D_8018D450 = (u8*) gTexture69DCB4;
+    D_8018D454 = (u8*) gTexture69DFA0;
+    D_8018D458 = (u8*) gTexture69E25C;
+    D_8018D45C = (u8*) gTexture69E518;
+    D_8018D460 = (u8*) gTexture69E7A8;
+    D_8018D464 = (u8*) gTexture69EA18;
+    D_8018D468 = (u8*) gTexture69EC54;
+    D_8018D46C = (u8*) gTexture69EE38;
+    D_8018D470 = (u8*) gTexture69EFE0;
+    gTextureLoadedLightningBolt0 = (u8*) gTextureLightningBolt0;
+    gTextureLoadedLightningBolt1 = (u8*) gTextureLightningBolt1;
 }
 
 void reset_player_particle_pool(Player* player) {
@@ -4919,7 +4920,7 @@ void render_player_ground_particles(Player* player, UNUSED s8 arg1, s16 arg2, s8
                                 G_TX_NOLOD, G_TX_NOLOD);
             func_8004B35C(primRed, primGreen, primBlue, 0x000000FF);
             gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_TEX_EDGE, G_RM_AA_ZB_TEX_EDGE2);
-            gSPVertex(gDisplayListHead++, D_800E8C00, 4, 0);
+            gSPVertex(gDisplayListHead++, (uintptr_t) D_800E8C00, 4, 0);
             gSPDisplayList(gDisplayListHead++, D_0D008DA0);
         }
         gMatrixEffectCount += 1;
@@ -4987,7 +4988,7 @@ UNUSED void func_80066714(Player* player, UNUSED s32 arg1, s16 arg2, s8 arg3) {
                             G_TX_NOLOD, G_TX_NOLOD);
         func_8004B35C(red, green, blue, alpha);
         gDPSetRenderMode(gDisplayListHead++, G_RM_ZB_XLU_SURF, G_RM_ZB_XLU_SURF2);
-        gSPVertex(gDisplayListHead++, D_800E8B00, 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) D_800E8B00, 4, 0);
         gSPDisplayList(gDisplayListHead++, D_0D008DA0);
         gMatrixEffectCount += 1;
     }
@@ -5082,12 +5083,12 @@ void func_80066BAC(Player* player, UNUSED s8 arg1, s16 arg2, s8 arg3) {
             gDPLoadTextureBlock(gDisplayListHead++, gTextureLoadedLightningBolt0, G_IM_FMT_IA, G_IM_SIZ_8b, 32, 64, 0,
                                 G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
                                 G_TX_NOLOD, G_TX_NOLOD);
-            gSPVertex(gDisplayListHead++, &D_800E8900a[0][player->particlePool0[arg2].red], 4, 0);
+            gSPVertex(gDisplayListHead++, (uintptr_t) &D_800E8900a[0][player->particlePool0[arg2].red], 4, 0);
             gSPDisplayList(gDisplayListHead++, common_square_plain_render);
             gDPLoadTextureBlock(gDisplayListHead++, gTextureLoadedLightningBolt1, G_IM_FMT_IA, G_IM_SIZ_8b, 32, 64, 0,
                                 G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
                                 G_TX_NOLOD, G_TX_NOLOD);
-            gSPVertex(gDisplayListHead++, &D_800E8900a[1][player->particlePool0[arg2].red], 4, 0);
+            gSPVertex(gDisplayListHead++, (uintptr_t) &D_800E8900a[1][player->particlePool0[arg2].red], 4, 0);
             gSPDisplayList(gDisplayListHead++, D_0D008DA0);
         } else {
             gSPDisplayList(gDisplayListHead++, D_0D008DB8);
@@ -5096,12 +5097,12 @@ void func_80066BAC(Player* player, UNUSED s8 arg1, s16 arg2, s8 arg3) {
             gDPLoadTextureBlock(gDisplayListHead++, gTextureLoadedLightningBolt1, G_IM_FMT_IA, G_IM_SIZ_8b, 32, 64, 0,
                                 G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
                                 G_TX_NOLOD, G_TX_NOLOD);
-            gSPVertex(gDisplayListHead++, &D_800E8900a[0][player->particlePool0[arg2].red], 4, 0);
+            gSPVertex(gDisplayListHead++, (uintptr_t) &D_800E8900a[0][player->particlePool0[arg2].red], 4, 0);
             gSPDisplayList(gDisplayListHead++, common_square_plain_render);
             gDPLoadTextureBlock(gDisplayListHead++, gTextureLoadedLightningBolt0, G_IM_FMT_IA, G_IM_SIZ_8b, 32, 64, 0,
                                 G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
                                 G_TX_NOLOD, G_TX_NOLOD);
-            gSPVertex(gDisplayListHead++, &D_800E8900a[1][player->particlePool0[arg2].red], 4, 0);
+            gSPVertex(gDisplayListHead++, (uintptr_t) &D_800E8900a[1][player->particlePool0[arg2].red], 4, 0);
             gSPDisplayList(gDisplayListHead++, D_0D008DA0);
         }
         gMatrixEffectCount += 1;
@@ -5203,12 +5204,12 @@ void render_player_onomatopoeia_whrrrr(Player* player, UNUSED s8 arg1, f32 arg2,
         gDPLoadTextureBlock(gDisplayListHead++, gTextureOnomatopoeiaWhrrrr1, G_IM_FMT_CI, G_IM_SIZ_8b, 64, 32, 0,
                             G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK,
                             G_TX_NOLOD, G_TX_NOLOD);
-        gSPVertex(gDisplayListHead++, D_800E8840, 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) D_800E8840, 4, 0);
         gSPDisplayList(gDisplayListHead++, common_square_plain_render);
         gDPLoadTextureBlock(gDisplayListHead++, gTextureOnomatopoeiaWhrrrr2, G_IM_FMT_CI, G_IM_SIZ_8b, 64, 32, 0,
                             G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK,
                             G_TX_NOLOD, G_TX_NOLOD);
-        gSPVertex(gDisplayListHead++, D_800E8800, 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) D_800E8800, 4, 0);
         gSPDisplayList(gDisplayListHead++, D_0D008DA0);
         gMatrixEffectCount += 1;
     }
@@ -5293,12 +5294,12 @@ void render_player_onomatopoeia_crash(Player* player, UNUSED s8 arg1, UNUSED f32
         gDPLoadTextureBlock(gDisplayListHead++, gTextureOnomatopoeiaCrash1, G_IM_FMT_CI, G_IM_SIZ_8b, 64, 32, 0,
                             G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK,
                             G_TX_NOLOD, G_TX_NOLOD);
-        gSPVertex(gDisplayListHead++, D_800E8880, 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) D_800E8880, 4, 0);
         gSPDisplayList(gDisplayListHead++, common_square_plain_render);
         gDPLoadTextureBlock(gDisplayListHead++, gTextureOnomatopoeiaCrash2, G_IM_FMT_CI, G_IM_SIZ_8b, 64, 32, 0,
                             G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK,
                             G_TX_NOLOD, G_TX_NOLOD);
-        gSPVertex(gDisplayListHead++, D_800E88C0, 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) D_800E88C0, 4, 0);
         gSPDisplayList(gDisplayListHead++, D_0D008DA0);
         gMatrixEffectCount += 1;
     }
@@ -5323,12 +5324,12 @@ void func_80068724(Player* player, UNUSED s8 arg1, UNUSED f32 arg2, s8 arg3, s8
         gDPLoadTextureBlock(gDisplayListHead++, gTextureLoadedLightningBolt0, G_IM_FMT_IA, G_IM_SIZ_8b, 32, 64, 0,
                             G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
                             G_TX_NOLOD);
-        gSPVertex(gDisplayListHead++, D_800E8A00, 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) D_800E8A00, 4, 0);
         gSPDisplayList(gDisplayListHead++, common_square_plain_render);
         gDPLoadTextureBlock(gDisplayListHead++, gTextureLoadedLightningBolt1, G_IM_FMT_IA, G_IM_SIZ_8b, 32, 64, 0,
                             G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
                             G_TX_NOLOD);
-        gSPVertex(gDisplayListHead++, D_800E8A40, 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) D_800E8A40, 4, 0);
         gSPDisplayList(gDisplayListHead++, D_0D008DA0);
         gMatrixEffectCount += 1;
     }
@@ -5361,7 +5362,7 @@ void render_player_onomatopoeia_boing(Player* player, UNUSED s8 arg1, UNUSED f32
                             G_TX_NOLOD, G_TX_NOLOD);
         func_8004B35C(0x000000FF, 0x000000FF, 0x000000FF, 0x000000FF);
         gDPSetRenderMode(gDisplayListHead++, G_RM_ZB_CLD_SURF, G_RM_ZB_CLD_SURF2);
-        gSPVertex(gDisplayListHead++, D_800E8B40, 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) D_800E8B40, 4, 0);
         gSPDisplayList(gDisplayListHead++, D_0D008DA0);
         gMatrixEffectCount += 1;
     }
@@ -5385,12 +5386,12 @@ void render_player_onomatopoeia_pomp(Player* player, UNUSED s8 arg1, UNUSED f32
         gDPLoadTextureBlock(gDisplayListHead++, gTextureOnomatopoeiaPoomp1, G_IM_FMT_CI, G_IM_SIZ_8b, 64, 32, 0,
                             G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
                             G_TX_NOLOD);
-        gSPVertex(gDisplayListHead++, D_800E8B80, 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) D_800E8B80, 4, 0);
         gSPDisplayList(gDisplayListHead++, common_square_plain_render);
         gDPLoadTextureBlock(gDisplayListHead++, gTextureOnomatopoeiaPoomp2, G_IM_FMT_CI, G_IM_SIZ_8b, 64, 32, 0,
                             G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
                             G_TX_NOLOD);
-        gSPVertex(gDisplayListHead++, D_800E8BC0, 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) D_800E8BC0, 4, 0);
         gSPDisplayList(gDisplayListHead++, D_0D008DA0);
         gMatrixEffectCount += 1;
     }
@@ -5418,7 +5419,7 @@ void func_800691B8(Player* player, UNUSED s8 arg1, s16 arg2, s8 arg3) {
                             G_TX_NOLOD, G_TX_NOLOD);
         func_8004B35C(0xFF, 0xFF, 0, alpha);
         gDPSetRenderMode(gDisplayListHead++, G_RM_ZB_CLD_SURF, G_RM_ZB_CLD_SURF2);
-        gSPVertex(gDisplayListHead++, D_800E87C0, 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) D_800E87C0, 4, 0);
         gSPDisplayList(gDisplayListHead++, D_0D008DA0);
         gMatrixEffectCount++;
     }
@@ -5489,7 +5490,7 @@ void render_wall_bonk_star_particles(Player* player, UNUSED s8 arg1, s16 arg2, s
                             G_TX_NOLOD, G_TX_NOLOD);
         func_8004B35C(0x000000FF, 0x000000FF, 0, alpha);
         gDPSetRenderMode(gDisplayListHead++, G_RM_ZB_CLD_SURF, G_RM_ZB_CLD_SURF2);
-        gSPVertex(gDisplayListHead++, D_800E87C0, 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) D_800E87C0, 4, 0);
         gSPDisplayList(gDisplayListHead++, D_0D008DA0);
         gMatrixEffectCount += 1;
     }
@@ -5516,7 +5517,7 @@ void func_80069938(Player* player, UNUSED s8 arg1, s16 arg2, s8 arg3) {
                             G_TX_NOLOD, G_TX_NOLOD);
         func_8004B35C(0x000000FF, 0x000000FF, 0, alpha);
         gDPSetRenderMode(gDisplayListHead++, G_RM_ZB_CLD_SURF, G_RM_ZB_CLD_SURF2);
-        gSPVertex(gDisplayListHead++, D_800E87C0, 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) D_800E87C0, 4, 0);
         gSPDisplayList(gDisplayListHead++, D_0D008DA0);
         gMatrixEffectCount += 1;
     }
@@ -5572,7 +5573,7 @@ void func_80069DB8(Player* player, UNUSED s8 arg1, s16 arg2, s8 arg3) {
                             G_TX_NOLOD, G_TX_NOLOD);
         func_8004B35C(0x000000FF, 0x000000FF, 0x000000FF, 0x000000FF);
         gDPSetRenderMode(gDisplayListHead++, G_RM_ZB_CLD_SURF, G_RM_ZB_CLD_SURF2);
-        gSPVertex(gDisplayListHead++, D_800E8740, 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) D_800E8740, 4, 0);
         gSPDisplayList(gDisplayListHead++, D_0D008DA0);
         gMatrixEffectCount += 1;
     }
@@ -5598,7 +5599,7 @@ void func_8006A01C(Player* player, UNUSED s8 arg1, s16 arg2, s8 arg3) {
                             G_TX_NOLOD, G_TX_NOLOD);
         func_8004B35C(0xFF, 0xFF, 0xFF, 0xFF);
         gDPSetRenderMode(gDisplayListHead++, G_RM_ZB_CLD_SURF, G_RM_ZB_CLD_SURF2);
-        gSPVertex(gDisplayListHead++, D_0D008B78, 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) D_0D008B78, 4, 0);
         gSPDisplayList(gDisplayListHead++, D_0D008DA0);
         gMatrixEffectCount++;
     }
@@ -5630,7 +5631,7 @@ void func_8006A280(Player* player, s8 playerId, s16 arg2, s8 screenId) {
                                G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
         func_8004B414(red, green, blue, 0x000000FF);
         gDPSetRenderMode(gDisplayListHead++, G_RM_ZB_CLD_SURF, G_RM_ZB_CLD_SURF2);
-        gSPVertex(gDisplayListHead++, D_800E8780, 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) D_800E8780, 4, 0);
         gSPDisplayList(gDisplayListHead++, D_0D008DA0);
         FrameInterpolation_RecordCloseChild();
         gMatrixEffectCount += 1;
@@ -5742,7 +5743,7 @@ void func_8006A7C0(Player* player, f32 arg1, f32 arg2, s8 arg3, s8 arg4) {
         move_s16_towards(&D_8018D890[arg3][arg4], 0, 0.1f);
         move_s16_towards(&D_8018D860[arg3][arg4], 0, 0.1f);
         if (gPlayerBalloonDepartingTimer[arg3][arg4] >= 0x78) {
-            set_player_balloon_to_gone((s32) player, arg3, arg4);
+            set_player_balloon_to_gone((s32) (uintptr_t) player, arg3, arg4);
         }
     }
 }
@@ -5828,12 +5829,12 @@ void render_battle_balloon(Player* player, s8 arg1, s16 arg2, s8 arg3) {
     gDPLoadTextureBlock(gDisplayListHead++, gTextureBalloon1, G_IM_FMT_CI, G_IM_SIZ_8b, 64, 32, 0,
                         G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
                         G_TX_NOLOD);
-    gSPVertex(gDisplayListHead++, gBalloonVertexPlane1, 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) gBalloonVertexPlane1, 4, 0);
     gSPDisplayList(gDisplayListHead++, common_square_plain_render);
     gDPLoadTextureBlock(gDisplayListHead++, gTextureBalloon2, G_IM_FMT_CI, G_IM_SIZ_8b, 64, 32, 0,
                         G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
                         G_TX_NOLOD);
-    gSPVertex(gDisplayListHead++, gBalloonVertexPlane2, 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) gBalloonVertexPlane2, 4, 0);
     gSPDisplayList(gDisplayListHead++, common_square_plain_render);
     gSPTexture(gDisplayListHead++, 0x0001, 0x0001, 0, G_TX_RENDERTILE, G_OFF);
 
@@ -5955,14 +5956,14 @@ void render_balloon(Vec3f arg0, f32 arg1, s16 arg2, s16 arg3) {
     gDPLoadTextureBlock(gDisplayListHead++, gTextureBalloon1, G_IM_FMT_CI, G_IM_SIZ_8b, 64, 32, 0,
                         G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
                         G_TX_NOLOD);
-    gSPVertex(gDisplayListHead++, gBalloonVertexPlane1, 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) gBalloonVertexPlane1, 4, 0);
     gSPDisplayList(gDisplayListHead++, common_square_plain_render);
     // D_8018D4C0 is correct. But interestingly, IDO seems to set "-0x40" to a different register so the texture still
     // looks fine.
     gDPLoadTextureBlock(gDisplayListHead++, gTextureBalloon2, G_IM_FMT_CI, G_IM_SIZ_8b, 64, 32, 0,
                         G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
                         G_TX_NOLOD);
-    gSPVertex(gDisplayListHead++, gBalloonVertexPlane2, 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) gBalloonVertexPlane2, 4, 0);
     gSPDisplayList(gDisplayListHead++, common_square_plain_render);
     gSPTexture(gDisplayListHead++, 1, 1, 0, G_TX_RENDERTILE, G_OFF);
     gMatrixEffectCount += 1;
@@ -6018,7 +6019,7 @@ void func_8006C294(Vec3f arg0, f32 arg1, s32 rgb, s16 alpha) {
                         G_TX_NOLOD);
     func_8004B35C(red, green, blue, alpha);
     gDPSetRenderMode(gDisplayListHead++, G_RM_ZB_CLD_SURF, G_RM_ZB_CLD_SURF2);
-    gSPVertex(gDisplayListHead++, D_800E87C0, 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) D_800E87C0, 4, 0);
     gSPDisplayList(gDisplayListHead++, D_0D008DA0);
     gMatrixEffectCount += 1;
 }
diff --git a/src/code_8006E9C0.c b/src/code_8006E9C0.c
index 7aedf0cc9..36af78a50 100644
--- a/src/code_8006E9C0.c
+++ b/src/code_8006E9C0.c
@@ -121,7 +121,7 @@ void clear_object_list() {
 /**
  * Dma's mario kart 64 logo and track outline textures.
  */
-u8* dma_misc_textures(u8* devAddr, u8* baseAddress, u32 size, u32 offset) {
+u8* dma_misc_textures(u8* devAddr, u8* baseAddress, UNUSED u32 size, UNUSED u32 offset) {
 #ifdef TARGET_N64
     u8** tempAddress;
     u8* address;
@@ -156,8 +156,8 @@ void init_item_window(s32 objectIndex) {
     temp_v0->textureListIndex = temp_v0->currentItem;
     temp_v0->tlutList = (u8*) common_tlut_item_window_none;
     temp_v0->activeTLUT = (u8*) common_tlut_item_window_none;
-    temp_v0->textureList = common_texture_item_window_none;
-    temp_v0->activeTexture = common_texture_item_window_none;
+    temp_v0->textureList = (u8*) common_texture_item_window_none;
+    temp_v0->activeTexture = (u8*) common_texture_item_window_none;
     temp_v0->unk_04C = -1;
     temp_v0->unk_09C = 0x00A0;  // Screen X position
     temp_v0->unk_09E = -0x0020; // Screen Y position
@@ -174,10 +174,10 @@ void get_minimap_properties() {
 }
 
 void func_8006EF60(void) {
-    s32 i;
+    UNUSED s32 i;
     // `huh`'s and `i`'s types have to differ, for some reason
-    s16 huh;
-    u8* wut = 0;
+    UNUSED s16 huh;
+    UNUSED u8* wut = 0;
 
     // Commented the below code out because it is sketchy.
     // Just-in-case it results in ub or similar.
@@ -542,14 +542,14 @@ void init_cloud_object(s32 objectIndex, s32 arg1, CloudData* arg2) {
     temp_v0->direction_angle[1] = arg2->rotY;
     temp_v0->unk_09E = arg2->posY;
     temp_v0->sizeScaling = (f32) arg2->scalePercent / 100.0;
-    if (GameEngine_ResourceGetTexTypeByName(CM_GetProps()->CloudTexture) != 1) {
+    if (GameEngine_ResourceGetTexTypeByName((const char*) CM_GetProps()->CloudTexture) != 1) {
         temp_v0->activeTexture = ((u8*) LOAD_ASSET_RAW(CM_GetProps()->CloudTexture)) + (arg2->subType * 1024);
         func_80073404(objectIndex, 0x40U, 0x20U, D_0D005FB0);
     } else {
         temp_v0->activeTexture = CM_GetProps()->CloudTexture;
-        if (strcmp(CM_GetProps()->CloudTexture, gTextureExhaust0) == 0 ||
-            strcmp(CM_GetProps()->CloudTexture, gTextureExhaust1) == 0 ||
-            strcmp(CM_GetProps()->CloudTexture, gTextureExhaust2) == 0) {
+        if (strcmp((const char*) CM_GetProps()->CloudTexture, gTextureExhaust0) == 0 ||
+            strcmp((const char*) CM_GetProps()->CloudTexture, gTextureExhaust1) == 0 ||
+            strcmp((const char*) CM_GetProps()->CloudTexture, gTextureExhaust2) == 0) {
             func_80073404(objectIndex, 0x40U, 0x20U, cloudvtx2[arg2->subType]);
         } else {
             func_80073404(objectIndex, 0x40U, 0x20U, cloudvtx[arg2->subType]);
@@ -596,7 +596,7 @@ void init_star_object(s32 objectIndex, s32 arg1, StarData* arg2) {
     temp_v0->direction_angle[1] = arg2->rotY;
     temp_v0->unk_09E = arg2->posY;                           // screen Y position
     temp_v0->sizeScaling = (f32) arg2->scalePercent / 100.0; // some type of scaling on the texture
-    temp_v0->activeTexture = D_0D0293D8;
+    temp_v0->activeTexture = (u8*) D_0D0293D8;
     func_80073404(objectIndex, 0x10U, 0x10U, common_vtx_rectangle);
 }
 
@@ -615,8 +615,8 @@ void init_stars(StarData* starList) {
 }
 
 void func_8007055C(ScreenContext* screen) {
-    s32 var_s0;
-    s32 var_s4;
+    UNUSED s32 var_s0;
+    UNUSED s32 var_s4;
 
     InitSkyActors(screen);
     func_8008C23C();
@@ -637,8 +637,8 @@ void func_80070714(void) {
 }
 
 void init_course_object(void) {
-    s32 objectId;
-    s32 i;
+    UNUSED s32 objectId;
+    UNUSED s32 i;
 
     CM_InitTrackObjects();
 }
diff --git a/src/code_8006E9C0.h b/src/code_8006E9C0.h
index 6859f71ac..f620d4c08 100644
--- a/src/code_8006E9C0.h
+++ b/src/code_8006E9C0.h
@@ -34,6 +34,6 @@ void init_hud_two_player_horizontal(void);
 extern Vtx cloudvtx[4][4];
 extern Vtx cloudvtx2[3][4];
 extern s16 D_800E5520[];
-extern u8* gCourseOutlineTextures[0x14]; // 800e54d0
+extern const char* gCourseOutlineTextures[0x14]; // 800e54d0
 
 #endif
diff --git a/src/code_80086E70.c b/src/code_80086E70.c
index 2e6ecd04d..b927d5f17 100644
--- a/src/code_80086E70.c
+++ b/src/code_80086E70.c
@@ -1311,7 +1311,7 @@ void func_8008A1D0(s32 objectIndex, s32 cameraId, s32 arg2, s32 arg3) {
     clear_object_flag(objectIndex, 0x00100000 | VISIBLE);
     temp_v0 = get_horizontal_distance_to_camera(objectIndex, camera);
     if (CVarGetInteger("gNoCulling", 0) == 1) {
-        temp_v0 = MIN(temp_v0, arg3 * arg3);
+        temp_v0 = MIN(temp_v0, (u32) (arg3 * arg3));
     }
     if (temp_v0 < 0x2711U) {
         var_a2 = 0x5555;
@@ -1357,9 +1357,9 @@ s32 func_8008A364(s32 objectIndex, s32 cameraId, u16 arg2, s32 arg3) {
     clear_object_flag(objectIndex, 0x00020000 | VISIBLE);
     dist = get_horizontal_distance_to_camera(objectIndex, camera);
     if (CVarGetInteger("gNoCulling", 0) == 1) {
-        dist = MIN(dist, (arg3 * arg3) - 1);
+        dist = MIN(dist, (u32) ((arg3 * arg3) - 1));
     }
-    if (dist < (arg3 * arg3)) {
+    if (dist < (u32) (arg3 * arg3)) {
         set_object_flag(objectIndex, 0x00020000);
         if (dist < 0x2711U) {
             var_a2 = 0x5555;
diff --git a/src/code_80091440.c b/src/code_80091440.c
index 0325c03ec..35c936351 100644
--- a/src/code_80091440.c
+++ b/src/code_80091440.c
@@ -17,7 +17,7 @@ UNUSED void func_800914E0(void) {
     UNUSED Vec3f sp64 = { 0.0f, -20.0f, 150.0f };
     UNUSED Vec3f sp58 = { 0.0f, -6.0f, 4.0f };
     Camera* camera = &cameras[0];
-    struct ActorSpawnData* sp48 = D_8015F718[0];
+    struct ActorSpawnData* sp48 = (struct ActorSpawnData*) D_8015F718[0];
     struct ActorSpawnData* tempData;
 
     s16 temp3 = (s16) D_80152308;
diff --git a/src/code_800AF9B0.c b/src/code_800AF9B0.c
index bd276059e..7a2c0cb67 100644
--- a/src/code_800AF9B0.c
+++ b/src/code_800AF9B0.c
@@ -83,7 +83,7 @@ void func_800AF9E4(Vtx* arg0, s32 arg1, s32 arg2, s32 arg3, s16 arg4, s16 arg5,
 
     gDPSetPrimColor(gDisplayListHead++, 0, 0, r, g, b, 255);
     gDPPipeSync(gDisplayListHead++);
-    gSPVertex(gDisplayListHead++, VIRTUAL_TO_PHYSICAL2(arg0), 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) VIRTUAL_TO_PHYSICAL2(arg0), 4, 0);
     gSP1Triangle(gDisplayListHead++, 1, 2, 0, 0);
     gSP1Triangle(gDisplayListHead++, 3, 2, 1, 0);
 }
diff --git a/src/data/some_data.c b/src/data/some_data.c
index 5e25181ce..2677edf3d 100644
--- a/src/data/some_data.c
+++ b/src/data/some_data.c
@@ -193,7 +193,7 @@ Vtx gBalloonVertexPlane2[] = {
 //     #include "assets/code/some_data/gTLUTOnomatopoeia.rgba16.inc.c"
 // };
 
-u8* gCourseOutlineTextures[] = {
+const char* gCourseOutlineTextures[] = {
     minimap_mario_raceway, minimap_choco_mountain,  minimap_bowsers_castle,     minimap_banshee_boardwalk,
     minimap_yoshi_valley,  minimap_frappe_snowland, minimap_koopa_troopa_beach, minimap_royal_raceway,
     minimap_luigi_raceway, minimap_moo_moo_farm,    minimap_toads_turnpike,     minimap_kalimari_desert,
diff --git a/src/data/some_data.h b/src/data/some_data.h
index f746cc836..f3d2b7458 100644
--- a/src/data/some_data.h
+++ b/src/data/some_data.h
@@ -23,7 +23,7 @@ extern Vtx D_800E51D0[];
 extern Vtx D_800E5210[];
 extern Vtx gBalloonVertexPlane1[];
 extern Vtx gBalloonVertexPlane2[];
-extern u8* gCourseOutlineTextures[];
+extern const char* gCourseOutlineTextures[];
 extern s16 D_800E5520[];
 extern s16 minimapDimensions[];
 extern u16 D_800E55A0[];
diff --git a/src/effects.c b/src/effects.c
index 69f5ca1b0..8b4bd464d 100644
--- a/src/effects.c
+++ b/src/effects.c
@@ -1599,7 +1599,7 @@ void func_8008FEDC(Player* player, UNUSED s8 arg1) {
 void CM_Waypoints(Player*, s8);
 
 void func_8008FF08(Player* player, s8 playerId) {
-    s16 waypoint;
+    UNUSED s16 waypoint;
 
     CM_Waypoints(player, playerId);
 }
diff --git a/src/ending/code_80280000.c b/src/ending/code_80280000.c
index 0ae8b934e..f6fd8690f 100644
--- a/src/ending/code_80280000.c
+++ b/src/ending/code_80280000.c
@@ -53,7 +53,7 @@ void func_80280038(Camera* camera) {
     gMatrixEffectCount = 0;
     gMatrixHudCount = 0;
     init_rdp();
-    race_begin_viewport(gScreenOneCtx, 0);
+    race_begin_viewport(gScreenOneCtx);
     if ((CVarGetInteger("gDrawSky", true) == true)) {
         CM_RaceDrawSky(gScreenOneCtx, 0);
         func_80093A30(0); // Fill box for thunderbolt?
diff --git a/src/ending/code_80281780.c b/src/ending/code_80281780.c
index f361fa99c..b0c6ecaa2 100644
--- a/src/ending/code_80281780.c
+++ b/src/ending/code_80281780.c
@@ -28,7 +28,9 @@
 // For init podium ceremony
 #include "ceremony_and_credits.h"
 
-#define bcopy memcpy
+// bcopy takes (src, dst); memcpy takes (dst, src), do not mix it up.
+#undef bcopy
+#define bcopy(src, dst, n) memmove(dst, src, n)
 
 u8 defaultCharacterIds[] = { 1, 2, 3, 4, 5, 6, 7, 0 };
 
@@ -94,8 +96,6 @@ void func_802818BC(void) {
 }
 
 void setup_podium_ceremony(void) {
-    Vec3f spawn = {0, 0, 0};
-
     clear_D_802874D8_actors();
 
     gCurrentCourseId = TRACK_ROYAL_RACEWAY;
diff --git a/src/ending/code_80281C40.c b/src/ending/code_80281C40.c
index 08470accf..203e4f113 100644
--- a/src/ending/code_80281C40.c
+++ b/src/ending/code_80281C40.c
@@ -61,7 +61,7 @@ void func_80281D00(void) {
     Mat4 matrix;
     UNUSED s32 pad2[3];
 
-    race_begin_viewport(gScreenOneCtx, 0);
+    race_begin_viewport(gScreenOneCtx);
     if ((CVarGetInteger("gDrawSky", true) == true)) {
         CM_RaceDrawSky(gScreenOneCtx, 0);
         func_80093A30(0); // Fill box for thunderbolt?
diff --git a/src/kart_dma.c b/src/kart_dma.c
index b6cd7df75..18076d006 100644
--- a/src/kart_dma.c
+++ b/src/kart_dma.c
@@ -584,8 +584,8 @@ u8** gKartTextureTumbles[] = {
 };
 
 u8* gKartPalettes[] = {
-    gKartMarioPalette, gKartLuigiPalette, gKartYoshiPalette, gKartToadPalette,
-    gKartDKPalette,    gKartWarioPalette, gKartPeachPalette, gKartBowserPalette,
+    (u8*) gKartMarioPalette, (u8*) gKartLuigiPalette, (u8*) gKartYoshiPalette, (u8*) gKartToadPalette,
+    (u8*) gKartDKPalette,    (u8*) gKartWarioPalette, (u8*) gKartPeachPalette, (u8*) gKartBowserPalette,
 };
 
 /**
@@ -610,25 +610,25 @@ void load_kart_texture(Player* player, s8 playerId, s8 screenId, s8 screenId2, s
         if (player->animFrameSelector[screenId] != 0) {
             osInvalDCache(&gEncodedKartTexture[index][screenId2][playerId], D_800DDEB0[player->characterId]);
             gEncodedKartTexture[index][screenId2][playerId].unk_00 =
-                gKartTextureTable1[player->characterId][player->animGroupSelector[screenId]]
-                                  [player->animFrameSelector[screenId]][wheelid];
+                (const char*) gKartTextureTable1[player->characterId][player->animGroupSelector[screenId]]
+                                                [player->animFrameSelector[screenId]][wheelid];
         } else {
             osInvalDCache(&gEncodedKartTexture[index][screenId2][playerId], D_800DDEB0[player->characterId]);
             gEncodedKartTexture[index][screenId2][playerId].unk_00 =
-                gKartTextureTable0[player->characterId][player->animGroupSelector[screenId]]
-                                  [player->animFrameSelector[screenId]][wheelid];
+                (const char*) gKartTextureTable0[player->characterId][player->animGroupSelector[screenId]]
+                                                [player->animFrameSelector[screenId]][wheelid];
         }
     } else if (((temp & 0x400) == 0x400) || ((temp & 0x01000000) == 0x01000000) ||
                ((temp & 0x02000000) == 0x02000000) || ((temp & 0x10000) == 0x10000)) {
         osInvalDCache(&gEncodedKartTexture[index][screenId2][playerId], 0x780U);
 // player->unk_0A8 >> 8 converts an 8.8 fixed-point animation frame to a whole number.
         gEncodedKartTexture[index][screenId2][playerId].unk_00 =
-            gKartTextureTumbles[player->characterId][player->unk_0A8 >> 8];
+            (const char*) gKartTextureTumbles[player->characterId][player->unk_0A8 >> 8];
     } else {
         osInvalDCache(&gEncodedKartTexture[index][screenId2][playerId], D_800DDEB0[player->characterId]);
         gEncodedKartTexture[index][screenId2][playerId].unk_00 =
-            gKartTextureTable0[player->characterId][player->animGroupSelector[screenId]]
-                              [player->animFrameSelector[screenId]][wheelid];
+            (const char*) gKartTextureTable0[player->characterId][player->animGroupSelector[screenId]]
+                                            [player->animFrameSelector[screenId]][wheelid];
     }
 }
 
@@ -642,23 +642,25 @@ void load_kart_texture_non_blocking(Player* player, s8 arg1, s8 arg2, s8 arg3, s
         if (player->animFrameSelector[arg2] != 0) {
             osInvalDCache(&gEncodedKartTexture[arg4][arg3][arg1], D_800DDEB0[player->characterId]);
             gEncodedKartTexture[arg4][arg3][arg1].unk_00 =
-                gKartTextureTable1[player->characterId][player->animGroupSelector[arg2]]
-                                  [player->animFrameSelector[arg2]][wheelid];
+                (const char*) gKartTextureTable1[player->characterId][player->animGroupSelector[arg2]]
+                                                [player->animFrameSelector[arg2]][wheelid];
         } else {
             osInvalDCache(&gEncodedKartTexture[arg4][arg3][arg1], D_800DDEB0[player->characterId]);
             gEncodedKartTexture[arg4][arg3][arg1].unk_00 =
-                gKartTextureTable0[player->characterId][player->animGroupSelector[arg2]]
-                                  [player->animFrameSelector[arg2]][wheelid];
+                (const char*) gKartTextureTable0[player->characterId][player->animGroupSelector[arg2]]
+                                                [player->animFrameSelector[arg2]][wheelid];
         }
     } else if (((temp & 0x400) == 0x400) || ((temp & 0x01000000) == 0x01000000) ||
                ((temp & 0x02000000) == 0x02000000) || ((temp & 0x10000) == 0x10000)) {
         osInvalDCache(&gEncodedKartTexture[arg4][arg3][arg1], 0x780);
 // player->unk_0A8 >> 8 converts an 8.8 fixed-point animation frame to a whole number.
-        gEncodedKartTexture[arg4][arg3][arg1].unk_00 = gKartTextureTumbles[player->characterId][player->unk_0A8 >> 8];
+        gEncodedKartTexture[arg4][arg3][arg1].unk_00 =
+            (const char*) gKartTextureTumbles[player->characterId][player->unk_0A8 >> 8];
     } else {
         osInvalDCache(&gEncodedKartTexture[arg4][arg3][arg1], D_800DDEB0[player->characterId]);
         gEncodedKartTexture[arg4][arg3][arg1].unk_00 =
-            gKartTextureTable0[player->characterId][player->animGroupSelector[arg2]][player->animFrameSelector[arg2]][wheelid];
+            (const char*) gKartTextureTable0[player->characterId][player->animGroupSelector[arg2]]
+                                            [player->animFrameSelector[arg2]][wheelid];
     }
 }
 
@@ -672,21 +674,21 @@ void load_kart_palette(Player* player, s8 playerId, s8 screenId, s8 buffer) {
         case SCREEN_MODE_2P_SPLITSCREEN_VERTICAL:
             osInvalDCache(temp_s0, sizeof(struct_D_802F1F80));
 
-            size = ResourceGetTexSizeByName(gKartPalettes[player->characterId]);
+            size = ResourceGetTexSizeByName((const char*) gKartPalettes[player->characterId]);
             asset = (u8*) LOAD_ASSET(gKartPalettes[player->characterId]);
             memcpy(&temp_s0->kart_palette[0], asset, size);
             break;
         case SCREEN_MODE_3P_4P_SPLITSCREEN: // Code identical to above
             osInvalDCache(temp_s0, sizeof(struct_D_802F1F80));
 
-            size = ResourceGetTexSizeByName(gKartPalettes[player->characterId]);
+            size = ResourceGetTexSizeByName((const char*) gKartPalettes[player->characterId]);
             asset = (u8*) LOAD_ASSET(gKartPalettes[player->characterId]);
             memcpy(&temp_s0->kart_palette[0], asset, size);
             break;
     }
 }
 
-void load_player_data(UNUSED Player* player, s32 arg1, void* vAddr, u16 size) {
+void load_player_data(UNUSED Player* player, UNUSED s32 arg1, void* vAddr, u16 size) {
     osInvalDCache(vAddr, size);
 
 #ifdef TARGET_N64
@@ -713,7 +715,7 @@ void load_wheel_palette_non_blocking(UNUSED Player* player, const char* texture,
                  (uintptr_t) &_kart_texturesSegmentRomStart[SEGMENT_OFFSET(arg1)], vAddr, size, &gDmaMesgQueue);
 #else
     u16* tex = (u16*) LOAD_ASSET(texture);
-    size_t textureSize = ResourceGetTexSizeByName(texture);
+    // size_t textureSize = ResourceGetTexSizeByName(texture);
     memcpy(vAddr, tex, size);
 #endif
 }
diff --git a/src/main.c b/src/main.c
index d942bdc28..1bdbee6e1 100644
--- a/src/main.c
+++ b/src/main.c
@@ -390,7 +390,7 @@ void update_controller(s32 index) {
 }
 
 void read_controllers(void) {
-    OSMesg msg;
+    // OSMesg msg;
 
     osContStartReadData(&gSIEventMesgQueue);
     // osRecvMesg(&gSIEventMesgQueue, &msg, OS_MESG_BLOCK);
@@ -419,7 +419,7 @@ void read_controllers(void) {
 }
 
 void func_80000BEC(void) {
-    gPhysicalZBuffer = VIRTUAL_TO_PHYSICAL(&gZBuffer);
+    gPhysicalZBuffer = (uintptr_t) VIRTUAL_TO_PHYSICAL(&gZBuffer);
 }
 
 void dispatch_audio_sptask(struct SPTask* spTask) {
@@ -727,7 +727,7 @@ void race_logic_loop(void) {
     }
 
     if (gIsGamePaused == false) {
-        for (size_t i = 0; i < gTickLogic; i++) {
+        for (size_t i = 0; i < (size_t) gTickLogic; i++) {
             process_game_tick();
         }
         if (Editor_IsPaused() == false) {
@@ -1093,19 +1093,19 @@ void update_gamestate(void) {
     switch (gGamestate) {
         case START_MENU_FROM_QUIT:
             func_80002658();
-            gCurrentlyLoadedTrackAddr = NULL;
+            gCurrentlyLoadedTrackAddr = 0;
             break;
         case MAIN_MENU_FROM_QUIT:
             func_800025D4();
-            gCurrentlyLoadedTrackAddr = NULL;
+            gCurrentlyLoadedTrackAddr = 0;
             break;
         case PLAYER_SELECT_MENU_FROM_QUIT:
             func_80002600();
-            gCurrentlyLoadedTrackAddr = NULL;
+            gCurrentlyLoadedTrackAddr = 0;
             break;
         case COURSE_SELECT_MENU_FROM_QUIT:
             func_8000262C();
-            gCurrentlyLoadedTrackAddr = NULL;
+            gCurrentlyLoadedTrackAddr = 0;
             break;
         case RACING:
             /**
@@ -1117,12 +1117,12 @@ void update_gamestate(void) {
             TrackBrowser_ResetSelectedTrack(); // Same function as gCurrentlyLoadedTrackAddr
             break;
         case ENDING:
-            gCurrentlyLoadedTrackAddr = NULL;
+            gCurrentlyLoadedTrackAddr = 0;
             init_segment_ending_sequences();
             setup_podium_ceremony();
             break;
         case CREDITS_SEQUENCE:
-            gCurrentlyLoadedTrackAddr = NULL;
+            gCurrentlyLoadedTrackAddr = 0;
             // init_segment_racing();
             init_segment_ending_sequences();
             load_credits();
diff --git a/src/math_util_2.c b/src/math_util_2.c
index df635ba85..86fabc012 100644
--- a/src/math_util_2.c
+++ b/src/math_util_2.c
@@ -17,8 +17,6 @@
 #include "engine/Matrix.h"
 #include "port/interpolation/FrameInterpolation.h"
 
-#pragma intrinsic(sqrtf)
-
 Mat4 sInterpolationMatrixStack[0x1000];
 Mat4* gInterpolationMatrix = &sInterpolationMatrixStack[0];
 
@@ -718,7 +716,7 @@ void func_80042330_unchanged(s32 x, s32 y, u16 angle, f32 scale) {
 }
 
 // Allows a different way of lining up the portraits at the end of race sequence
-void func_80042330_portrait(s32 x, s32 y, u16 angle, f32 scale, s16 lapCount) {
+void func_80042330_portrait(s32 x, s32 y, u16 angle, f32 scale, UNUSED s16 lapCount) {
     Mat4 matrix;
     // printf("panel %d %d %d\n", x, (s32)OTRGetDimensionFromLeftEdge(x), (s32)OTRGetDimensionFromLeftEdge(0));
 
diff --git a/src/menu_items.c b/src/menu_items.c
index ccf5704cd..dd1c3f177 100644
--- a/src/menu_items.c
+++ b/src/menu_items.c
@@ -1601,7 +1601,7 @@ void func_80092290(s32 arg0, s32* arg1, s32* arg2) {
     s32 temp_t7;
     s32 temp_t8_2;
     s32 temp_t9;
-    s32 temp_t0;
+    UNUSED s32 temp_t0;
     s32 a, b, c, d;
     Vtx* vtx;
 
@@ -2530,7 +2530,7 @@ void func_800942D0(void) {
     }
 }
 
-void func_80094660(struct GfxPool* arg0, UNUSED s32 arg1) {
+void func_80094660(UNUSED struct GfxPool* arg0, UNUSED s32 arg1) {
     u16 perspNorm;
 
     gDPSetTexturePersp(gDisplayListHead++, G_TP_PERSP);
@@ -2566,7 +2566,7 @@ void render_checkered_flag(struct GfxPool* arg0, UNUSED s32 arg1) {
     gSPDisplayList(gDisplayListHead++, D_02007650);
 }
 
-void func_80094A64(struct GfxPool* pool) {
+void func_80094A64(UNUSED struct GfxPool* pool) {
     ClearObjectsMatrixPool();
     gMatrixHudCount = 0;
     gMatrixEffectCount = 0;
@@ -2901,8 +2901,8 @@ Gfx* func_800959F8(Gfx* displayListHead, Vtx* arg1) {
     }
 #ifdef AVOID_UB
     arg1 = LOAD_ASSET(arg1);
-    gSPVertex(displayListHead++, arg1, 2, 0);
-    gSPVertex(displayListHead++, &arg1[(index + 1) * 2], 2, 2);
+    gSPVertex(displayListHead++, (uintptr_t) arg1, 2, 0);
+    gSPVertex(displayListHead++, (uintptr_t) &arg1[(index + 1) * 2], 2, 2);
     gSPDisplayList(displayListHead++, common_rectangle_display);
 #else
     if (arg1 == D_02007BB8) {
@@ -3078,7 +3078,7 @@ Gfx* func_80095BD0_wide_right(Gfx* displayListHead, u8* arg1, f32 arg2, f32 arg3
 // Player select menu character border
 Gfx* func_80095E10(Gfx* displayListHead, s8 textureFormat, s32 texScaleS, s32 texScaleT, s32 srcX, s32 srcY,
                    s32 srcWidth, s32 srcHeight, s32 screenX, s32 screenY, u8* textureData, u32 texWidth,
-                   u32 texHeight) {
+                   UNUSED u32 texHeight) {
     gDPLoadTextureTile(displayListHead++, textureData, textureFormat, G_IM_SIZ_16b, texWidth, texHeight, srcX, srcY,
                        srcX + srcWidth - 1, srcY + srcHeight - 1, 0, G_TX_NOMIRROR | G_TX_WRAP,
                        G_TX_NOMIRROR | G_TX_WRAP, 0, 0, G_TX_NOLOD, G_TX_NOLOD);
@@ -3090,8 +3090,8 @@ Gfx* func_80095E10(Gfx* displayListHead, s8 textureFormat, s32 texScaleS, s32 te
 // Cup select menu, an alt version to fix cup and trophy
 Gfx* func_80095E10_alt(Gfx* displayListHead, s8 textureFormat, s32 texScaleS, s32 texScaleT, s32 srcX, s32 srcY,
                        s32 srcWidth, s32 srcHeight, s32 screenX, s32 screenY, u8* textureData, u32 texWidth,
-                       u32 texHeight) {
-    if (GameEngine_ResourceGetTexTypeByName(textureData) != 1) {
+                       UNUSED u32 texHeight) {
+    if (GameEngine_ResourceGetTexTypeByName((const char*) textureData) != 1) {
         gDPLoadTextureTile(displayListHead++, textureData, textureFormat, G_IM_SIZ_16b, texWidth, texHeight, srcX, srcY,
                            srcX + srcWidth - 1, srcY + srcHeight + 2, 0, G_TX_NOMIRROR | G_TX_WRAP,
                            G_TX_NOMIRROR | G_TX_WRAP, 0, 0, G_TX_NOLOD, G_TX_NOLOD);
@@ -3109,8 +3109,8 @@ Gfx* func_80095E10_alt(Gfx* displayListHead, s8 textureFormat, s32 texScaleS, s3
 }
 
 Gfx* func_800963F0(Gfx* displayListHead, s8 textureFormat, s32 texScaleS, s32 texScaleT, f32 scaleX, f32 scaleY,
-                   s32 srcX, s32 srcY, s32 srcHeight, s32 srcWidth, s32 screenX, s32 screenY, u8* textureData,
-                   u32 texWidth, u32 texHeight) {
+                   s32 srcX, s32 srcY, UNUSED s32 srcHeight, UNUSED s32 srcWidth, s32 screenX, s32 screenY,
+                   u8* textureData, u32 texWidth, u32 texHeight) {
     gDPLoadTextureTile(displayListHead++, textureData, textureFormat, G_IM_SIZ_16b, texWidth, texHeight, srcX, srcY,
                        srcX + texWidth - 1, srcY + texHeight - 1, 0, G_TX_NOMIRROR | G_TX_WRAP,
                        G_TX_NOMIRROR | G_TX_WRAP, 0, 0, G_TX_NOLOD, G_TX_NOLOD);
@@ -3170,8 +3170,8 @@ Gfx* func_80096CD8(Gfx* displayListHead, s32 xPos, s32 yPos, u32 width, u32 heig
     // Clamp positions to valid range
     s32 xStart = CLAMP(xPos << 2, -32768, 32767); // Ensure no overflow in fixed-point
     s32 yStart = CLAMP(yPos << 2, -32768, 32767);
-    s32 xEnd = CLAMP((xPos + width) << 2, -32768, 32767);
-    s32 yEnd = CLAMP((yPos + height) << 2, -32768, 32767);
+    s32 xEnd = CLAMP((s32) ((xPos + width) << 2), -32768, 32767);
+    s32 yEnd = CLAMP((s32) ((yPos + height) << 2), -32768, 32767);
 
     // Updated call with clamped values
     gSPWideTextureRectangle(displayListHead++, xStart, yStart, xEnd, yEnd, G_TX_RENDERTILE, 0, 0, 1024, 1024);
@@ -3179,9 +3179,8 @@ Gfx* func_80096CD8(Gfx* displayListHead, s32 xPos, s32 yPos, u32 width, u32 heig
     return displayListHead;
 }
 
-#ifdef NON_MATCHING
 Gfx* func_80097274(Gfx* displayListHead, s8 arg1, s32 arg2, s32 arg3, s32 arg4, s32 arg5, s32 arg6, s32 arg7, s32 arg8,
-                   s32 arg9, u16* argA, u32 argB, u32 argC, s32 argD) {
+                   s32 arg9, UNUSED u16* argA, u32 argB, u32 argC, UNUSED s32 argD) {
     u32 var_a1_2 = arg4;
     u32 var_s3 = arg5;
     s32 sp7C;
@@ -3192,50 +3191,41 @@ Gfx* func_80097274(Gfx* displayListHead, s8 arg1, s32 arg2, s32 arg3, s32 arg4,
     s32 sp68 = 0;
     s32 sp64 = 0;
     s32 var_v0_2;
-
     gDPPipeSync(displayListHead++);
     gDPSetCycleType(displayListHead++, G_CYC_2CYCLE);
     gDPSetTextureLOD(displayListHead++, G_TL_TILE);
     gDPSetPrimColor(displayListHead++, 0, 0, 0, 0, 0, gGlobalTimer % 256);
     gDPSetCombineLERP(displayListHead++, TEXEL1, TEXEL0, PRIMITIVE_ALPHA, TEXEL0, TEXEL1, TEXEL0, PRIMITIVE, TEXEL0, 0,
                       0, 0, COMBINED, 0, 0, 0, COMBINED);
-
-    while (var_t0 < (s32) argB) {
+    while ((u32) var_t0 < argB) {
         var_t0 *= 2;
     }
-
     temp_lo = 0x400 / var_t0;
-
-    while ((temp_lo / 2) > (s32) argC) {
+    while ((u32) (temp_lo / 2) > argC) {
         temp_lo /= 2;
     }
-
     var_v0_2 = var_t0;
     while (var_v0_2 > 1) {
         var_v0_2 /= 2;
         sp68 += 1;
     }
     var_v0_2 = temp_lo;
-
     while (var_v0_2 > 1) {
         var_v0_2 /= 2;
         sp64 += 1;
     }
-
     if (arg8 < 0) {
         arg4 -= arg8;
         arg8 = 0;
     } else if (((arg6 - arg4) + arg8) > SCREEN_WIDTH) {
         arg6 = (arg4 - arg8) + SCREEN_WIDTH;
     }
-
     if (arg9 < 0) {
         arg5 -= arg9;
         arg9 = 0;
     } else if (((arg7 - arg5) + arg9) > SCREEN_HEIGHT) {
         arg7 = (arg5 - arg9) + SCREEN_HEIGHT;
     }
-
     if (arg6 < arg4) {
         return displayListHead;
     }
@@ -3244,8 +3234,7 @@ Gfx* func_80097274(Gfx* displayListHead, s8 arg1, s32 arg2, s32 arg3, s32 arg4,
     }
     sp7C = arg8;
     for (var_s3 = arg5; var_s3 < (u32) arg7; var_s3 += temp_lo) {
-
-        if (arg7 < (s32) temp_lo + var_s3) {
+        if ((u32) arg7 < temp_lo + var_s3) {
             var_s4 = arg7 - var_s3;
             if (!var_s4) {
                 break;
@@ -3253,10 +3242,8 @@ Gfx* func_80097274(Gfx* displayListHead, s8 arg1, s32 arg2, s32 arg3, s32 arg4,
         } else {
             var_s4 = temp_lo;
         }
-
         for (var_a1_2 = arg4; var_a1_2 < (u32) arg6; var_a1_2 += var_t0) {
-
-            if (arg6 < (s32) var_t0 + var_a1_2) {
+            if ((u32) arg6 < var_t0 + var_a1_2) {
                 var_s2 = arg6 - var_a1_2;
                 if (!var_s2) {
                     break;
@@ -3264,21 +3251,16 @@ Gfx* func_80097274(Gfx* displayListHead, s8 arg1, s32 arg2, s32 arg3, s32 arg4,
             } else {
                 var_s2 = var_t0;
             }
-
-            gDPLoadMultiTile(displayListHead++, arg1, 0, G_TX_RENDERTILE, arg2, G_IM_SIZ_16b, argB, argC, var_a1_2,
+            gDPLoadMultiTile(displayListHead++, argA, 0, G_TX_RENDERTILE, arg1, G_IM_SIZ_16b, argB, argC, var_a1_2,
                              var_s3, var_a1_2 + var_s2, var_s3 + var_s4, 0, G_TX_WRAP, G_TX_WRAP, sp68, sp64,
                              G_TX_NOLOD, G_TX_NOLOD);
-
-            gDPLoadMultiTile(displayListHead++, D_0B002A00 + random_int(128) * 2, 256, G_TX_RENDERTILE + 1, arg2,
+            gDPLoadMultiTile(displayListHead++, D_0B002A00 + random_int(128) * 2, 256, G_TX_RENDERTILE + 1, arg1,
                              G_IM_SIZ_16b, argB, argC, var_a1_2, var_s3, var_a1_2 + var_s2, var_s3 + var_s4, 0,
                              G_TX_WRAP, G_TX_WRAP, sp68, sp64, G_TX_NOLOD, G_TX_NOLOD);
-
             gSPTextureRectangle(displayListHead++, arg8 * 4, arg9 * 4, (arg8 + var_s2) * 4, (arg9 + var_s4) * 4, 0,
                                 (var_a1_2 * 32) & 0xFFFF, (var_s3 * 32) & 0xFFFF, arg2, arg3);
-
             arg8 += var_t0;
         }
-
         arg8 = sp7C;
         arg9 += temp_lo;
     }
@@ -3286,9 +3268,6 @@ Gfx* func_80097274(Gfx* displayListHead, s8 arg1, s32 arg2, s32 arg3, s32 arg4,
     gDPSetCycleType(displayListHead++, G_CYC_1CYCLE);
     return displayListHead;
 }
-#else
-GLOBAL_ASM("asm/non_matchings/menu_items/func_80097274.s")
-#endif
 
 #undef D_0B002A00
 
@@ -3316,8 +3295,8 @@ Gfx* func_80097AE4(Gfx* displayListHead, s8 textureFormat, s32 destX, s32 destY,
 }
 
 // Render player characters at player select menu
-Gfx* func_80097E58(Gfx* displayListHead, s8 textureFormat, u32 uls, u32 ult, u32 lrs, u32 lrt, s32 screenX, s32 screenY,
-                   u8* textureData, u32 textureWidth, u32 textureHeight, s32 width) {
+Gfx* func_80097E58(Gfx* displayListHead, s8 textureFormat, u32 uls, u32 ult, UNUSED u32 lrs, UNUSED u32 lrt,
+                   s32 screenX, s32 screenY, u8* textureData, u32 textureWidth, u32 textureHeight, s32 width) {
     if (width >= 32) {
         return displayListHead;
     }
@@ -3722,7 +3701,7 @@ void clear_menu_textures(void) {
 #include <assets/textures/player_selection.h>
 
 void load_menu_img(MenuTexture* addr) {
-    u16 size;
+    UNUSED u16 size;
     s32 i;
     s32 imgLoaded;
     MenuTexture* texAddr;
@@ -3805,7 +3784,7 @@ void load_menu_img_mio0_forced(MenuTexture* addr) {
 void load_menu_img_comp_type(MenuTexture* texAddr, s32 compType) {
     s32 i;
     s32 imgLoaded;
-    u8 clearBit;
+    UNUSED u8 clearBit;
     TextureMap* texMap = &sMenuTextureMap[0];
 
     while (texAddr->textureData != NULL) {
@@ -3824,7 +3803,7 @@ void load_menu_img_comp_type(MenuTexture* texAddr, s32 compType) {
     }
 }
 
-void func_80099958(MenuTexture* addr, s32 arg1, s32 arg2) {
+void func_80099958(MenuTexture* addr, UNUSED s32 arg1, UNUSED s32 arg2) {
     u16 size;
     MenuTexture* texAddr;
 
@@ -3869,9 +3848,9 @@ void func_80099AEC(void) {
     s8 texEnd;
     s32 size;
     s32 texSize;
-    OSIoMesg mb;
+    UNUSED OSIoMesg mb;
     OSMesg msg;
-    s32 bufSize;
+    UNUSED s32 bufSize;
     MenuTexture* texAddr;
     struct_8018E060_entry* var_s1;
 
@@ -3978,7 +3957,7 @@ void func_80099EC4(void) {
     s8 texEnd;
     s32 size;
     UNUSED s32 pad[2];
-    OSIoMesg sp68;
+    UNUSED OSIoMesg sp68;
     OSMesg sp64;
     s32 texSize;
     MenuTexture* texAddr;
@@ -4069,8 +4048,8 @@ void func_80099EC4(void) {
 
 void func_8009A238(MenuTexture* arg0, s32 arg1) {
     s32 var_a3;
-    s32 temp_v1;
-    u64* sp24;
+    UNUSED s32 temp_v1;
+    UNUSED u64* sp24;
     UNUSED TextureMap* temp_v0;
 
     temp_v1 = sMenuTextureMap[arg1].offset;
@@ -4448,7 +4427,7 @@ void adjust_img_colour(s32 index, s32 screenSize, s32 r, s32 g, s32 b) {
 
     color = LOAD_ASSET(sMenuTextureList[sMenuTextureMap[index].offset]);
 
-    for (size_t i = 0; i < screenSize; i++) {
+    for (size_t i = 0; i < (size_t) screenSize; i++) {
         u16 color_pixel = BSWAP16(*color);
         red = ((color_pixel & 0xF800) >> 0xB) * 0x4D;
         green = ((color_pixel & 0x7C0) >> 6) * 0x96;
@@ -4578,7 +4557,7 @@ Gfx* render_menu_textures(Gfx* arg0, MenuTexture* arg1, s32 column, s32 row) {
 }
 
 Gfx* render_menu_textures_alt(Gfx* arg0, MenuTexture* arg1, s32 column, s32 row) {
-    u8* temp_v0_3;
+    UNUSED u8* temp_v0_3;
     s8 var_s4;
 
     while (arg1->textureData != NULL) {
@@ -4665,7 +4644,7 @@ Gfx* func_8009BC9C(Gfx* arg0, MenuTexture* texProps, s32 arg2, s32 arg3, s32 arg
 
 Gfx* print_letter(Gfx* arg0, MenuTexture* glyphTexture, f32 arg2, f32 arg3, s32 mode, f32 scaleX, f32 scaleY) {
     s32 var_v0;
-    u8* temp_v0_2;
+    UNUSED u8* temp_v0_2;
     f32 thing0;
     f32 thing1;
     MenuTexture* var_s0;
@@ -4809,7 +4788,7 @@ Gfx* func_8009C204(Gfx* arg0, MenuTexture* arg1, s32 arg2, s32 arg3, s32 arg4) {
 }
 
 Gfx* func_8009C434(Gfx* arg0, struct_8018DEE0_entry* arg1, s32 arg2, s32 arg3, s32 arg4) {
-    s32 var_t0;
+    UNUSED s32 var_t0;
     s32 var_t1;
     Gfx* temp;
     MenuTexture* var_s0;
@@ -4866,7 +4845,7 @@ Gfx* func_8009C434(Gfx* arg0, struct_8018DEE0_entry* arg1, s32 arg2, s32 arg3, s
 }
 
 Gfx* func_8009C434_alt(Gfx* arg0, struct_8018DEE0_entry* arg1, s32 arg2, s32 arg3) {
-    s32 var_t0;
+    UNUSED s32 var_t0;
     s32 var_t1;
     Gfx* temp;
     MenuTexture* var_s0;
@@ -4899,7 +4878,7 @@ Gfx* func_8009C434_alt(Gfx* arg0, struct_8018DEE0_entry* arg1, s32 arg2, s32 arg
     return arg0;
 }
 
-Gfx* func_8009C708(Gfx* arg0, struct_8018DEE0_entry* arg1, s32 arg2, s32 arg3, s32 arg4, s32 arg5) {
+Gfx* func_8009C708(Gfx* arg0, struct_8018DEE0_entry* arg1, s32 arg2, s32 arg3, UNUSED s32 arg4, s32 arg5) {
     s32 var_t0;
     UNUSED s32 thing;
     Gfx* temp;
@@ -5895,8 +5874,8 @@ void add_menu_item(s32 type, s32 column, s32 row, s8 priority) {
     s32 temp_a1;
     MkAnimation* var_a0;
     s32 one = 1;
-    int original_width;
-    int height;
+    UNUSED int original_width;
+    UNUSED int height;
 
     var_v0 = 0;
     var_ra = gMenuItems;
@@ -6673,7 +6652,7 @@ void render_menus(MenuItem* arg0) {
                 break;
             case COURSE_SELECT_OK:
                 func_800A8564(arg0);
-                int32_t original_width = D_02004E80->width;
+                UNUSED int32_t original_width = D_02004E80->width;
                 int32_t height = D_02004E80->height;
                 D_02004E80->width = ResourceGetTexWidthByName(D_02004E80->textureData) * height /
                                     ResourceGetTexHeightByName(D_02004E80->textureData);
@@ -9676,7 +9655,7 @@ void func_800A890C(s32 arg0, MenuItem* arg1) {
         gDPPipeSync(gDisplayListHead++);
         gDPSetRenderMode(gDisplayListHead++, G_RM_OPA_SURF, G_RM_OPA_SURF2);
         gDPSetCombineMode(gDisplayListHead++, G_CC_DECALRGBA, G_CC_DECALRGBA);
-        if (arg0 == GetCupIndex()) {
+        if (arg0 == (s32) GetCupIndex()) {
             if (gSubMenuSelection == SUB_MENU_MAP_SELECT_CUP) {
                 gDisplayListHead = draw_flash_select_case_slow(gDisplayListHead, temp_t1 + temp_t7, temp_a2,
                                                                (temp_t1 - temp_t7) + 64, temp_a2 + 39);
@@ -9700,8 +9679,8 @@ void func_800A8A98(MenuItem* item) {
     gDPSetRenderMode(gDisplayListHead++, G_RM_OPA_SURF, G_RM_OPA_SURF2);
     gDPSetCombineMode(gDisplayListHead++, G_CC_DECALRGBA, G_CC_DECALRGBA);
 
-    for (i = 0; i < GetCupSize(); i++) {
-        if ((i == GetCupCursorPosition()) && (gSubMenuSelection > SUB_MENU_MAP_SELECT_CUP) &&
+    for (i = 0; i < (s32) GetCupSize(); i++) {
+        if ((i == (s32) GetCupCursorPosition()) && (gSubMenuSelection > SUB_MENU_MAP_SELECT_CUP) &&
             (gModeSelection != GRAND_PRIX)) {
             if ((gSubMenuSelection == SUB_MENU_MAP_SELECT_COURSE) ||
                 (gSubMenuSelection == SUB_MENU_MAP_SELECT_BATTLE_COURSE)) {
@@ -10879,14 +10858,14 @@ void func_800AB020(MenuItem* arg0) {
 void func_800AB098(MenuItem* arg0) {
     switch (arg0->state) {
         case 0:
-            if ((GetCupIndex() + 0x53) == arg0->type) {
+            if (((s32) GetCupIndex() + 0x53) == arg0->type) {
                 arg0->state = 2;
             } else {
                 arg0->state = 1;
             }
             break;
         case 4:
-            if ((GetCupIndex() + 0x53) == arg0->type) {
+            if (((s32) GetCupIndex() + 0x53) == arg0->type) {
                 arg0->state = 2;
                 arg0->param1 = 0;
                 break;
@@ -10903,7 +10882,7 @@ void func_800AB098(MenuItem* arg0) {
             }
             break;
         case 3:
-            if ((GetCupIndex() + 0x53) == arg0->type) {
+            if (((s32) GetCupIndex() + 0x53) == arg0->type) {
                 arg0->state = 2;
             }
             break;
@@ -10916,7 +10895,7 @@ void func_800AB098(MenuItem* arg0) {
 void func_800AB164(MenuItem* arg0) {
     Unk_D_800E70A0* thing = &D_800E7148[arg0->type - 0x53];
 
-    if ((GetCupIndex() + 0x53) == arg0->type) {
+    if (((s32) GetCupIndex() + 0x53) == arg0->type) {
         arg0->priority = 0x0A;
     } else {
         arg0->priority = 4;
@@ -10947,7 +10926,7 @@ void func_800AB164(MenuItem* arg0) {
 
 void func_800AB260(MenuItem* arg0) {
     s32 temp = (arg0->type - 0x58);
-    if (temp == GetCupIndex()) {
+    if (temp == (s32) GetCupIndex()) {
         arg0->visible = 1;
     } else {
         arg0->visible = 0;
@@ -10955,7 +10934,7 @@ void func_800AB260(MenuItem* arg0) {
 }
 
 void func_800AB290(MenuItem* arg0) {
-    if (arg0->param1 != GetCupIndex()) {
+    if (arg0->param1 != (s32) GetCupIndex()) {
         arg0->param1 = GetCupIndex();
         func_8009A594(arg0->D_8018DEE0_index, 0,
                       D_800E7E34[gCupCourseOrder[GetCupIndex()][arg0->type - 0x5F]]);
@@ -10980,8 +10959,8 @@ void func_800AB314(MenuItem* arg0) {
             if (gSubMenuSelection != one) {
                 arg0->state = 0;
                 arg0->param2 = 0;
-                for (var_a1 = 0; var_a1 < GetCupSize(); var_a1++) {
-                    if (GetCupCursorPosition() == var_a1) {
+                for (var_a1 = 0; var_a1 < (s32) GetCupSize(); var_a1++) {
+                    if ((s32) GetCupCursorPosition() == var_a1) {
                         sp24[var_a1]->visible = one;
                         if (arg0->param1 != var_a1) {
                             arg0->param1 = var_a1;
@@ -11001,7 +10980,7 @@ void func_800AB314(MenuItem* arg0) {
         case 0:
             switch (arg0->state) {
                 case 0:
-                    if ((arg0->param1 / 4) == GetCupIndex()) {
+                    if ((arg0->param1 / 4) == (s32) GetCupIndex()) {
                         arg0->param2++;
                         if (arg0->param2 >= 0x33) {
                             arg0->state = one;
@@ -11019,7 +10998,7 @@ void func_800AB314(MenuItem* arg0) {
                     }
                     break;
                 case 1:
-                    if ((arg0->param1 / 4) != GetCupIndex()) {
+                    if ((arg0->param1 / 4) != (s32) GetCupIndex()) {
                         arg0->state = 0;
                         arg0->param2 = 0;
                         arg0->param1 = 0;
@@ -11119,7 +11098,7 @@ void func_800AB904(MenuItem* arg0) {
 void func_800AB9B0(MenuItem* arg0) {
     Unk_D_800E70A0* temp_v1;
 
-    if (arg0->param1 != GetCupIndex()) {
+    if (arg0->param1 != (s32) GetCupIndex()) {
         arg0->param1 = GetCupIndex();
         arg0->param2 = func_800B54C0((s32) GetCupIndex(), gCCSelection);
         func_8009A594(arg0->D_8018DEE0_index, 0,
diff --git a/src/menus.c b/src/menus.c
index 615302c04..d045dd380 100644
--- a/src/menus.c
+++ b/src/menus.c
@@ -480,7 +480,7 @@ void options_menu_act(struct Controller* controller, u16 controllerIdx) {
             case SUB_MENU_COPY_PAK_TO_GHOST2_2P: {
                 // bit of a fake match, but if it works it works?
                 if ((sp30[sp38->param2].trackIndex !=
-                     ((0, (D_8018EE10 + (gSubMenuSelection - SUB_MENU_COPY_PAK_TO_GHOST_MIN))->trackIndex))) ||
+                     (((D_8018EE10 + (gSubMenuSelection - SUB_MENU_COPY_PAK_TO_GHOST_MIN))->trackIndex))) ||
                     ((D_8018EE10 + (gSubMenuSelection - SUB_MENU_COPY_PAK_TO_GHOST_MIN))->ghostDataSaved == 0)) {
                     if ((btnAndStick & D_JPAD) && (gSubMenuSelection < SUB_MENU_COPY_PAK_TO_GHOST_MAX)) {
                         gSubMenuSelection += 1;
@@ -1562,7 +1562,7 @@ bool is_character_spot_free(s32 gridId) {
  * Grid positions are from right to left, then top to bottom
  */
 void player_select_menu_act(struct Controller* controller, u16 controllerIdx) {
-    s8* bar;
+    UNUSED s8* bar;
     s8 selected;
     s8 i;
     s8 savedSelection;
diff --git a/src/racing/actors.c b/src/racing/actors.c
index b835ad311..b254f975f 100644
--- a/src/racing/actors.c
+++ b/src/racing/actors.c
@@ -64,7 +64,7 @@ u16 D_802BA260;
  * the game will cleanup any dead red or green shells by deleting their actors.
  */
 void cleanup_red_and_green_shells(struct ShellActor* shell) {
-    s32 actorIndex;
+    size_t actorIndex;
     struct ShellActor* compare;
 
     // try finding the dead green shell
@@ -741,7 +741,7 @@ void render_actor_shell(Camera* camera, Mat4 matrix, struct ShellActor* shell) {
     bool reverseShell = false;
 
     size_t actorIdx = CM_FindActorIndex((struct Actor*)shell);
-    if (-1 == actorIdx) {
+    if ((size_t) -1 == actorIdx) {
         printf("[render_actor_shell] Could not find actor index for FI, skipping!\n");
         return;
     }
@@ -1118,8 +1118,8 @@ void spawn_fake_item_box(Vec3f pos) {
     startingRot[1] = random_u16();
     startingRot[2] = random_u16();
     s32 id = add_actor_to_empty_slot(pos, startingRot, startingVelocity, ACTOR_FAKE_ITEM_BOX);
-    f32 height = spawn_actor_on_surface(pos[0], pos[1], pos[2]);
-    
+    spawn_actor_on_surface(pos[0], pos[1], pos[2]);
+
     struct FakeItemBox* box = (struct FakeItemBox*) CM_GetActor(id);
     box->state = 1;
     box->targetY = pos[1];
@@ -1157,7 +1157,7 @@ void init_kiwano_fruit(void) {
  * members such as pos and rot should be set to prevent using expired data
  **/
 void destroy_all_actors(void) {
-    s32 i;
+    size_t i;
     gNumActors = 0;
     for (i = 0; i < ACTOR_LIST_SIZE; i++) {
         struct Actor* actor = CM_GetActor(i);
@@ -1221,7 +1221,7 @@ void destroy_actor(struct Actor* actor) {
 }
 
 s16 try_remove_destructable_item(Vec3f pos, Vec3s rot, Vec3f velocity, s16 actorType) {
-    s32 actorIndex;
+    size_t actorIndex;
     struct ShellActor* compare;
 
     // try removing a red shell, green shell, banana, or a fake item box if the actor is expired
@@ -1639,7 +1639,7 @@ bool collision_tree(Player* player, struct Actor* actor) {
         spawn_leaf(actorPos, 0);
     }
     if (xz_dist < 0.1f) {
-        sqrtf((sp48 * sp48) + (sp44 * sp44));
+        (void) sqrtf((sp48 * sp48) + (sp44 * sp44));
         if (xz_dist) {}
         player->velocity[0] = 0;
         player->velocity[2] = 0;
@@ -2176,7 +2176,8 @@ void evaluate_collision_between_player_actor(Player* player, struct Actor* actor
 
 void evaluate_collision_for_players_and_actors(void) {
     struct Actor* temp_a1;
-    s32 i, j;
+    s32 i;
+    size_t j;
     Player* phi_s1;
 
     for (i = 0; i < NUM_PLAYERS; i++) {
@@ -2202,10 +2203,10 @@ void evaluate_collision_for_players_and_actors(void) {
 void evaluate_collision_for_destructible_actors(void) {
     struct Actor* actor1;
     struct Actor* actor2;
-    s32 i, j;
+    size_t i, j;
     UNUSED s32 pad;
 
-    for (i = gNumPermanentActors; i < (ACTOR_LIST_SIZE); i++) {
+    for (i = gNumPermanentActors; i < ACTOR_LIST_SIZE; i++) {
         actor1 = CM_GetActor(i);
 
         if ((actor1->flags & 0x8000) == 0) {
@@ -2324,7 +2325,7 @@ void init_actor_hot_air_balloon_item_box(f32 x, f32 y, f32 z) {
 void render_item_boxes(ScreenContext* arg0) {
     Camera* camera = arg0->camera;
     struct Actor* actor;
-    s32 i;
+    size_t i;
     D_8015F8DC = 0;
 
     for (i = 0; i < CM_GetActorSize(); i++) {
@@ -2352,7 +2353,7 @@ void render_course_actors(ScreenContext* screen) {
     Camera* camera = screen->camera;
     u16 pathCounter = screen->pathCounter;
     UNUSED s32 pad[12];
-    s32 i;
+    size_t i;
 
     struct Actor* actor;
     UNUSED Vec3f sp4C = { 0.0f, 5.0f, 10.0f };
@@ -2507,7 +2508,7 @@ void render_course_actors(ScreenContext* screen) {
 
 void update_course_actors(void) {
     struct Actor* actor;
-    s32 i;
+    size_t i;
     for (i = 0; i < CM_GetActorSize(); i++) {
 
         actor = CM_GetActor(i);
diff --git a/src/racing/actors_extended.c b/src/racing/actors_extended.c
index b629ec4ce..d226a8039 100644
--- a/src/racing/actors_extended.c
+++ b/src/racing/actors_extended.c
@@ -863,7 +863,7 @@ s32 use_banana_item(Player* player) {
     }
     // Extremely weird fake match to fix a tiny stack difference
     // place the banana in back of the player
-    startingPos[0, 0] = 0.0f;
+    startingPos[0] = 0.0f;
     startingPos[1] = -player->boundingBoxSize;
     startingPos[2] = -(player->boundingBoxSize + 4.0f);
 
diff --git a/src/racing/collision.c b/src/racing/collision.c
index 225dee00e..e8e9b491b 100644
--- a/src/racing/collision.c
+++ b/src/racing/collision.c
@@ -17,8 +17,6 @@
 #include <stdio.h>
 #include "engine/RaceManager.h"
 
-#pragma intrinsic(sqrtf)
-
 // Used to delete the choco mountain guard rail
 void nullify_displaylist(uintptr_t addr) {
     Gfx* macro;
@@ -2068,7 +2066,7 @@ void generate_collision_mesh(Gfx* addr, s8 surfaceType, u16 sectionId) {
                 size_t vtxDataOff = gfx->words.w1 & 0xFFFF;
                 Vtx* vtx = ( (Vtx*)ResourceGetDataByName(filePath) ) + vtxDataOff;
 
-                set_vtx_buffer(vtx, count, index);
+                set_vtx_buffer((uintptr_t) vtx, count, index);
                 break;
             }
             case G_VTX_OTR_HASH:
@@ -2187,7 +2185,7 @@ void find_vtx_and_set_colours(Gfx* displayList, s8 alpha, u8 red, u8 green, u8 b
         lo = gfx->words.w0;
         hi = gfx->words.w1;
         opcode = GFX_GET_OPCODE(lo);
-        if (opcode == ((u32) (G_ENDDL & 0xFF) << 24)) {
+        if (opcode == (G_ENDDL << 24)) {
             break;
         } else if (opcode == (G_DL << 24)) {
             find_vtx_and_set_colours((Gfx*) hi, alpha, red, green, blue);
diff --git a/src/racing/math_util.c b/src/racing/math_util.c
index 9d83a5914..59dc6e65f 100644
--- a/src/racing/math_util.c
+++ b/src/racing/math_util.c
@@ -11,8 +11,6 @@
 #include "port/Game.h"
 #include <port/interpolation/FrameInterpolation.h>
 #include <port/interpolation/matrix.h>
-#pragma intrinsic(sqrtf, fabs)
-
 s32 D_802B91C0[2] = { 13, 13 };
 Vec3f D_802B91C8 = { 0.0f, 0.0f, 0.0f };
 
@@ -1104,11 +1102,11 @@ f32 is_within_render_distance(Vec3f cameraPos, Vec3f objectPos, u16 orientationY
     f32 distance;
     f32 distanceY;
     f32 scaleFov;
-    f32 maxDistance2;
+    UNUSED f32 maxDistance2;
     s32 plus_fov_angle;
     s32 minus_fov_angle;
     u16 temp;
-    s32 count = 0;
+    UNUSED s32 count = 0;
 
     maxDistance *= 6.5f;
     maxDistance2 = 1.0f;
diff --git a/src/racing/memory.c b/src/racing/memory.c
index 6607d08c4..69e697033 100644
--- a/src/racing/memory.c
+++ b/src/racing/memory.c
@@ -26,7 +26,7 @@ s32 sGfxSeekPosition;
 s32 sPackedSeekPosition;
 
 static u8 sMemoryPool[0x10000000] ALIGNED4096;
-uintptr_t sPoolEnd = sMemoryPool + sizeof(sMemoryPool);
+uintptr_t sPoolEnd = (uintptr_t) (sMemoryPool + sizeof(sMemoryPool));
 
 uintptr_t sPoolFreeSpace;
 struct MainPoolBlock* sPoolListHeadL;
@@ -63,25 +63,6 @@ void* get_next_available_memory_addr(uintptr_t size) {
     return (void*) freeSpace;
 }
 
-static uintptr_t get_texture2(size_t offset, const course_texture* textures) {
-    if (!((offset >= 0x5000000) && (offset < 0x6000000))) {
-        return NULL;
-    }
-    size_t totalOffset = 0x5000000;
-
-    while (textures->addr) {
-        if (totalOffset == offset) {
-            return (uintptr_t) (textures->addr);
-        }
-        totalOffset += textures->data_size;
-        textures++;
-    }
-
-    printf("memory.c: get_texture()\n  TEXTURE NOT FOUND DURING DISPLAYLIST EXTRACT\n");
-    printf("  offset: 0x%zX\n", offset);
-    return NULL;
-}
-
 /**
  * @brief Sets the starting location for allocating memory and calculates pool size.
  *
@@ -272,7 +253,7 @@ UNUSED void* func_802A80B0(u8* dest, u8* srcStart, u8* srcEnd) {
     return addr;
 }
 
-uintptr_t MIO0_0F(u8* arg0, uintptr_t arg1, uintptr_t arg2) {
+uintptr_t MIO0_0F(UNUSED u8* arg0, uintptr_t arg1, uintptr_t arg2) {
     uintptr_t oldHeapEndPtr;
     void* temp_v0;
 
@@ -292,7 +273,6 @@ uintptr_t MIO0_0F(u8* arg0, uintptr_t arg1, uintptr_t arg2) {
     return oldHeapEndPtr;
 }
 
-
 /* To help verify if ptrs are pointing within segments see gfx_pc.cpp gfx_step() */
 uintptr_t vtxSegEnd;
 uintptr_t dlSegEnd;
diff --git a/src/racing/race_logic.c b/src/racing/race_logic.c
index 4118add2f..2239b7f95 100644
--- a/src/racing/race_logic.c
+++ b/src/racing/race_logic.c
@@ -28,8 +28,6 @@
 #include "port/audio/HMAS.h"
 #include "engine/editor/Editor.h"
 
-#pragma intrinsic(sqrtf)
-
 extern s16 gPlayerBalloonCount[];
 extern s16 D_8016348C;
 
@@ -423,7 +421,7 @@ void func_8028EC38(s32 arg0) {
     }
 }
 
-void func_8028EC98(s32 arg0) {
+void func_8028EC98(void) {
 
     // We want music in multiplayer, so this was removed
     //if (gScreenModeSelection == SCREEN_MODE_3P_4P_SPLITSCREEN) {
@@ -444,7 +442,7 @@ void start_race(void) {
 
     D_8015011E = -1;
     if (!gDemoMode) {
-        func_8028EC98(gCurrentCourseId);
+        func_8028EC98();
     }
 
     if (gRaceState == RACE_STAGING) {
@@ -927,7 +925,7 @@ void func_8028FCBC(void) {
                     phi_v0_4 = 0x1;
                     //! @warning this used to be < gCurrentCourseId
                     // Hopefully this is equivallent.
-                    for (i = 0; i < TrackBrowser_GetTrackIndex(); i++) {
+                    for (i = 0; i < (s32) TrackBrowser_GetTrackIndex(); i++) {
                         phi_v0_4 <<= 1;
                     }
                     if ((D_8015F890 == 0) && (!(D_800DC5AC & phi_v0_4))) {
diff --git a/src/racing/race_logic.h b/src/racing/race_logic.h
index e63094a30..995f7b928 100644
--- a/src/racing/race_logic.h
+++ b/src/racing/race_logic.h
@@ -13,7 +13,7 @@ void set_next_course(void);
 void func_8028E438(void);
 void func_8028E678(void);
 void func_8028EC38(s32);
-void func_8028EC98(s32);
+void func_8028EC98(void);
 void start_race(void);
 f32 func_8028EE8C(s32);
 void func_8028EEF0(s32);
diff --git a/src/racing/render_courses.c b/src/racing/render_courses.c
index e077396c8..4324ea511 100644
--- a/src/racing/render_courses.c
+++ b/src/racing/render_courses.c
@@ -199,11 +199,11 @@ void func_80291198(void) {
     gSPDisplayList(gDisplayListHead++, (Gfx*) d_course_mario_raceway_packed_dl_1140); //
 }
 
-void draw_transparent_geography(ScreenContext* screen, s32 playerId) {
+void draw_transparent_geography(ScreenContext* screen, UNUSED s32 playerId) {
     UNUSED s32 pad;
-    Player* player = screen->player;
+    UNUSED Player* player = screen->player;
     Mat4 matrix;
-    Vec3f vector;
+    UNUSED Vec3f vector;
     u16 pathCounter;
     u16 cameraRot;
     s16 playerDirection;
diff --git a/src/racing/skybox_and_splitscreen.c b/src/racing/skybox_and_splitscreen.c
index d317889b9..18b0e25b5 100644
--- a/src/racing/skybox_and_splitscreen.c
+++ b/src/racing/skybox_and_splitscreen.c
@@ -400,7 +400,7 @@ void func_802A487C(Vtx* arg0) {
         gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gGfxPool->mtxScreen),
                   G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
         gSPMatrix(gDisplayListHead++, &gIdentityMatrix2, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
-        gSPVertex(gDisplayListHead++, &arg0[4], 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) &arg0[4], 4, 0);
         gSP2Triangles(gDisplayListHead++, 0, 3, 1, 0, 1, 3, 2, 0);
     }
 }
@@ -466,10 +466,10 @@ void func_802A4A0C(Vtx* vtx, ScreenContext* screen) {
     gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gGfxPool->mtxScreen),
               G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
     gSPMatrix(gDisplayListHead++, &gIdentityMatrix2, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
-    gSPVertex(gDisplayListHead++, &vtx[0], 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) &vtx[0], 4, 0);
     gSP2Triangles(gDisplayListHead++, 0, 3, 1, 0, 1, 3, 2, 0);
     if (IsRainbowRoad()) {
-        gSPVertex(gDisplayListHead++, &vtx[4], 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) &vtx[4], 4, 0);
         gSP2Triangles(gDisplayListHead++, 0, 3, 1, 0, 1, 3, 2, 0);
     }
 }
@@ -529,7 +529,7 @@ void func_802A4EF4(void) {
  * The swapping of logic may be a required for proper draw order.
  * Or, perhaps they slapped functions in differing orders for each screen on a wim.
  */
-void race_begin_viewport(ScreenContext* screen, s32 mode) {
+void race_begin_viewport(ScreenContext* screen) {
     init_rdp();
 
     // --------------------------------------------------
@@ -594,7 +594,6 @@ void race_begin_viewport_4p(ScreenContext* screen) {
 }
 
 void render_screens(ScreenContext* screen, s32 mode, s32 someId, s32 playerId) {
-    Mat4 matrix;
     Camera* camera = screen->camera;
     s32 screenId = screen - gScreenContexts;
 
@@ -624,7 +623,7 @@ void render_screens(ScreenContext* screen, s32 mode, s32 someId, s32 playerId) {
             }
             break;
         default:
-            race_begin_viewport(screen, mode);
+            race_begin_viewport(screen);
 
             if ((CVarGetInteger("gDrawSky", true) == true)) {
                 CM_RaceDrawSky(screen, someId);
@@ -726,7 +725,7 @@ void render_screens(ScreenContext* screen, s32 mode, s32 someId, s32 playerId) {
 void set_screen(void) {
     ScreenContext* wrapper = &gScreenContexts[0];
     Player* player = &gPlayers[0];
-    Camera* camera = &cameras[0];
+    // Camera* camera = &cameras[0];
     struct Controller* controller = &gControllers[0];
 
     // struct? size = 0x10. unk++ doesn't work cause s32 too small.
@@ -791,7 +790,7 @@ void set_screen(void) {
                 break;
         }
         player++;
-        camera++;
+        // camera++;
         wrapper++;
         unk += 0x10;
     }
diff --git a/src/racing/skybox_and_splitscreen.h b/src/racing/skybox_and_splitscreen.h
index 9007a0783..f144a05dd 100644
--- a/src/racing/skybox_and_splitscreen.h
+++ b/src/racing/skybox_and_splitscreen.h
@@ -25,7 +25,7 @@ void func_802A450C(Vtx*);
 void func_802A487C(Vtx*);
 void func_802A4D18(void);
 void func_802A4EF4(void);
-void race_begin_viewport(ScreenContext* screen, s32 mode);
+void race_begin_viewport(ScreenContext* screen);
 void race_blank_viewport(ScreenContext* screen);
 void race_begin_viewport_4p(ScreenContext* screen);
 void render_screens(ScreenContext* screen, s32 mode, s32 someId, s32 playerId);
diff --git a/src/render_objects.c b/src/render_objects.c
index 1c22699e0..5ace5a97f 100644
--- a/src/render_objects.c
+++ b/src/render_objects.c
@@ -69,7 +69,7 @@ Lights1 D_800E46E0 = gdSPDefLights1(85, 85, 85, 255, 255, 255, 0, 0, 120);
 
 void func_800431B0(Vec3f pos, Vec3su orientation, f32 scale, Vtx* vtx) {
     rsp_set_matrix_transformation(pos, orientation, scale);
-    gSPVertex(gDisplayListHead++, vtx, 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) vtx, 4, 0);
     gSPDisplayList(gDisplayListHead++, common_rectangle_display);
 }
 
@@ -140,14 +140,14 @@ UNUSED void func_80043668(Vec3f arg0, Vec3su arg1, f32 arg2, Gfx* gfx) {
 UNUSED void func_800436D0(s32 arg0, s32 arg1, u16 arg2, f32 arg3, Vtx* vtx) {
     func_80042330(arg0, arg1, arg2, arg3);
     gSPDisplayList(gDisplayListHead++, D_0D0078A0);
-    gSPVertex(gDisplayListHead++, vtx, 3, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) vtx, 3, 0);
     gSPDisplayList(gDisplayListHead++, D_0D006930);
 }
 
 UNUSED void func_80043764(s32 arg0, s32 arg1, u16 arg2, f32 arg3, Vtx* vtx) {
     func_80042330(arg0, arg1, arg2, arg3);
     gSPDisplayList(gDisplayListHead++, D_0D0078A0);
-    gSPVertex(gDisplayListHead++, vtx, 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) vtx, 4, 0);
     gSPDisplayList(gDisplayListHead++, common_rectangle_display);
 }
 
@@ -160,7 +160,7 @@ UNUSED void func_800437F8(s32 arg0, s32 arg1, u16 arg2, f32 arg3, Vtx* vtx, s32
     vtx[1].v.cn[3] = arg5;
     vtx[2].v.cn[3] = arg5;
     vtx[3].v.cn[3] = arg5;
-    gSPVertex(gDisplayListHead++, vtx, 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) vtx, 4, 0);
     gSPDisplayList(gDisplayListHead++, common_rectangle_display);
 }
 
@@ -170,7 +170,7 @@ UNUSED void func_800438C4(s32 arg0, s32 arg1, u16 arg2, f32 arg3, Vtx* vtx, s32
     func_80042330(arg0, arg1, arg2, arg3);
     gSPDisplayList(gDisplayListHead++, D_0D0078A0);
     gDPSetRenderMode(gDisplayListHead++, G_RM_CLD_SURF, G_RM_CLD_SURF2);
-    gSPVertex(gDisplayListHead++, vtx, 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) vtx, 4, 0);
     gSPDisplayList(gDisplayListHead++, common_rectangle_display);
 }
 
@@ -180,7 +180,7 @@ UNUSED void func_8004398C(s32 arg0, s32 arg1, u16 arg2, f32 arg3, Vtx* vtx, s32
     func_80042330(arg0, arg1, arg2, arg3);
     gSPDisplayList(gDisplayListHead++, D_0D0078A0);
     gDPSetRenderMode(gDisplayListHead++, G_RM_CLD_SURF, G_RM_CLD_SURF2);
-    gSPVertex(gDisplayListHead++, vtx, 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) vtx, 4, 0);
     gSPDisplayList(gDisplayListHead++, common_rectangle_display);
 }
 
@@ -394,19 +394,19 @@ UNUSED void func_80045738(u8* image1, u8* image2, s32 width, s32 height) {
 }
 
 void func_80045B2C(Vtx* arg0) {
-    gSPVertex(gDisplayListHead++, arg0, 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) arg0, 4, 0);
     gSPDisplayList(gDisplayListHead++, common_rectangle_display);
 }
 
 void func_80045B74(Vtx* arg0) {
-    gSPVertex(gDisplayListHead++, arg0, 3, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) arg0, 3, 0);
     gSPDisplayList(gDisplayListHead++, D_0D006930);
 }
 
 UNUSED void func_80045BBC(Vec3f arg0, Vec3su arg1, f32 arg2, Vtx* arg3) {
     rsp_set_matrix_transformation(arg0, arg1, arg2);
     gSPDisplayList(gDisplayListHead++, D_0D0078A0);
-    gSPVertex(gDisplayListHead++, arg3, 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) arg3, 4, 0);
     gSPDisplayList(gDisplayListHead++, common_rectangle_display);
 }
 
@@ -414,7 +414,7 @@ UNUSED void func_80045C48(Vec3f arg0, Vec3su arg1, f32 arg2, Vtx* arg3) {
     rsp_set_matrix_transformation(arg0, arg1, arg2);
     gSPDisplayList(gDisplayListHead++, D_0D0078D0);
     gSPClearGeometryMode(gDisplayListHead++, G_CULL_BOTH);
-    gSPVertex(gDisplayListHead++, arg3, 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) arg3, 4, 0);
     gSPDisplayList(gDisplayListHead++, common_rectangle_display);
     gSPSetGeometryMode(gDisplayListHead++, G_CULL_BACK);
 }
@@ -700,7 +700,7 @@ void func_80047068(u8* tlut, u8* texture, Vtx* arg2, UNUSED s32 arg3, s32 arg4,
     gDPLoadTLUT_pal256(gDisplayListHead++, tlut);
     for (heightIndex = 0; heightIndex < arg4 / height; heightIndex++) {
         rsp_load_texture(img, width, height);
-        gSPVertex(gDisplayListHead++, &arg2[vertexIndex], 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) &arg2[vertexIndex], 4, 0);
         gSPDisplayList(gDisplayListHead++, common_rectangle_display);
         img += width * height;
         vertexIndex += 4;
@@ -717,7 +717,7 @@ void draw_rectangle_texture_overlap(u8* tlut, u8* texture, Vtx* arg2, UNUSED s32
     gDPLoadTLUT_pal256(gDisplayListHead++, tlut);
     for (heightIndex = 0; heightIndex < height / heighthalf; heightIndex++) {
         rsp_load_texture(img, width, heighthalf);
-        gSPVertex(gDisplayListHead++, &arg2[vertexIndex], 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) &arg2[vertexIndex], 4, 0);
         gSPDisplayList(gDisplayListHead++, common_rectangle_display);
         img += width * (heighthalf - 1);
         vertexIndex += 4;
@@ -733,7 +733,7 @@ void func_8004747C(u8* tlut, u8* texture, Vtx* arg2, UNUSED s32 arg3, s32 arg4,
     gDPLoadTLUT_pal256(gDisplayListHead++, tlut);
     for (heightIndex = 0; heightIndex < arg4 / height; heightIndex++) {
         rsp_load_texture_mask(img, width, height, someMask);
-        gSPVertex(gDisplayListHead++, &arg2[vertexIndex], 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) &arg2[vertexIndex], 4, 0);
         gSPDisplayList(gDisplayListHead++, common_rectangle_display);
         img += width * (height - 1);
         vertexIndex += 4;
@@ -750,7 +750,7 @@ void func_8004768C(u8* tlut, u8* texture, Vtx* arg2, s32 arg3, s32 width, s32 he
     for (heightIndex = 0; heightIndex < arg3 / height; heightIndex++) {
         // Something seems off about arguments here, but if it matches it matches
         rsp_load_texture(img, height, width);
-        gSPVertex(gDisplayListHead++, &arg2[vertexIndex], 4, 0);
+        gSPVertex(gDisplayListHead++, (uintptr_t) &arg2[vertexIndex], 4, 0);
         gSPDisplayList(gDisplayListHead++, common_rectangle_display);
         img += height * width;
         vertexIndex += 4;
@@ -935,14 +935,14 @@ void func_80048438(Vec3f arg0, Vec3su arg1, f32 arg2, s32 arg3, u8* tlut, u8* te
     func_80047068(tlut, texture, arg6, arg7, arg8, arg9, argA);
 }
 
-void func_800484BC(Vec3f arg0, Vec3su arg1, f32 arg2, s32 arg3, u8* tlut, u8* texture, Vtx* arg6, s32 arg7, s32 arg8,
-                   s32 arg9, s32 argA) {
+void func_800484BC(Vec3f arg0, Vec3su arg1, f32 arg2, s32 arg3, u8* tlut, u8* texture, Vtx* arg6, UNUSED s32 arg7,
+                   s32 arg8, s32 arg9, UNUSED s32 argA) {
     rsp_set_matrix_transformation(arg0, arg1, arg2);
     gSPDisplayList(gDisplayListHead++, D_0D007E18);
     set_transparency(arg3);
     gDPLoadTLUT_pal256(gDisplayListHead++, tlut);
     rsp_load_texture(texture, arg9, arg8);
-    gSPVertex(gDisplayListHead++, arg6, 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) arg6, 4, 0);
     gSPDisplayList(gDisplayListHead++, common_rectangle_display);
     gSPTexture(gDisplayListHead++, 1, 1, 0, G_TX_RENDERTILE, G_OFF);
 }
@@ -1069,7 +1069,7 @@ void func_80048F8C(u8* texture, Vtx* arg1, s32 arg2, s32 arg3, s32 width, s32 he
     for (heightIndex = 0; heightIndex < arg3 / height; heightIndex++) {
         for (widthIndex = 0; widthIndex < arg2 / width; widthIndex++) {
             load_texture_block_ia16_nomirror(img, width, height);
-            gSPVertex(gDisplayListHead++, &arg1[vertexIndex], 4, 0);
+            gSPVertex(gDisplayListHead++, (uintptr_t) &arg1[vertexIndex], 4, 0);
             gSPDisplayList(gDisplayListHead++, common_rectangle_display);
             img += width * height * 2;
             vertexIndex += 4;
@@ -1087,7 +1087,7 @@ void func_80049130(u8* texture, Vtx* arg1, s32 arg2, s32 arg3, s32 width, s32 he
     for (heightIndex = 0; heightIndex < arg3 / height; heightIndex++) {
         for (widthIndex = 0; widthIndex < arg2 / width; widthIndex++) {
             load_texture_tile_ia16_nomirror(img, width, height);
-            gSPVertex(gDisplayListHead++, &arg1[vertexIndex], 4, 0);
+            gSPVertex(gDisplayListHead++, (uintptr_t) &arg1[vertexIndex], 4, 0);
             gSPDisplayList(gDisplayListHead++, common_rectangle_display);
             img += width * height * 2;
             vertexIndex += 4;
@@ -1105,7 +1105,7 @@ void func_800492D4(u8* texture, Vtx* arg1, s32 arg2, s32 arg3, s32 width, s32 he
     for (heightIndex = 0; heightIndex < arg3 / height; heightIndex++) {
         for (widthIndex = 0; widthIndex < arg2 / width; widthIndex++) {
             load_texture_block_ia8_nomirror(img, width, height);
-            gSPVertex(gDisplayListHead++, &arg1[vertexIndex], 4, 0);
+            gSPVertex(gDisplayListHead++, (uintptr_t) &arg1[vertexIndex], 4, 0);
             gSPDisplayList(gDisplayListHead++, common_rectangle_display);
             img += width * height;
             vertexIndex += 4;
@@ -1123,7 +1123,7 @@ void func_80049478(u8* texture, Vtx* arg1, s32 arg2, s32 arg3, s32 width, s32 he
     for (heightIndex = 0; heightIndex < arg3 / height; heightIndex++) {
         for (widthIndex = 0; widthIndex < arg2 / width; widthIndex++) {
             load_texture_tile_ia8_nomirror(img, width, height);
-            gSPVertex(gDisplayListHead++, &arg1[vertexIndex], 4, 0);
+            gSPVertex(gDisplayListHead++, (uintptr_t) &arg1[vertexIndex], 4, 0);
             gSPDisplayList(gDisplayListHead++, common_rectangle_display);
             img += width * height;
             vertexIndex += 4;
@@ -1142,7 +1142,7 @@ void func_8004961C(u8* texture, Vtx* arg1, s32 arg2, s32 arg3, s32 width, s32 he
         for (j = 0; j < arg2 / width; j++) {
 
             func_80044924(img, width, height);
-            gSPVertex(gDisplayListHead++, &arg1[var_s2], 4, 0);
+            gSPVertex(gDisplayListHead++, (uintptr_t) &arg1[var_s2], 4, 0);
             gSPDisplayList(gDisplayListHead++, common_rectangle_display);
             img += (width * height) / 2;
             var_s2 += 4;
@@ -1161,7 +1161,7 @@ void func_800497CC(u8* texture, Vtx* arg1, s32 arg2, s32 arg3, s32 width, s32 he
     for (heightIndex = 0; heightIndex < arg3 / height; heightIndex++) {
         for (widthIndex = 0; widthIndex < arg2 / width; widthIndex++) {
             func_80044BF8(img, width, height);
-            gSPVertex(gDisplayListHead++, &arg1[vertexIndex], 4, 0);
+            gSPVertex(gDisplayListHead++, (uintptr_t) &arg1[vertexIndex], 4, 0);
             gSPDisplayList(gDisplayListHead++, common_rectangle_display);
             img += width * height;
             vertexIndex += 4;
@@ -1179,7 +1179,7 @@ void func_80049970(u8* texture, Vtx* arg1, s32 arg2, s32 arg3, s32 width, s32 he
     for (i = 0; i < arg3 / height; i++) {
         for (j = 0; j < arg2 / width; j++) {
             func_80044DA0(img, width, height);
-            gSPVertex(gDisplayListHead++, &arg1[var_s2], 4, 0);
+            gSPVertex(gDisplayListHead++, (uintptr_t) &arg1[var_s2], 4, 0);
             gSPDisplayList(gDisplayListHead++, common_rectangle_display);
             img += (width * height) / 2;
             var_s2 += 4;
@@ -1299,12 +1299,12 @@ void func_8004A258(s32 arg0, s32 arg1, u16 arg2, f32 arg3, u8* texture, Vtx* arg
 }
 
 void func_8004A2F4(s32 arg0, s32 arg1, u16 arg2, f32 arg3, s32 red, s32 green, s32 blue, s32 alpha, u8* texture,
-                   Vtx* vtx, s32 argA, s32 argB, s32 width, s32 height) {
+                   Vtx* vtx, s32 argA, s32 argB, UNUSED s32 width, UNUSED s32 height) {
     func_80042330(arg0, arg1, arg2, arg3);
     gSPDisplayList(gDisplayListHead++, D_0D007A40);
     func_8004B414(red, green, blue, alpha);
     func_80044DA0(texture, argA, argB);
-    gSPVertex(gDisplayListHead++, vtx, 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) vtx, 4, 0);
     gSPDisplayList(gDisplayListHead++, common_rectangle_display);
     gSPTexture(gDisplayListHead++, 0x0001, 0x0001, 0, G_TX_RENDERTILE, G_OFF);
 }
@@ -1672,9 +1672,9 @@ void render_texture_rectangle_wide(s32 x, s32 y, s32 width, s32 height, s32 arg4
     //                     1 << 10);
 }
 
-void render_texture_rectangle_wide_left(s32 x, s32 y, s32 width, s32 height, s32 arg4, s32 arg5, s32 arg6) {
-    s32 xh = (((x + width) - 1));
-    s32 yh = (((y + height) - 1) << 2);
+void render_texture_rectangle_wide_left(s32 x, s32 y, s32 width, s32 height, s32 arg4, s32 arg5, UNUSED s32 arg6) {
+    UNUSED s32 xh = (((x + width) - 1));
+    UNUSED s32 yh = (((y + height) - 1) << 2);
     s32 xl = ((x));
     s32 yl = y << 2;
 
@@ -2064,13 +2064,13 @@ void func_8004C628(s32 arg0, s32 arg1, u32 arg2, u32 arg3, u8* texture) {
 
 // non-matching
 void render_texture_tile_rgba32_block(s16 x, s16 y, u8* texture, u32 width, u32 height) {
-    s32 remainingSize;
+    UNUSED s32 remainingSize;
     s32 currX;
     s32 currY;
-    u32 size;
-    s32 tileHeight;
-    s32 numTiles;
-    s32 numTilesDup;
+    UNUSED u32 size;
+    UNUSED s32 tileHeight;
+    UNUSED s32 numTiles;
+    UNUSED s32 numTilesDup;
 
     currX = x - (width / 2);
     currY = y - (height / 2);
@@ -2091,7 +2091,7 @@ void render_game_logo(s16 x, s16 y) {
     int32_t height = 128;
     int32_t width =
         ResourceGetTexWidthByName(logo_mario_kart_64) * height / ResourceGetTexHeightByName(logo_mario_kart_64);
-    render_texture_tile_rgba32_block(x, y, logo_mario_kart_64, width, height);
+    render_texture_tile_rgba32_block(x, y, (u8*) logo_mario_kart_64, width, height);
 }
 
 UNUSED void func_8004C91C(s32 arg0, s32 arg1, u8* texture, s32 arg3, s32 arg4, s32 arg5) {
@@ -2161,10 +2161,10 @@ void func_8004D210(s32 arg0, s32 arg1, u8* texture, s32 arg3, s32 arg4, s32 arg5
 }
 
 void func_8004D37C(s32 x, s32 y, u8* texture, s32 red, s32 green, s32 blue, s32 alpha, s32 width, s32 height,
-                   UNUSED s32 width2, s32 height2) {
-    s32 var_s3;
+                   UNUSED s32 width2, UNUSED s32 height2) {
+    UNUSED s32 var_s3;
     u8* img;
-    s32 i;
+    UNUSED s32 i;
 
     img = texture;
     gSPDisplayList(gDisplayListHead++, D_0D007FE0);
@@ -2178,7 +2178,7 @@ void func_8004D4E8(s32 arg0, s32 arg1, u8* texture, s32 red, s32 green, s32 blue
                    UNUSED s32 width2, s32 height2) {
     s32 var_s3;
     u8* img;
-    s32 i;
+    UNUSED s32 i;
 
     var_s3 = arg1 - (height / 2);
     img = texture;
@@ -2193,7 +2193,7 @@ void func_8004D4E8(s32 arg0, s32 arg1, u8* texture, s32 red, s32 green, s32 blue
 void func_8004D654(s32 arg0, s32 arg1, u8* texture, f32 arg3, s32 arg4, s32 arg5, s32 arg6, UNUSED s32 arg7, s32 width,
                    s32 arg9, UNUSED s32 argA, s32 height) {
     s32 i;
-    s32 var_s3;
+    UNUSED s32 var_s3;
     u8* textureCopy;
 
     var_s3 = arg1 - (arg9 / 2);
@@ -2405,7 +2405,7 @@ void draw_item_window(s32 playerId) {
     if (object->state >= 2) {
         temp_v0 = &playerHUD[playerId];
         func_8004E4CC(temp_v0->slideItemBoxX + temp_v0->itemBoxX, temp_v0->slideItemBoxY + temp_v0->itemBoxY,
-                      (u8*) object->activeTLUT, object->activeTexture);
+                      (u8*) object->activeTLUT, (u8*) object->activeTexture);
     }
 }
 
@@ -2440,14 +2440,14 @@ void func_8004E800(s32 playerId) {
             func_8004A384(playerHUD[playerId].rankX + playerHUD[playerId].slideRankX,
                           playerHUD[playerId].rankY + playerHUD[playerId].slideRankY, 0U,
                           playerHUD[playerId].rankScaling, 0x000000FF, D_800E55F8[D_8018CF98[playerId]], 0, 0x000000FF,
-                          common_texture_hud_place[D_8018CF98[playerId]], D_0D0068F0, 0x00000080, 0x00000040,
+                          (u8*) common_texture_hud_place[D_8018CF98[playerId]], D_0D0068F0, 0x00000080, 0x00000040,
                           0x00000080, 0x00000040);
         } else {
             func_8004A384(playerHUD[playerId].rankX + playerHUD[playerId].slideRankX,
                           playerHUD[playerId].rankY + playerHUD[playerId].slideRankY, 0U,
                           playerHUD[playerId].rankScaling, 0x000000FF, D_800E55F8[D_80165594], 0, 0x000000FF,
-                          common_texture_hud_place[gGPCurrentRaceRankByPlayerId[playerId]], D_0D0068F0, 0x00000080,
-                          0x00000040, 0x00000080, 0x00000040);
+                          (u8*) common_texture_hud_place[gGPCurrentRaceRankByPlayerId[playerId]], D_0D0068F0,
+                          0x00000080, 0x00000040, 0x00000080, 0x00000040);
         }
     }
     FrameInterpolation_RecordCloseChild();
@@ -2461,13 +2461,13 @@ void func_8004E998(s32 playerId) {
                           playerHUD[playerId].rankY + playerHUD[playerId].slideRankY, 0U,
                           playerHUD[playerId].rankScaling, 0x000000FF,
                           D_800E5618[gGPCurrentRaceRankByPlayerId[playerId]], 0, 0x000000FF,
-                          D_0D015258[gGPCurrentRaceRankByPlayerId[playerId]], D_0D006030, 0x00000040, 0x00000040,
+                          (u8*) D_0D015258[gGPCurrentRaceRankByPlayerId[playerId]], D_0D006030, 0x00000040, 0x00000040,
                           0x00000040, 0x00000040);
         } else {
             func_8004A384(playerHUD[playerId].rankX + playerHUD[playerId].slideRankX,
                           playerHUD[playerId].rankY + playerHUD[playerId].slideRankY, 0U,
                           playerHUD[playerId].rankScaling, 0x000000FF, D_800E5618[D_80165598], 0, 0x000000FF,
-                          D_0D015258[gGPCurrentRaceRankByPlayerId[playerId]], D_0D006030, 0x00000040, 0x00000040,
+                          (u8*) D_0D015258[gGPCurrentRaceRankByPlayerId[playerId]], D_0D006030, 0x00000040, 0x00000040,
                           0x00000040, 0x00000040);
         }
         FrameInterpolation_RecordCloseChild();
@@ -2533,10 +2533,10 @@ void render_speedometer(s32 playerIdx) {
     func_8004A2F4(playerHUD[playerIdx].speedometerX, playerHUD[playerIdx].speedometerY, 0U, 1.0f,
                   // RGBA
                   CM_GetProps()->Minimap.Colour.r, CM_GetProps()->Minimap.Colour.g, CM_GetProps()->Minimap.Colour.b,
-                  0xFF, common_texture_speedometer, speedometer_vtx, 64, 96, 64, 48);
+                  0xFF, (u8*) common_texture_speedometer, speedometer_vtx, 64, 96, 64, 48);
     // x, y, needle rot
-    func_8004A258(D_8018CFEC, D_8018CFF4, D_8016579E, 1.0f, common_texture_speedometer_needle, D_0D005FF0, 0x40, 0x20,
-                  0x40, 0x20);
+    func_8004A258(D_8018CFEC, D_8018CFF4, D_8016579E, 1.0f, (u8*) common_texture_speedometer_needle, D_0D005FF0, 0x40,
+                  0x20, 0x40, 0x20);
 }
 
 // player is only 0 or 1
@@ -2567,8 +2567,8 @@ void func_8004EF9C(s32 arg0) {
 
     width = ResourceGetTexWidthByName(minimap);
     height = ResourceGetTexHeightByName(minimap);
-    func_8004D37C(0x00000104, 0x0000003C, minimap, 0x000000FF, 0x000000FF,
-                  0x000000FF, 0x000000FF, width, height, width, height);
+    func_8004D37C(0x00000104, 0x0000003C, (u8*) minimap, 0x000000FF, 0x000000FF, 0x000000FF, 0x000000FF, width, height,
+                  width, height);
 }
 
 void set_minimap_finishline_position(s32 playerId) {
@@ -2847,7 +2847,7 @@ void func_8004FDB4(f32 arg0, f32 arg1, s16 arg2, s16 arg3, s16 characterId, s32
         gSPDisplayList(gDisplayListHead++, D_0D007DB8);
         func_8004B35C(0x000000FF, 0x000000FF, 0x000000FF, D_8018D3E0);
         gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_portrait_bomb_kart_and_question_mark);
-        rsp_load_texture(common_texture_portrait_question_mark, 0x00000020, 0x00000020);
+        rsp_load_texture((u8*) common_texture_portrait_question_mark, 0x00000020, 0x00000020);
         gSPDisplayList(gDisplayListHead++, D_0D0069E0);
     } else {
         func_80042330_portrait(arg0, arg1, 0U, 1.0f, arg3);
@@ -2864,14 +2864,14 @@ void func_8004FDB4(f32 arg0, f32 arg1, s16 arg2, s16 arg3, s16 characterId, s32
             func_80042330_portrait(arg0, arg1, 0U, 1.0f, arg3);
             gSPDisplayList(gDisplayListHead++, D_0D007A60);
             func_8004B35C(D_8018D3E4, D_8018D3E8, D_8018D3EC, 0x000000FF);
-            func_80044924(common_texture_character_portrait_border, 0x20, 0x20);
+            func_80044924((u8*) common_texture_character_portrait_border, 0x20, 0x20);
             gSPDisplayList(gDisplayListHead++, D_0D0069E0);
         }
         gSPDisplayList(gDisplayListHead++, D_0D007DB8);
         func_8004B35C(0x000000FF, 0x000000FF, 0x000000FF, arg5);
         gSPDisplayList(gDisplayListHead++, D_0D007CB8);
         gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_hud_type_C_rank_font);
-        rsp_load_texture(common_texture_hud_type_C_rank_font[arg2], 0x00000010, 0x00000010);
+        rsp_load_texture((u8*) common_texture_hud_type_C_rank_font[arg2], 0x00000010, 0x00000010);
         if (arg7 != 0) {
             func_80042330_portrait((s32) (arg0 + 9.0f), (s32) (arg1 + 7.0f), 0U, 1.0f, arg3);
         } else {
@@ -3102,7 +3102,7 @@ void func_80050C68(void) {
             func_800507D8(var_s1, &sp88, &sp84);
             gSPDisplayList(gDisplayListHead++, D_0D007DB8);
             gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_portrait_bomb_kart_and_question_mark);
-            rsp_load_texture(common_texture_portrait_bomb_kart, 0x00000020, 0x00000020);
+            rsp_load_texture((u8*) common_texture_portrait_bomb_kart, 0x00000020, 0x00000020);
             func_80042330(sp88 + 0x20, sp84 + 0x12, 0U, 0.6f);
             gSPDisplayList(gDisplayListHead++, D_0D0069E0);
         }
@@ -3142,7 +3142,7 @@ void func_80050E34(s32 playerId, s32 arg1) {
     if ((IsYoshiValley()) && (lapCount < 3)) {
         gSPDisplayList(gDisplayListHead++, D_0D007DB8);
         gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_portrait_bomb_kart_and_question_mark);
-        rsp_load_texture(common_texture_portrait_question_mark, 0x00000020, 0x00000020);
+        rsp_load_texture((u8*) common_texture_portrait_question_mark, 0x00000020, 0x00000020);
         object = &gObjectList[objectIndex];
         object->pos[0] = object->offset[0] + ((f32) (spD0 + 0x20));
         object->pos[1] = object->offset[1] + ((f32) (spC4 + spCC));
@@ -3170,7 +3170,7 @@ void func_80050E34(s32 playerId, s32 arg1) {
             gSPDisplayList(gDisplayListHead++, D_0D0069E0);
         }
         gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_hud_type_C_rank_tiny_font);
-        rsp_load_texture(common_texture_hud_type_C_rank_tiny_font[arg1 + 1], 8, 8);
+        rsp_load_texture((u8*) common_texture_hud_type_C_rank_tiny_font[arg1 + 1], 8, 8);
         if (spB8 != 0) {
             func_80042330_unchanged(spD0 + 0x26, (spC4 + spCC) + 4, 0U, 1.0f);
         } else {
@@ -3180,7 +3180,7 @@ void func_80050E34(s32 playerId, s32 arg1) {
         if ((player == gPlayerOne) && (gScreenModeSelection == SCREEN_MODE_1P)) {
             gSPDisplayList(gDisplayListHead++, D_0D007A40);
             func_8004B35C(D_8018D3E4, D_8018D3E8, D_8018D3EC, 0x000000FF);
-            func_80044924(common_texture_character_portrait_border, 0x00000020, 0x00000020);
+            func_80044924((u8*) common_texture_character_portrait_border, 0x00000020, 0x00000020);
             rsp_set_matrix_transformation(object->pos, object->direction_angle, object->sizeScaling);
             gSPDisplayList(gDisplayListHead++, D_0D0069E0);
         }
@@ -3250,7 +3250,7 @@ void render_object_snowflakes_particles(s32 cameraId) {
 
     gSPDisplayList(gDisplayListHead++, D_0D007AE0);
     gDPSetCombineLERP(gDisplayListHead++, 1, 0, SHADE, 0, 0, 0, 0, TEXEL0, 1, 0, SHADE, 0, 0, 0, 0, TEXEL0);
-    func_80044F34(D_0D0293D8, 0x10, 0x10);
+    func_80044F34((u8*) D_0D0293D8, 0x10, 0x10);
     for (i = 0; i < NUM_SNOWFLAKES; i++) {
         snowflakeIndex = gObjectParticle1[i];
 
@@ -3267,21 +3267,21 @@ void render_object_snowflakes_particles(s32 cameraId) {
 }
 
 // Render clouds
-void func_80051ABC(ScreenContext* screen, s16 arg0, s32 arg1) {
-    s32 var_s0;
-    s32 objectIndex;
-    Object* object;
+void func_80051ABC(ScreenContext* screen, s16 arg0, UNUSED s32 arg1) {
+    UNUSED s32 var_s0;
+    UNUSED s32 objectIndex;
+    UNUSED Object* object;
 
     D_8018D228 = 0xFF;
     gSPDisplayList(gDisplayListHead++, D_0D007A60);
     DrawSkyActors(screen, arg0);
 }
 
-void func_80051C60(ScreenContext* screen, s16 arg0, s32 arg1) {
+void func_80051C60(ScreenContext* screen, s16 arg0, UNUSED s32 arg1) {
     s16 var_s5;
-    s32 var_s0;
-    s32 objectIndex;
-    Object* object;
+    UNUSED s32 var_s0;
+    UNUSED s32 objectIndex;
+    UNUSED Object* object;
 
     if (D_801658FE == 0) {
         if (IsKoopaTroopaBeach()) {
@@ -3398,7 +3398,7 @@ void func_800528EC(s32 cameraId) {
     gDPSetCombineMode(gDisplayListHead++, G_CC_MODULATEIA, G_CC_MODULATEIA);
     gSPClearGeometryMode(gDisplayListHead++, G_CULL_BOTH);
     gSPSetGeometryMode(gDisplayListHead++, G_SHADE | G_LIGHTING | G_SHADING_SMOOTH);
-    load_texture_block_ia16_nomirror(d_course_sherbet_land_ice, 32, 32);
+    load_texture_block_ia16_nomirror((u8*) d_course_sherbet_land_ice, 32, 32);
     if (gPlayerCountSelection1 < 3) {
         for (var_s3 = 0; var_s3 < gObjectParticle2_SIZE; var_s3++) {
             objectIndex = gObjectParticle2[var_s3];
@@ -3407,7 +3407,7 @@ void func_800528EC(s32 cameraId) {
                 if (object->state > 0) {
                     FrameInterpolation_RecordOpenChild("ice_block2", (var_s3 << 4) | cameraId);
                     rsp_set_matrix_transformation(object->pos, D_80183E80, object->sizeScaling);
-                    gSPVertex(gDisplayListHead++, D_0D005BD0, 3, 0);
+                    gSPVertex(gDisplayListHead++, (uintptr_t) D_0D005BD0, 3, 0);
                     gSPDisplayList(gDisplayListHead++, D_0D006930);
                     FrameInterpolation_RecordCloseChild();
                 }
@@ -3422,7 +3422,7 @@ void func_800528EC(s32 cameraId) {
                     (gMatrixHudCount <= MTX_HUD_POOL_SIZE_MAX)) {
                     FrameInterpolation_RecordOpenChild("ice_block3", (var_s3 << 4) | cameraId);
                     rsp_set_matrix_transformation(object->pos, D_80183E80, object->sizeScaling);
-                    gSPVertex(gDisplayListHead++, D_0D005BD0, 3, 0);
+                    gSPVertex(gDisplayListHead++, (uintptr_t) D_0D005BD0, 3, 0);
                     gSPDisplayList(gDisplayListHead++, D_0D006930);
                     FrameInterpolation_RecordCloseChild();
                 }
@@ -3442,7 +3442,7 @@ void render_ice_block(s32 cameraId) {
     D_800E4620.l[0].l.dir[2] = D_80165840[2];
     gSPLight(gDisplayListHead++, &D_800E4620.l[0], LIGHT_1);
     gSPLight(gDisplayListHead++, &D_800E4620.a, LIGHT_2);
-    for (size_t i = 0; i < gPlayerCountSelection1; i++) {
+    for (size_t i = 0; i < (size_t) gPlayerCountSelection1; i++) {
         objectIndex = gIndexLakituList[i];
         if (objectIndex) {}
         if (func_80072320(objectIndex, 4) != false) {
@@ -3511,7 +3511,7 @@ void render_object_trains_smoke_particles(s32 cameraId) {
 
     camera = &camera1[cameraId];
     gSPDisplayList(gDisplayListHead++, D_0D007AE0);
-    load_texture_block_i8_nomirror(D_0D029458, 32, 32);
+    load_texture_block_i8_nomirror((u8*) D_0D029458, 32, 32);
     func_8004B72C(255, 255, 255, 255, 255, 255, 255);
     D_80183E80[0] = 0;
     D_80183E80[2] = 0x8000;
@@ -3573,7 +3573,7 @@ void render_object_paddle_boat_smoke_particles(s32 cameraId) {
     camera = &camera1[cameraId];
     gSPDisplayList(gDisplayListHead++, D_0D007AE0);
 
-    load_texture_block_i8_nomirror(D_0D029458, 32, 32);
+    load_texture_block_i8_nomirror((u8*) D_0D029458, 32, 32);
     func_8004B72C(255, 255, 255, 255, 255, 255, 255);
     D_80183E80[0] = 0;
     D_80183E80[2] = 0x8000;
@@ -3615,7 +3615,7 @@ void render_object_bowser_flame(s32 cameraId) {
     s32 objectIndex;
 
     gSPDisplayList(gDisplayListHead++, D_0D007AE0);
-    load_texture_block_i8_nomirror(common_texture_particle_smoke[D_80165598], 0x00000020, 0x00000020);
+    load_texture_block_i8_nomirror((u8*) common_texture_particle_smoke[D_80165598], 0x00000020, 0x00000020);
     func_8004B414(0, 0, 0, 0x000000FF);
     D_80183E80[0] = 0;
     D_80183E80[2] = 0x8000;
@@ -3660,7 +3660,7 @@ void render_object_smoke_particles(s32 cameraId) {
     sp54 = &camera1[cameraId];
 
     gSPDisplayList(gDisplayListHead++, D_0D007AE0);
-    load_texture_block_i8_nomirror(common_texture_particle_smoke[D_80165598], 32, 32);
+    load_texture_block_i8_nomirror((u8*) common_texture_particle_smoke[D_80165598], 32, 32);
     func_8004B72C(255, 255, 255, 255, 255, 255, 255);
     D_80183E80[0] = 0;
     D_80183E80[2] = 0x8000;
@@ -3755,8 +3755,8 @@ void render_object_neon(s32 cameraId) {
                 rsp_set_matrix_transformation(object->pos, object->orientation, object->sizeScaling);
                 gSPDisplayList(gDisplayListHead++, D_0D007D78);
                 gDPLoadTLUT_pal256(gDisplayListHead++, object->activeTLUT);
-                rsp_load_texture(object->activeTexture, 64, 64);
-                gSPVertex(gDisplayListHead++, common_vtx_neon, 4, 0);
+                rsp_load_texture((u8*) object->activeTexture, 64, 64);
+                gSPVertex(gDisplayListHead++, (uintptr_t) common_vtx_neon, 4, 0);
                 gSPDisplayList(gDisplayListHead++, common_rectangle_display);
                 gSPTexture(gDisplayListHead++, 1, 1, 0, G_TX_RENDERTILE, G_OFF);
             }
diff --git a/src/render_player.c b/src/render_player.c
index 07a9cc38f..741d68ed1 100644
--- a/src/render_player.c
+++ b/src/render_player.c
@@ -304,32 +304,28 @@ void load_kart_texture_and_render_kart_particles(s32 screenIdx) {
             D_801651D0[gPlayersToRenderScreenId[i]][gPlayersToRenderPlayerId[i]]
         );
 
-        strcpy(
-            D_802BFB80.arraySize8[D_801651D0[gPlayersToRenderScreenId[i - 1]]
-                                 [gPlayersToRenderPlayerId[i - 1]]]
-                                 [gPlayersToRenderScreenId[i - 1] + screenOffset]
-                                 [gPlayersToRenderPlayerId[i - 1] + playerOffset]
-            .pixel_index_array,
-            gEncodedKartTexture[D_801651D0[gPlayersToRenderScreenId[i - 1]]
-                               [gPlayersToRenderPlayerId[i - 1]]]
-                               [gPlayersToRenderScreenId[i - 1] + screenOffset]
-                               [gPlayersToRenderPlayerId[i - 1] + playerOffset]
-            .unk_00
-        );
+        strcpy((char*) D_802BFB80
+                   .arraySize8[D_801651D0[gPlayersToRenderScreenId[i - 1]][gPlayersToRenderPlayerId[i - 1]]]
+                              [gPlayersToRenderScreenId[i - 1] + screenOffset]
+                              [gPlayersToRenderPlayerId[i - 1] + playerOffset]
+                   .pixel_index_array,
+               gEncodedKartTexture[D_801651D0[gPlayersToRenderScreenId[i - 1]][gPlayersToRenderPlayerId[i - 1]]]
+                                  [gPlayersToRenderScreenId[i - 1] + screenOffset]
+                                  [gPlayersToRenderPlayerId[i - 1] + playerOffset]
+                                      .unk_00);
     }
 
-    strcpy(
-        D_802BFB80.arraySize8[D_801651D0[gPlayersToRenderScreenId[gPlayersToRenderCount - 1]]
-                             [gPlayersToRenderPlayerId[gPlayersToRenderCount - 1]]]
-                             [gPlayersToRenderScreenId[gPlayersToRenderCount - 1] + screenOffset]
-                             [gPlayersToRenderPlayerId[gPlayersToRenderCount - 1] + playerOffset]
-        .pixel_index_array,
-        gEncodedKartTexture[D_801651D0[gPlayersToRenderScreenId[gPlayersToRenderCount - 1]]
-                           [gPlayersToRenderPlayerId[gPlayersToRenderCount - 1]]]
-                           [gPlayersToRenderScreenId[gPlayersToRenderCount - 1] + screenOffset]
-                           [gPlayersToRenderPlayerId[gPlayersToRenderCount - 1] + playerOffset]
-        .unk_00
-    );
+    strcpy((char*) D_802BFB80
+               .arraySize8[D_801651D0[gPlayersToRenderScreenId[gPlayersToRenderCount - 1]]
+                                     [gPlayersToRenderPlayerId[gPlayersToRenderCount - 1]]]
+                          [gPlayersToRenderScreenId[gPlayersToRenderCount - 1] + screenOffset]
+                          [gPlayersToRenderPlayerId[gPlayersToRenderCount - 1] + playerOffset]
+               .pixel_index_array,
+           gEncodedKartTexture[D_801651D0[gPlayersToRenderScreenId[gPlayersToRenderCount - 1]]
+                                         [gPlayersToRenderPlayerId[gPlayersToRenderCount - 1]]]
+                              [gPlayersToRenderScreenId[gPlayersToRenderCount - 1] + screenOffset]
+                              [gPlayersToRenderPlayerId[gPlayersToRenderCount - 1] + playerOffset]
+                                  .unk_00);
 }
 
 void try_rendering_player(Player* player, s8 playerId, s8 screenIdx) {
@@ -1247,7 +1243,7 @@ void render_player_shadow(Player* player, s8 playerId, s8 screenId) {
                         G_TX_NOLOD);
     func_8004B414(0, 0, 0, 0xFF);
     gDPSetRenderMode(gDisplayListHead++, G_RM_ZB_CLD_SURF, G_RM_ZB_CLD_SURF2);
-    gSPVertex(gDisplayListHead++, gKartShadowVertices, 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) gKartShadowVertices, 4, 0);
 
     gSPDisplayList(gDisplayListHead++, common_square_plain_render);
     gSPTexture(gDisplayListHead++, 1, 1, 0, G_TX_RENDERTILE, G_OFF);
@@ -1297,7 +1293,7 @@ void render_player_shadow_credits(Player* player, s8 playerId, s8 screenId) {
                         G_TX_NOLOD);
     func_8004B414(0, 0, 0, 0x000000D0);
     gDPSetRenderMode(gDisplayListHead++, G_RM_ZB_CLD_SURF, G_RM_ZB_CLD_SURF2);
-    gSPVertex(gDisplayListHead++, gKartShadowVertices, 4, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) gKartShadowVertices, 4, 0);
 
     gSPDisplayList(gDisplayListHead++, common_square_plain_render);
     gSPTexture(gDisplayListHead++, 1, 1, 0, G_TX_RENDERTILE, G_OFF);
@@ -1429,7 +1425,7 @@ void render_kart(Player* player, s8 playerId, s8 screenId, s8 flipOffset) {
     gDPLoadTextureBlock(gDisplayListHead++, sKartTexture, G_IM_FMT_CI, G_IM_SIZ_8b, 64, 64, 0,
                         G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
                         G_TX_NOLOD);
-    gSPVertex(gDisplayListHead++, &gPlayerVtx[playerId][flipOffset], 8, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) &gPlayerVtx[playerId][flipOffset], 8, 0);
     gSP2Triangles(gDisplayListHead++, 0, 1, 2, 0, 0, 2, 3, 0);
     gSP2Triangles(gDisplayListHead++, 4, 5, 6, 4, 4, 6, 7, 4);
     gSPTexture(gDisplayListHead++, 1, 1, 0, G_TX_RENDERTILE, G_OFF);
@@ -1501,7 +1497,7 @@ void render_ghost(Player* player, s8 playerId, s8 screenId, s8 flipOffset) {
     gDPLoadTextureBlock(gDisplayListHead++, sKartTexture, G_IM_FMT_CI, G_IM_SIZ_8b, 64, 64, 0,
                         G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
                         G_TX_NOLOD);
-    gSPVertex(gDisplayListHead++, &gPlayerVtx[playerId][flipOffset], 8, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) &gPlayerVtx[playerId][flipOffset], 8, 0);
     gSP2Triangles(gDisplayListHead++, 0, 1, 2, 0, 0, 2, 3, 0);
     gSP2Triangles(gDisplayListHead++, 4, 5, 6, 4, 4, 6, 7, 4);
     gSPTexture(gDisplayListHead++, 1, 1, 0, G_TX_RENDERTILE, G_OFF);
@@ -1544,7 +1540,7 @@ void func_80025DE8(Player* player, s8 playerId, s8 screenId, s8 flipOffset) {
     gDPLoadTextureBlock(gDisplayListHead++, sKartTexture, G_IM_FMT_CI, G_IM_SIZ_8b, 64, 64, 0,
                         G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
                         G_TX_NOLOD);
-    gSPVertex(gDisplayListHead++, &gPlayerVtx[playerId][flipOffset], 8, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) &gPlayerVtx[playerId][flipOffset], 8, 0);
     gSP2Triangles(gDisplayListHead++, 0, 1, 2, 0, 0, 2, 3, 0);
     gSP2Triangles(gDisplayListHead++, 4, 5, 6, 4, 4, 6, 7, 4);
     gSPTexture(gDisplayListHead++, 1, 1, 0, G_TX_RENDERTILE, G_OFF);
@@ -1589,7 +1585,7 @@ void render_player_ice_reflection(Player* player, s8 playerId, s8 screenId, s8 f
     gDPLoadTextureBlock(gDisplayListHead++, sKartTexture, G_IM_FMT_CI, G_IM_SIZ_8b, 64, 64, 0,
                         G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
                         G_TX_NOLOD);
-    gSPVertex(gDisplayListHead++, &gPlayerVtx[playerId][flipOffset], 8, 0);
+    gSPVertex(gDisplayListHead++, (uintptr_t) &gPlayerVtx[playerId][flipOffset], 8, 0);
     gSP2Triangles(gDisplayListHead++, 0, 1, 2, 0, 0, 2, 3, 0);
     gSP2Triangles(gDisplayListHead++, 4, 5, 6, 4, 4, 6, 7, 4);
     gSPTexture(gDisplayListHead++, 1, 1, 0, G_TX_RENDERTILE, G_OFF);
diff --git a/src/replays.c b/src/replays.c
index 2ba389f95..66b664744 100644
--- a/src/replays.c
+++ b/src/replays.c
@@ -130,9 +130,10 @@ s32 func_800051C4(void) {
 
     if (sReplayGhostBufferSize != 0) {
         // func_80040174 in mio0_decode.s
-        func_80040174((void*) sReplayGhostBuffer, (sReplayGhostBufferSize * 4) + 0x20, (s32) sReplayGhostEncoded);
-        phi_v0 =
-            mio0encode((s32) sReplayGhostEncoded, (sReplayGhostBufferSize * 4) + 0x20, (s32) gReplayGhostCompressed);
+        func_80040174((void*) sReplayGhostBuffer, (sReplayGhostBufferSize * 4) + 0x20,
+                      (s32) (uintptr_t) sReplayGhostEncoded);
+        phi_v0 = mio0encode((uintptr_t) sReplayGhostEncoded, (sReplayGhostBufferSize * 4) + 0x20,
+                            (uintptr_t) gReplayGhostCompressed);
         return phi_v0 + 0x1e;
     }
     // Empty buffer used to fall off the end; report zero encoded size (the
@@ -450,7 +451,7 @@ void save_player_replay(void) {
     it says "these inputs were played for __ frames" */
     prevInputs = prevInputsWCounter & REPLAY_CLEAR_FRAME_COUNTER;
     // first frame of inputs
-    if ((*sPlayerInputs) == -1) {
+    if ((*sPlayerInputs) == (u32) -1) {
 
         sPlayerInputs[sPlayerInputIdx] = inputs;
 
diff --git a/src/replays.h b/src/replays.h
index 1a632932f..24de2fba9 100644
--- a/src/replays.h
+++ b/src/replays.h
@@ -23,7 +23,7 @@ void replays_loop(void);
 
 // mi0decode
 
-extern s32 mio0encode(s32 input, s32, s32);
+extern s32 mio0encode(uintptr_t input, s32, uintptr_t);
 
 extern StaffGhost* D_80162DC4;
 extern s32 D_80162DC8;
diff --git a/src/save.c b/src/save.c
index cadc00393..55f43392b 100644
--- a/src/save.c
+++ b/src/save.c
@@ -120,7 +120,7 @@ u8 checksum_time_trial_records(s32 trackIdx) {
 
 u8 compute_save_data_checksum_1(void) {
     u8* grandPrixPoints = (u8*) &gSaveData.main.saveInfo.grandPrixPoints;
-    s32 i;
+    size_t i;
     s32 crc = 0;
 
     for (i = 0; i < sizeof(SaveInfo); i++) {
@@ -532,7 +532,7 @@ void update_save_data_backup(void) {
 
 u8 compute_save_data_checksum_backup_1(void) {
     u8* backupGrandPrixPoints = gSaveData.backup.saveInfo.grandPrixPoints;
-    s32 i;
+    size_t i;
     s32 crc = 0;
 
     for (i = 0; i < sizeof(SaveInfo); i++) {
@@ -837,7 +837,7 @@ s32 func_800B63F0(s32 arg0) {
     func_80005AE8(gPlayerThree);
 
     phi_s3 = 0;
-    if (((GetCupIndex() * 4) + GetCupCursorPosition()) != D_8018EE10[arg0].trackIndex) {
+    if ((s8) ((GetCupIndex() * 4) + GetCupCursorPosition()) != D_8018EE10[arg0].trackIndex) {
         phi_s3 = 2;
     } else if (D_80162DFC != D_8018EE10[arg0].unk_00) {
         phi_s3 = 3;
@@ -864,7 +864,7 @@ s32 func_800B63F0(s32 arg0) {
 }
 
 s32 func_800B64EC(s32 arg0) {
-    s32 temp_s0;
+    UNUSED s32 temp_s0;
     s32 temp_v0;
 
     if ((arg0 != 0) && (arg0 != 1)) {
@@ -979,7 +979,7 @@ GLOBAL_ASM("asm/non_matchings/save/func_800B68F4.s")
 #endif
 
 s32 func_800B69BC(s32 arg0) {
-    s32 i;
+    size_t i;
     struct_8018EE10_entry* plz = &D_8018EE10[arg0];
 
     plz->ghostDataSaved = false;
diff --git a/src/spawn_players.c b/src/spawn_players.c
index 6064f5181..ba2175154 100644
--- a/src/spawn_players.c
+++ b/src/spawn_players.c
@@ -77,7 +77,7 @@ s16 D_80165582;
 
 // arg4 is height? Or something like that?
 void spawn_player(Player* player, s8 playerIndex, f32 startingRow, f32 startingColumn, f32 arg4, f32 arg5,
-                  u16 characterId, s16 playerType) {
+                  u16 characterId, s32 playerType) {
     f32 ret;
     s8 idx;
 
@@ -176,7 +176,7 @@ void spawn_player(Player* player, s8 playerIndex, f32 startingRow, f32 startingC
     player->unk_090 = 0.0f;
     player->speed = 0.0f;
     player->unk_074 = 0.0f;
-    player->type = playerType;
+    player->type = (s16) playerType;
     player->lakituProps = 0;
     player->oobProps = 0;
     player->unk_10C = 0;
@@ -543,41 +543,40 @@ void spawn_players_gp_one_player(f32* arg0, f32* arg1, f32 arg2) {
 
     D_8016556E = 0;
     if (gDemoMode == 1) {
-        spawn_player(gPlayerOne, 0, arg0[D_80165270[0]], arg1[D_80165270[0]], arg2, 32768.0f,
-                     gCharacterSelections[0], PLAYER_HUMAN_AND_CPU);
+        spawn_player(gPlayerOne, 0, arg0[D_80165270[0]], arg1[D_80165270[0]], arg2, 32768.0f, gCharacterSelections[0],
+                     (PLAYER_HUMAN_AND_CPU));
         spawn_player(gPlayerTwo, 1, arg0[D_80165270[1]], arg1[D_80165270[1]], arg2, 32768.0f, chooseCPUPlayers[0],
-                     PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                     (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
         spawn_player(gPlayerThree, 2, arg0[D_80165270[2]], arg1[D_80165270[2]], arg2, 32768.0f, chooseCPUPlayers[1],
-                     PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                     (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
         spawn_player(gPlayerFour, 3, arg0[D_80165270[3]], arg1[D_80165270[3]], arg2, 32768.0f, chooseCPUPlayers[2],
-                     PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                     (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
         spawn_player(gPlayerFive, 4, arg0[D_80165270[4]], arg1[D_80165270[4]], arg2, 32768.0f, chooseCPUPlayers[3],
-                     PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                     (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
         spawn_player(gPlayerSix, 5, arg0[D_80165270[5]], arg1[D_80165270[5]], arg2, 32768.0f, chooseCPUPlayers[4],
-                     PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                     (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
         spawn_player(gPlayerSeven, 6, arg0[D_80165270[6]], arg1[D_80165270[6]], arg2, 32768.0f, chooseCPUPlayers[5],
-                     PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                     (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
         spawn_player(gPlayerEight, 7, arg0[D_80165270[7]], arg1[D_80165270[7]], arg2, 32768.0f, chooseCPUPlayers[6],
-                     PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                     (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
         D_80164A28 = 0;
     } else {
         spawn_player(gPlayerOne, 0, arg0[D_80165270[0]], arg1[D_80165270[0]] + 250.0f, arg2, 32768.0f,
-                        gCharacterSelections[0],
-                        PLAYER_EXISTS | PLAYER_STAGING | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     gCharacterSelections[0], (PLAYER_EXISTS | PLAYER_STAGING | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
         spawn_player(gPlayerTwo, 1, arg0[D_80165270[1]], arg1[D_80165270[1]] + 250.0f, arg2, 32768.0f,
-                        chooseCPUPlayers[0], PLAYER_EXISTS | PLAYER_STAGING | PLAYER_START_SEQUENCE | PLAYER_CPU);
+                     chooseCPUPlayers[0], (PLAYER_EXISTS | PLAYER_STAGING | PLAYER_START_SEQUENCE | PLAYER_CPU));
         spawn_player(gPlayerThree, 2, arg0[D_80165270[3]], arg1[D_80165270[2]] + 250.0f, arg2, 32768.0f,
-                        chooseCPUPlayers[1], PLAYER_EXISTS | PLAYER_STAGING | PLAYER_START_SEQUENCE | PLAYER_CPU);
+                     chooseCPUPlayers[1], (PLAYER_EXISTS | PLAYER_STAGING | PLAYER_START_SEQUENCE | PLAYER_CPU));
         spawn_player(gPlayerFour, 3, arg0[D_80165270[2]], arg1[D_80165270[3]] + 250.0f, arg2, 32768.0f,
-                        chooseCPUPlayers[2], PLAYER_EXISTS | PLAYER_STAGING | PLAYER_START_SEQUENCE | PLAYER_CPU);
+                     chooseCPUPlayers[2], (PLAYER_EXISTS | PLAYER_STAGING | PLAYER_START_SEQUENCE | PLAYER_CPU));
         spawn_player(gPlayerFive, 4, arg0[D_80165270[5]], arg1[D_80165270[4]] + 250.0f, arg2, 32768.0f,
-                        chooseCPUPlayers[3], PLAYER_EXISTS | PLAYER_STAGING | PLAYER_START_SEQUENCE | PLAYER_CPU);
+                     chooseCPUPlayers[3], (PLAYER_EXISTS | PLAYER_STAGING | PLAYER_START_SEQUENCE | PLAYER_CPU));
         spawn_player(gPlayerSix, 5, arg0[D_80165270[4]], arg1[D_80165270[5]] + 250.0f, arg2, 32768.0f,
-                        chooseCPUPlayers[4], PLAYER_EXISTS | PLAYER_STAGING | PLAYER_START_SEQUENCE | PLAYER_CPU);
+                     chooseCPUPlayers[4], (PLAYER_EXISTS | PLAYER_STAGING | PLAYER_START_SEQUENCE | PLAYER_CPU));
         spawn_player(gPlayerSeven, 6, arg0[D_80165270[7]], arg1[D_80165270[6]] + 250.0f, arg2, 32768.0f,
-                        chooseCPUPlayers[5], PLAYER_EXISTS | PLAYER_STAGING | PLAYER_START_SEQUENCE | PLAYER_CPU);
+                     chooseCPUPlayers[5], (PLAYER_EXISTS | PLAYER_STAGING | PLAYER_START_SEQUENCE | PLAYER_CPU));
         spawn_player(gPlayerEight, 7, arg0[D_80165270[6]], arg1[D_80165270[7]] + 250.0f, arg2, 32768.0f,
-                        chooseCPUPlayers[6], PLAYER_EXISTS | PLAYER_STAGING | PLAYER_START_SEQUENCE | PLAYER_CPU);
+                     chooseCPUPlayers[6], (PLAYER_EXISTS | PLAYER_STAGING | PLAYER_START_SEQUENCE | PLAYER_CPU));
         D_80164A28 = 1;
     }
     func_80039AE4();
@@ -595,42 +594,41 @@ void spawn_players_versus_one_player(f32* arg0, f32* arg1, f32 arg2) {
     spawn_player(gPlayerEight, 7, arg0[6], arg1[6], arg2, 32768.0f, gCharacterSelections[0],
                  PLAYER_START_SEQUENCE | PLAYER_CPU);
     if (gDemoMode == 1) {
-        spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, 32768.0f, gCharacterSelections[0],
-                     PLAYER_HUMAN_AND_CPU);
+        spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, 32768.0f, gCharacterSelections[0], (PLAYER_HUMAN_AND_CPU));
         spawn_player(gPlayerTwo, 1, arg0[0], arg1[0], arg2, 32768.0f, gCharacterSelections[0],
                      PLAYER_START_SEQUENCE | PLAYER_CPU);
         spawn_player(gPlayerThree, 2, arg0[1], arg1[1], arg2, 32768.0f, gCharacterSelections[0],
                      PLAYER_START_SEQUENCE | PLAYER_CPU);
     } else if (D_8015F890 != 1) {
         spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, 32768.0f, gCharacterSelections[0],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
         if (bPlayerGhostDisabled == 0) {
             spawn_player(gPlayerTwo, 1, arg0[0], arg1[0], arg2, 32768.0f, D_80162DE0,
-                         PLAYER_EXISTS | PLAYER_HUMAN | PLAYER_START_SEQUENCE | PLAYER_INVISIBLE_OR_BOMB);
+                         (PLAYER_EXISTS | PLAYER_HUMAN | PLAYER_START_SEQUENCE | PLAYER_INVISIBLE_OR_BOMB));
         } else {
             spawn_player(gPlayerTwo, 1, arg0[0], arg1[0], arg2, 32768.0f, gCharacterSelections[0],
                          PLAYER_START_SEQUENCE | PLAYER_CPU);
         }
         if (bCourseGhostDisabled == 0) {
             spawn_player(gPlayerThree, 2, arg0[0], arg1[0], arg2, 32768.0f, D_80162DE4,
-                         PLAYER_EXISTS | PLAYER_HUMAN | PLAYER_START_SEQUENCE | PLAYER_INVISIBLE_OR_BOMB);
+                         (PLAYER_EXISTS | PLAYER_HUMAN | PLAYER_START_SEQUENCE | PLAYER_INVISIBLE_OR_BOMB));
         } else {
             spawn_player(gPlayerThree, 2, arg0[1], arg1[1], arg2, 32768.0f, gCharacterSelections[0],
                          PLAYER_START_SEQUENCE | PLAYER_CPU);
         }
     } else {
         spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, 32768.0f, D_80162DE8,
-                     PLAYER_EXISTS | PLAYER_HUMAN | PLAYER_START_SEQUENCE | PLAYER_INVISIBLE_OR_BOMB);
+                     (PLAYER_EXISTS | PLAYER_HUMAN | PLAYER_START_SEQUENCE | PLAYER_INVISIBLE_OR_BOMB));
         if (D_80162DD8 == 0) {
             spawn_player(gPlayerTwo, 1, arg0[0], arg1[0], arg2, 32768.0f, D_80162DE0,
-                         PLAYER_EXISTS | PLAYER_HUMAN | PLAYER_START_SEQUENCE | PLAYER_INVISIBLE_OR_BOMB);
+                         (PLAYER_EXISTS | PLAYER_HUMAN | PLAYER_START_SEQUENCE | PLAYER_INVISIBLE_OR_BOMB));
         } else {
             spawn_player(gPlayerTwo, 1, arg0[0], arg1[0], arg2, 32768.0f, gCharacterSelections[0],
                          PLAYER_START_SEQUENCE | PLAYER_CPU);
         }
         if (bCourseGhostDisabled == 0) {
             spawn_player(gPlayerThree, 2, arg0[0], arg1[0], arg2, 32768.0f, D_80162DE4,
-                         PLAYER_EXISTS | PLAYER_HUMAN | PLAYER_START_SEQUENCE | PLAYER_INVISIBLE_OR_BOMB);
+                         (PLAYER_EXISTS | PLAYER_HUMAN | PLAYER_START_SEQUENCE | PLAYER_INVISIBLE_OR_BOMB));
         } else {
             spawn_player(gPlayerThree, 2, arg0[1], arg1[1], arg2, 32768.0f, gCharacterSelections[0],
                          PLAYER_START_SEQUENCE | PLAYER_CPU);
@@ -670,31 +668,31 @@ void spawn_players_gp_two_player(f32* arg0, f32* arg1, f32 arg2) {
     }
 
     spawn_player(gPlayerThree, 2, arg0[D_80165270[2]], arg1[D_80165270[2]], arg2, 32768.0f, chooseCPUPlayers[0],
-                 PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                 (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
     spawn_player(gPlayerFour, 3, arg0[D_80165270[3]], arg1[D_80165270[3]], arg2, 32768.0f, chooseCPUPlayers[1],
-                 PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                 (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
     spawn_player(gPlayerFive, 4, arg0[D_80165270[4]], arg1[D_80165270[4]], arg2, 32768.0f, chooseCPUPlayers[2],
-                 PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                 (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
     spawn_player(gPlayerSix, 5, arg0[D_80165270[5]], arg1[D_80165270[5]], arg2, 32768.0f, chooseCPUPlayers[3],
-                 PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                 (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
     spawn_player(gPlayerSeven, 6, arg0[D_80165270[6]], arg1[D_80165270[6]], arg2, 32768.0f, chooseCPUPlayers[4],
-                 PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                 (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
     spawn_player(gPlayerEight, 7, arg0[D_80165270[7]], arg1[D_80165270[7]], arg2, 32768.0f, chooseCPUPlayers[5],
-                 PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                 (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
 
     if (gDemoMode == 1) {
-        spawn_player(gPlayerOne, 0, arg0[D_80165270[0]], arg1[D_80165270[0]], arg2, 32768.0f,
-                     gCharacterSelections[0], PLAYER_HUMAN_AND_CPU);
+        spawn_player(gPlayerOne, 0, arg0[D_80165270[0]], arg1[D_80165270[0]], arg2, 32768.0f, gCharacterSelections[0],
+                     (PLAYER_HUMAN_AND_CPU));
     } else {
-        spawn_player(gPlayerOne, 0, arg0[D_80165270[0]], arg1[D_80165270[0]], arg2, 32768.0f,
-                     gCharacterSelections[0], PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+        spawn_player(gPlayerOne, 0, arg0[D_80165270[0]], arg1[D_80165270[0]], arg2, 32768.0f, gCharacterSelections[0],
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
     }
     if (gDemoMode == 1) {
         spawn_player(gPlayerTwo, 1, arg0[D_80165270[1]], arg1[D_80165270[1]], arg2, 32768.0f, gCharacterSelections[1],
-                     PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                     (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
     } else {
         spawn_player(gPlayerTwo, 1, arg0[D_80165270[1]], arg1[D_80165270[1]], arg2, 32768.0f, gCharacterSelections[1],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
     }
 
     D_80164A28 = 0;
@@ -715,17 +713,16 @@ void spawn_players_versus_two_player(f32* arg0, f32* arg1, f32 arg2) {
     spawn_player(gPlayerEight, 7, arg0[6], arg1[6], arg2, 32768.0f, gCharacterSelections[0],
                  PLAYER_START_SEQUENCE | PLAYER_CPU);
     if (gDemoMode == 1) {
-        spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, 32768.0f, gCharacterSelections[0],
-                     PLAYER_HUMAN_AND_CPU);
+        spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, 32768.0f, gCharacterSelections[0], (PLAYER_HUMAN_AND_CPU));
     } else {
         spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, 32768.0f, gCharacterSelections[0],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
     }
     if (gDemoMode == 1) {
-        spawn_player(gPlayerTwo, 1, arg0[1], arg1[1], arg2, 32768.0f, gCharacterSelections[1], PLAYER_HUMAN_AND_CPU);
+        spawn_player(gPlayerTwo, 1, arg0[1], arg1[1], arg2, 32768.0f, gCharacterSelections[1], (PLAYER_HUMAN_AND_CPU));
     } else {
         spawn_player(gPlayerTwo, 1, arg0[1], arg1[1], arg2, 32768.0f, gCharacterSelections[1],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
     }
     D_80164A28 = 0;
     func_80039AE4();
@@ -734,14 +731,14 @@ void spawn_players_versus_two_player(f32* arg0, f32* arg1, f32 arg2) {
 void spawn_players_2p_battle(f32* arg0, f32* arg1, f32 arg2) {
     if (IsBigDonut()) {
         spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, -16384.0f, gCharacterSelections[0],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
         spawn_player(gPlayerTwo, 1, arg0[1], arg1[1], arg2, 16384.0f, gCharacterSelections[1],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
     } else {
         spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, 32768.0f, gCharacterSelections[0],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
         spawn_player(gPlayerTwo, 1, arg0[1], arg1[1], arg2, 0.0f, gCharacterSelections[1],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
     }
     spawn_player(gPlayerThree, 2, arg0[2], arg1[2], arg2, 32768.0f, gCharacterSelections[2],
                  PLAYER_START_SEQUENCE | PLAYER_HUMAN);
@@ -757,15 +754,16 @@ void spawn_players_2p_battle(f32* arg0, f32* arg1, f32 arg2) {
 
 void func_8003B318(f32* arg0, f32* arg1, f32 arg2) {
     spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, 32768.0f, gCharacterSelections[0],
-                 PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                 (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
     spawn_player(gPlayerTwo, 1, arg0[1], arg1[1], arg2, 32768.0f, gCharacterSelections[1],
-                 PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                 (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
     spawn_player(gPlayerThree, 2, arg0[2], arg1[2], arg2, 32768.0f, gCharacterSelections[2],
-                 PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                 (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
     if (gDemoMode == 1) {
-        spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, 32768.0f, gCharacterSelections[0], PLAYER_HUMAN_AND_CPU);
-        spawn_player(gPlayerTwo, 1, arg0[1], arg1[1], arg2, 32768.0f, gCharacterSelections[1], PLAYER_HUMAN_AND_CPU);
-        spawn_player(gPlayerThree, 2, arg0[2], arg1[2], arg2, 32768.0f, gCharacterSelections[2], PLAYER_HUMAN_AND_CPU);
+        spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, 32768.0f, gCharacterSelections[0], (PLAYER_HUMAN_AND_CPU));
+        spawn_player(gPlayerTwo, 1, arg0[1], arg1[1], arg2, 32768.0f, gCharacterSelections[1], (PLAYER_HUMAN_AND_CPU));
+        spawn_player(gPlayerThree, 2, arg0[2], arg1[2], arg2, 32768.0f, gCharacterSelections[2],
+                     (PLAYER_HUMAN_AND_CPU));
     }
 
     spawn_player(gPlayerFour, 3, arg0[3], arg1[3], arg2, 32768.0f, 3, PLAYER_START_SEQUENCE | PLAYER_CPU);
@@ -780,18 +778,18 @@ void func_8003B318(f32* arg0, f32* arg1, f32 arg2) {
 void spawn_players_3p_battle(f32* arg0, f32* arg1, f32 arg2) {
     if (IsBigDonut()) {
         spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, -16384.0f, gCharacterSelections[0],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
         spawn_player(gPlayerTwo, 1, arg0[1], arg1[1], arg2, 16384.0f, gCharacterSelections[1],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
         spawn_player(gPlayerThree, 2, arg0[2], arg1[2], arg2, 0.0f, gCharacterSelections[2],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
     } else {
         spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, 32768.0f, gCharacterSelections[0],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
         spawn_player(gPlayerTwo, 1, arg0[1], arg1[1], arg2, 0.0f, gCharacterSelections[1],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
         spawn_player(gPlayerThree, 2, arg0[2], arg1[2], arg2, -16384.0f, gCharacterSelections[2],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
     }
     spawn_player(gPlayerFour, 3, arg0[3], arg1[3], arg2, 32768.0f, 3, PLAYER_START_SEQUENCE | PLAYER_CPU);
     spawn_player(gPlayerFive, 4, arg0[4], arg1[4], arg2, 32768.0f, 4, PLAYER_START_SEQUENCE | PLAYER_CPU);
@@ -804,18 +802,19 @@ void spawn_players_3p_battle(f32* arg0, f32* arg1, f32 arg2) {
 
 void func_8003B870(f32* arg0, f32* arg1, f32 arg2) {
     spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, 32768.0f, gCharacterSelections[0],
-                 PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                 (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
     spawn_player(gPlayerTwo, 1, arg0[1], arg1[1], arg2, 32768.0f, gCharacterSelections[1],
-                 PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                 (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
     spawn_player(gPlayerThree, 2, arg0[2], arg1[2], arg2, 32768.0f, gCharacterSelections[2],
-                 PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                 (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
     spawn_player(gPlayerFour, 3, arg0[3], arg1[3], arg2, 32768.0f, gCharacterSelections[3],
-                 PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                 (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
     if (gDemoMode == 1) {
-        spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, 32768.0f, gCharacterSelections[0], PLAYER_HUMAN_AND_CPU);
-        spawn_player(gPlayerTwo, 1, arg0[1], arg1[1], arg2, 32768.0f, gCharacterSelections[1], PLAYER_HUMAN_AND_CPU);
-        spawn_player(gPlayerThree, 2, arg0[2], arg1[2], arg2, 32768.0f, gCharacterSelections[2], PLAYER_HUMAN_AND_CPU);
-        spawn_player(gPlayerFour, 3, arg0[3], arg1[3], arg2, 32768.0f, gCharacterSelections[3], PLAYER_HUMAN_AND_CPU);
+        spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, 32768.0f, gCharacterSelections[0], (PLAYER_HUMAN_AND_CPU));
+        spawn_player(gPlayerTwo, 1, arg0[1], arg1[1], arg2, 32768.0f, gCharacterSelections[1], (PLAYER_HUMAN_AND_CPU));
+        spawn_player(gPlayerThree, 2, arg0[2], arg1[2], arg2, 32768.0f, gCharacterSelections[2],
+                     (PLAYER_HUMAN_AND_CPU));
+        spawn_player(gPlayerFour, 3, arg0[3], arg1[3], arg2, 32768.0f, gCharacterSelections[3], (PLAYER_HUMAN_AND_CPU));
     }
     spawn_player(gPlayerFive, 4, arg0[4], arg1[4], arg2, 32768.0f, 4, PLAYER_START_SEQUENCE | PLAYER_CPU);
     spawn_player(gPlayerSix, 5, arg0[5], arg1[5], arg2, 32768.0f, 5, PLAYER_START_SEQUENCE | PLAYER_CPU);
@@ -828,22 +827,22 @@ void func_8003B870(f32* arg0, f32* arg1, f32 arg2) {
 void spawn_players_4p_battle(f32* arg0, f32* arg1, f32 arg2) {
     if (IsBigDonut()) {
         spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, -16384.0f, gCharacterSelections[0],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
         spawn_player(gPlayerTwo, 1, arg0[1], arg1[1], arg2, 16384.0f, gCharacterSelections[1],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
         spawn_player(gPlayerThree, 2, arg0[2], arg1[2], arg2, 0.0f, gCharacterSelections[2],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
         spawn_player(gPlayerFour, 3, arg0[3], arg1[3], arg2, 32768.0f, gCharacterSelections[3],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
     } else {
         spawn_player(gPlayerOne, 0, arg0[0], arg1[0], arg2, 32768.0f, gCharacterSelections[0],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
         spawn_player(gPlayerTwo, 1, arg0[1], arg1[1], arg2, 0.0f, gCharacterSelections[1],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
         spawn_player(gPlayerThree, 2, arg0[2], arg1[2], arg2, -16384.0f, gCharacterSelections[2],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
         spawn_player(gPlayerFour, 3, arg0[3], arg1[3], arg2, 16384.0f, gCharacterSelections[3],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
     }
     spawn_player(gPlayerFive, 4, arg0[4], arg1[4], arg2, 32768.0f, 4, PLAYER_START_SEQUENCE | PLAYER_CPU);
     spawn_player(gPlayerSix, 5, arg0[5], arg1[5], arg2, 32768.0f, 5, PLAYER_START_SEQUENCE | PLAYER_CPU);
@@ -855,17 +854,17 @@ void spawn_players_4p_battle(f32* arg0, f32* arg1, f32 arg2) {
 
 void func_8003BE30(void) {
     spawn_player(gPlayerOne, 0, -2770.774f, -345.187f, -34.6f, 0.0f, gCharacterIdByGPOverallRank[0],
-                 PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                 (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
     spawn_player(gPlayerTwo, 1, -3691.506f, -6.822f, -6.95f, 36400.0f, gCharacterIdByGPOverallRank[1],
-                 PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                 (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
     spawn_player(gPlayerThree, 2, -3475.028f, -998.485f, -8.059f, 45500.0f, gCharacterIdByGPOverallRank[2],
-                 PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                 (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
     if (D_802874D8.unk1D >= 3) {
         spawn_player(gPlayerFour, 3, -3025.772f, 110.039f, -23.224f, 28210.0f, D_802874D8.unk1E,
-                     PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                     (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
     } else {
         spawn_player(gPlayerFour, 3, -3025.772f, 110.039f, -23.224f, 28210.0f, gCharacterIdByGPOverallRank[3],
-                     PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                     (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
     }
     spawn_player(gPlayerFive, 4, -2770.774f, -345.187f, -34.6f, 0.0f, 0, 0x7000);
     spawn_player(gPlayerSix, 5, -3691.506f, -6.822f, -6.95f, 36400.0f, 0, 0x7000);
@@ -1130,21 +1129,21 @@ void spawn_and_set_player_spawns(void) {
         D_80165230[6] = 150.0f;
         D_80165230[7] = 170.0f;
         spawn_player(gPlayerOne, 0, D_80165210[0], D_80165230[0], sp5A, 32768.0f, gCharacterSelections[0],
-                     PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN);
+                     (PLAYER_EXISTS | PLAYER_START_SEQUENCE | PLAYER_HUMAN));
         spawn_player(gPlayerTwo, 1, D_80165210[1], D_80165230[1], sp5A, 32768.0f, 1,
-                     PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                     (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
         spawn_player(gPlayerThree, 2, D_80165210[2], D_80165230[2], sp5A, 32768.0f, 2,
-                     PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                     (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
         spawn_player(gPlayerFour, 3, D_80165210[3], D_80165230[3], sp5A, 32768.0f, 3,
-                     PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                     (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
         spawn_player(gPlayerFive, 4, D_80165210[4], D_80165230[4], sp5A, 32768.0f, 4,
-                     PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                     (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
         spawn_player(gPlayerSix, 5, D_80165210[5], D_80165230[5], sp5A, 32768.0f, 5,
-                     PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                     (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
         spawn_player(gPlayerSeven, 6, D_80165210[6], D_80165230[6], sp5A, 32768.0f, 6,
-                     PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                     (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
         spawn_player(gPlayerEight, 7, D_80165210[7], D_80165230[7], sp5A, 32768.0f, 7,
-                     PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE);
+                     (PLAYER_EXISTS | PLAYER_CPU | PLAYER_START_SEQUENCE));
         D_80164A28 = 0;
     }
 
diff --git a/src/spawn_players.h b/src/spawn_players.h
index 665a369c4..678afa6a1 100644
--- a/src/spawn_players.h
+++ b/src/spawn_players.h
@@ -6,7 +6,7 @@
 
 /* Function Prototypes */
 /** @cond */
-void spawn_player(Player*, s8, f32, f32, f32, f32, u16, s16);
+void spawn_player(Player*, s8, f32, f32, f32, f32, u16, s32);
 void func_80039AE4(void);
 void func_80039DA4(void);
 void spawn_and_set_player_spawns(void);
diff --git a/src/stubs.c b/src/stubs.c
index 93fbe1099..fbc35b73d 100644
--- a/src/stubs.c
+++ b/src/stubs.c
@@ -1,10 +1,17 @@
 #include <libultraship.h>
+#include <macros.h>
 #include <libultraship/libultra.h>
 #include <string.h>
 #include <stdio.h>
 #include <stubs.h>
 #include "save.h"
 
+// Everything here is a stub, so unused parameters are the norm; silence the
+// warning once for the file instead of tagging every signature.
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
 struct state_pak {
     OSPfsState state;
     FILE* file;
@@ -33,10 +40,9 @@ s32 osAiSetFrequency(u32 freq) {
 }
 
 void mio0decode(u8* arg0, u8* arg1) {
-    arg1 = arg0;
 }
 
-s32 mio0encode(s32 input, s32 arg1, s32 arg2) {
+s32 mio0encode(uintptr_t input, s32 arg1, uintptr_t arg2) {
     return 1;
 }
 
diff --git a/src/update_objects.c b/src/update_objects.c
index 697072351..34b32d5fe 100644
--- a/src/update_objects.c
+++ b/src/update_objects.c
@@ -78,39 +78,39 @@ Vtx D_800E44B0[] = {
     { { { -24, 20, 0 }, 0, { 3008, 2496 }, { 0xFF, 0xFF, 0xFF, 0xFF } } },
 };
 
-u16* gItemWindowTLUTs[] = { common_tlut_item_window_none,
-                            common_tlut_item_window_banana,
-                            common_tlut_item_window_banana_bunch,
-                            common_tlut_item_window_green_shell,
-                            common_tlut_item_window_triple_green_shell,
-                            common_tlut_item_window_red_shell,
-                            common_tlut_item_window_triple_red_shell,
-                            common_tlut_item_window_blue_shell,
-                            common_tlut_item_window_thunder_bolt,
-                            common_tlut_item_window_fake_item_box,
-                            common_tlut_item_window_star,
-                            common_tlut_item_window_boo,
-                            common_tlut_item_window_mushroom,
-                            common_tlut_item_window_double_mushroom,
-                            common_tlut_item_window_triple_mushroom,
-                            common_tlut_item_window_super_mushroom };
-
-u8* gItemWindowTextures[] = { common_texture_item_window_none,
-                              common_texture_item_window_banana,
-                              common_texture_item_window_banana_bunch,
-                              common_texture_item_window_green_shell,
-                              common_texture_item_window_triple_green_shell,
-                              common_texture_item_window_red_shell,
-                              common_texture_item_window_triple_red_shell,
-                              common_texture_item_window_blue_shell,
-                              common_texture_item_window_thunder_bolt,
-                              common_texture_item_window_fake_item_box,
-                              common_texture_item_window_star,
-                              common_texture_item_window_boo,
-                              common_texture_item_window_mushroom,
-                              common_texture_item_window_double_mushroom,
-                              common_texture_item_window_triple_mushroom,
-                              common_texture_item_window_super_mushroom };
+const char* gItemWindowTLUTs[] = { common_tlut_item_window_none,
+                                   common_tlut_item_window_banana,
+                                   common_tlut_item_window_banana_bunch,
+                                   common_tlut_item_window_green_shell,
+                                   common_tlut_item_window_triple_green_shell,
+                                   common_tlut_item_window_red_shell,
+                                   common_tlut_item_window_triple_red_shell,
+                                   common_tlut_item_window_blue_shell,
+                                   common_tlut_item_window_thunder_bolt,
+                                   common_tlut_item_window_fake_item_box,
+                                   common_tlut_item_window_star,
+                                   common_tlut_item_window_boo,
+                                   common_tlut_item_window_mushroom,
+                                   common_tlut_item_window_double_mushroom,
+                                   common_tlut_item_window_triple_mushroom,
+                                   common_tlut_item_window_super_mushroom };
+
+const char* gItemWindowTextures[] = { common_texture_item_window_none,
+                                      common_texture_item_window_banana,
+                                      common_texture_item_window_banana_bunch,
+                                      common_texture_item_window_green_shell,
+                                      common_texture_item_window_triple_green_shell,
+                                      common_texture_item_window_red_shell,
+                                      common_texture_item_window_triple_red_shell,
+                                      common_texture_item_window_blue_shell,
+                                      common_texture_item_window_thunder_bolt,
+                                      common_texture_item_window_fake_item_box,
+                                      common_texture_item_window_star,
+                                      common_texture_item_window_boo,
+                                      common_texture_item_window_mushroom,
+                                      common_texture_item_window_double_mushroom,
+                                      common_texture_item_window_triple_mushroom,
+                                      common_texture_item_window_super_mushroom };
 
 u16* gHudLapTextures[] = { common_texture_hud_lap_1_on_3, common_texture_hud_lap_2_on_3,
                            common_texture_hud_lap_3_on_3 };
@@ -119,10 +119,10 @@ u16* gPortraitTLUTs[] = { common_tlut_portrait_mario, common_tlut_portrait_luigi
                           common_tlut_portrait_toad,  common_tlut_portrait_donkey_kong, common_tlut_portrait_wario,
                           common_tlut_portrait_peach, common_tlut_portrait_bowser };
 
-u8* gPortraitTextures[] = { common_texture_portrait_mario,       common_texture_portrait_luigi,
-                            common_texture_portrait_yoshi,       common_texture_portrait_toad,
-                            common_texture_portrait_donkey_kong, common_texture_portrait_wario,
-                            common_texture_portrait_peach,       common_texture_portrait_bowser };
+u8* gPortraitTextures[] = { (u8*) common_texture_portrait_mario,       (u8*) common_texture_portrait_luigi,
+                            (u8*) common_texture_portrait_yoshi,       (u8*) common_texture_portrait_toad,
+                            (u8*) common_texture_portrait_donkey_kong, (u8*) common_texture_portrait_wario,
+                            (u8*) common_texture_portrait_peach,       (u8*) common_texture_portrait_bowser };
 
 s32 find_unused_obj_index(s32* arg0) {
     s32 temp_v0;
@@ -746,7 +746,7 @@ void init_texture_object(s32 objectIndex, u8* texture, const char** arg2, u8 arg
 }
 
 UNUSED void func_8007348C(s32 objectIndex, u8* arg1, u8 arg2, u8 arg3, Vtx* arg4) {
-    gObjectList[objectIndex].activeTLUT = arg1;
+    gObjectList[objectIndex].activeTLUT = (const char*) arg1;
     gObjectList[objectIndex].tlutList = arg1;
     gObjectList[objectIndex].textureWidth = arg2;
     gObjectList[objectIndex].textureHeight = arg3;
@@ -760,17 +760,14 @@ UNUSED void func_800734D4() {
 }
 
 void update_neon_texture(s32 objectIndex) {
-    // I have no idea why this typecast works
-    gObjectList[objectIndex].activeTLUT =
-        (u8*) ((u32*) gObjectList[objectIndex].tlutList + (gObjectList[objectIndex].textureListIndex * 128));
     int idx = gObjectList[objectIndex].textureListIndex;
-    char* texture = gObjectList[objectIndex].textureList[idx];
-    gObjectList[objectIndex].activeTexture =
-        gObjectList[objectIndex].textureList[gObjectList[objectIndex].textureListIndex];
+    // Each TLUT is 512 bytes (128 u32s); idx picks the palette for the frame.
+    gObjectList[objectIndex].activeTLUT = (const char*) (gObjectList[objectIndex].tlutList + (idx * 512));
+    gObjectList[objectIndex].activeTexture = gObjectList[objectIndex].textureList[idx];
 }
 
 void func_80073514(s32 objectIndex) {
-    gObjectList[objectIndex].activeTLUT = gObjectList[objectIndex].tlutList;
+    gObjectList[objectIndex].activeTLUT = (const char*) gObjectList[objectIndex].tlutList;
     gObjectList[objectIndex].activeTexture =
         gObjectList[objectIndex].textureList[gObjectList[objectIndex].textureListIndex];
 }
@@ -1209,7 +1206,7 @@ void func_800744CC(void) {
 
 uintptr_t devaddr2;
 
-void func_80074510(const char** lakituTexturePtr, const char* devAddr, size_t vaddr, size_t nbytes) {
+void func_80074510(const char** lakituTexturePtr, const char* devAddr, size_t vaddr, UNUSED size_t nbytes) {
     func_800744CC();
     lakituTexturePtr[vaddr] = devAddr;
     D_8018D224 = 1;
@@ -1226,7 +1223,7 @@ void func_800745C8(s32 objectIndex, const char** lakituTexturePtr) {
     if ((gObjectList[objectIndex].status & 1) != 0) {
         phi_a1 = 0;
         if (gObjectList[objectIndex].tlutList != (const u8*) gObjectList[objectIndex].activeTLUT) {
-            gObjectList[objectIndex].activeTLUT = gObjectList[objectIndex].tlutList;
+            gObjectList[objectIndex].activeTLUT = (const char*) gObjectList[objectIndex].tlutList;
         }
 
         gObjectList[objectIndex].status ^= 2;
@@ -1245,7 +1242,7 @@ void func_8007466C(s32 objectIndex, const char** lakituTexturePtr) {
     if ((gObjectList[objectIndex].status & 1) != 0) {
         // I have no idea why this typecase works
         gObjectList[objectIndex].activeTLUT =
-            (u8*) ((u32*) gObjectList[objectIndex].tlutList + (gObjectList[objectIndex].unk_0D3 << 7));
+            (const char*) ((u32*) gObjectList[objectIndex].tlutList + (gObjectList[objectIndex].unk_0D3 << 7));
         gObjectList[objectIndex].status ^= 2;
         phi_a1 = 0;
         if ((gObjectList[objectIndex].status & 2) != 0) {
@@ -1260,7 +1257,7 @@ void func_80074704(s32 objectIndex, const char** lakituTexturePtr) {
     s32 phi_a1;
 
     if ((gObjectList[objectIndex].status & 1) != 0) {
-        gObjectList[objectIndex].activeTLUT = gObjectList[objectIndex].tlutList;
+        gObjectList[objectIndex].activeTLUT = (const char*) gObjectList[objectIndex].tlutList;
         gObjectList[objectIndex].status ^= 2;
         phi_a1 = 0;
         if ((gObjectList[objectIndex].status & 2) != 0) {
@@ -1272,7 +1269,7 @@ void func_80074704(s32 objectIndex, const char** lakituTexturePtr) {
 }
 
 // Since the buffer only holds two textures, phi_a2 chooses which spot to load into
-size_t func_80074790(s32 objectIndex, const char** lakituTexturePtr) {
+size_t func_80074790(s32 objectIndex, UNUSED const char** lakituTexturePtr) {
     s32 phi_a2;
 
     gObjectList[objectIndex].status ^= 4;
@@ -1390,7 +1387,7 @@ s32 spawn_train_smoke(s32 trainIndex, Vec3f pos, f32 velocity) {
 
 void func_80075698(s32 objectIndex) {
     gObjectList[objectIndex].unk_0D5 = 1;
-    gObjectList[objectIndex].activeTexture = D_8018D490;
+    gObjectList[objectIndex].activeTexture = (const char*) D_8018D490;
     gObjectList[objectIndex].textureList = D_8018D490;
     gObjectList[objectIndex].primAlpha = 0xFF;
     gObjectList[objectIndex].direction_angle[1] = 0;
@@ -1511,7 +1508,7 @@ s32 spawn_ferry_smoke(s32 ferryIndex, Vec3f pos, f32 velocity) {
 
 void func_80075B08(s32 objectIndex) {
     gObjectList[objectIndex].unk_0D5 = 6;
-    gObjectList[objectIndex].activeTexture = D_8018D490;
+    gObjectList[objectIndex].activeTexture = (const char*) D_8018D490;
     gObjectList[objectIndex].textureList = D_8018D490;
     gObjectList[objectIndex].primAlpha = 0xFF;
     gObjectList[objectIndex].direction_angle[1] = 0;
@@ -2101,7 +2098,7 @@ void init_object_leaf_particle(s32 objectIndex, Vec3f arg1, s32 num) {
 
     init_object(objectIndex, 0);
     gObjectList[objectIndex].unk_0D5 = 7;
-    gObjectList[objectIndex].activeTLUT = (u8*) common_texture_particle_leaf;
+    gObjectList[objectIndex].activeTLUT = common_texture_particle_leaf;
     gObjectList[objectIndex].tlutList = (u8*) common_texture_particle_leaf;
     gObjectList[objectIndex].sizeScaling = 0.1f;
     gObjectList[objectIndex].surfaceHeight = arg1[1];
@@ -2220,7 +2217,7 @@ void func_80078220(s32 objectIndex) {
     Object* object;
 
     object = &gObjectList[objectIndex];
-    object->activeTexture = tex;
+    object->activeTexture = (const char*) tex;
     object->textureList = tex;
     object->vertex = vtx;
     object->sizeScaling = 0.15f;
@@ -2691,7 +2688,7 @@ void func_8007B34C(s32 playerId) {
             }
         }
     }
-    object->activeTLUT = (u8*) gItemWindowTLUTs[object->textureListIndex];
+    object->activeTLUT = gItemWindowTLUTs[object->textureListIndex];
     object->activeTexture = gItemWindowTextures[object->textureListIndex];
     sp38->currentItemCopy = object->type;
 }
@@ -2732,7 +2729,8 @@ void func_8007C420(s32 objectIndex, Player* player, Camera* camera) {
 void func_8007CE0C(s32 objectIndex) {
     Object* object;
 
-    init_texture_object(objectIndex, d_course_banshee_boardwalk_boo_tlut, gTextureGhosts, 0x30U, (u16) 0x00000028);
+    init_texture_object(objectIndex, (u8*) d_course_banshee_boardwalk_boo_tlut, gTextureGhosts, 0x30U,
+                        (u16) 0x00000028);
     object = &gObjectList[objectIndex];
     object->textureListIndex = 0x1C;
     object->pos[0] = 0.0f;
@@ -3074,7 +3072,7 @@ void func_80083FD0(s32 objectIndex, s32 arg1, s32 playerId) {
     object->unk_084[7] = playerId;
     init_object(objectIndex, 0);
     object->activeTLUT = d_course_sherbet_land_ice;
-    object->tlutList = d_course_sherbet_land_ice;
+    object->tlutList = (u8*) d_course_sherbet_land_ice;
     object->sizeScaling = ((f32) random_int(0x01F4U) * 0.0002) + 0.04;
     object->velocity[1] = ((f32) random_int(0x0032U) * 0.05) + 1.0;
     object->unk_034 = ((f32) random_int(0x000AU) * 0.1) + 1.0;
@@ -3269,7 +3267,7 @@ void func_80085F74(s32 objectIndex) {
 
 void func_80086074(s32 objectIndex, s32 arg1) {
     set_obj_origin_pos(objectIndex, D_800E6734[arg1][0] * xOrientation, D_800E6734[arg1][1], D_800E6734[arg1][2]);
-    init_texture_object(objectIndex, d_course_rainbow_road_static_tluts[arg1],
+    init_texture_object(objectIndex, (u8*) d_course_rainbow_road_static_tluts[arg1],
                         &d_course_rainbow_road_static_textures[arg1], 64, 64);
     func_80085BB4(objectIndex);
 }
diff --git a/src/update_objects.h b/src/update_objects.h
index 4db33ea7b..b2eee3f4c 100644
--- a/src/update_objects.h
+++ b/src/update_objects.h
@@ -346,8 +346,8 @@ extern f32 D_800E43B0[];
 extern Vtx D_800E43F0[];
 extern Vtx D_800E4470[];
 extern Vtx D_800E44B0[];
-extern u16* gItemWindowTLUTs[];
-extern u8* gItemWindowTextures[];
+extern const char* gItemWindowTLUTs[];
+extern const char* gItemWindowTextures[];
 extern u16* gHudLapTextures[];
 extern u16* gPortraitTLUTs[];
 extern u8* gPortraitTextures[];