diff --git a/include/color.h b/include/color.h
index 1004501..341d782 100644
--- a/include/color.h
+++ b/include/color.h
@@ -33,6 +33,13 @@ typedef union Color_RGBA8_u32 {
     u32 rgba;
 } Color_RGBA8_u32;
 
+typedef union Color_RGBA8_s32 {
+    struct {
+        s8 r, g, b, a;
+    };
+    s32 rgba;
+} Color_RGBA8_s32;
+
 typedef struct {
     f32 r, g, b, a;
 } Color_RGBAf;
diff --git a/include/math.h b/include/math.h
index 248fa3e..85e2e4f 100644
--- a/include/math.h
+++ b/include/math.h
@@ -18,6 +18,9 @@ extern float __ll_to_f(long long s);
 extern double __ull_to_d(unsigned long long u);
 extern float __ull_to_f(unsigned long long u);
 
+#define SINS(x) gSineTable[(u16) (x) >> 4]
+#define COSS(x) gCosineTable[(u16) (x) >> 4]
+
 typedef float MtxF_t[4][4];
 typedef union {
     MtxF_t mf;
@@ -41,4 +44,25 @@ typedef struct Vec3s {
     /* 0x4 */ s16 z;
 } Vec3s; // size = 0x6
 
+typedef union Vec2s_s32 {
+    struct {
+        /* 0x0 */ s16 x;
+        /* 0x2 */ s16 y;
+    };
+    s32 xy;
+} Vec2s_s32; // size = 0x6
+
+typedef union AllTypeS32 {
+    struct {
+        s16 rg;
+        s16 ba;
+    };
+    struct {
+        s8 r;
+        s8 g;
+        s8 b;
+        s8 a;
+    };
+} AllTypeS32;
+
 #endif
diff --git a/include/variables.h b/include/variables.h
index d744882..bcff160 100644
--- a/include/variables.h
+++ b/include/variables.h
@@ -79,6 +79,8 @@ extern u8 D_2028A60[];
 extern u8 D_2028AA0[];
 extern u32 D_B0000D10;
 
+extern u8 D_800818E0[0x20];
+
 typedef struct unk_D_80068BA0 {
     /* 0x00 */ char pad00[0x2];
     /* 0x02 */ s16 unk_02;
@@ -118,10 +120,6 @@ extern struct unk_D_86002F58_004_000_000 D_800AC840;
 extern struct unk_D_86002F58_004_000_000 D_800AC858;
 extern struct unk_D_86002F58_004_000* D_8006F09C;
 
-extern struct Vec3f D_8006F050;
-extern struct Vec3s D_8006F05C;
-extern struct Vec3f D_8006F064;
-
 typedef struct unk_D_8006FF00 {
 	/* 0x00 */ char unk_00[0x4];
 	/* 0x04 */ char* name;
diff --git a/src/12D80.c b/src/12D80.c
index 6e8d236..ba1493e 100644
--- a/src/12D80.c
+++ b/src/12D80.c
@@ -7,19 +7,16 @@
 #include "src/6A40.h"
 #include "src/6BC0.h"
 #include "src/32D10.h"
-#include "src/E890.h"
+#include "src/F420.h"
 #include "src/memmap.h"
 #include "src/util.h"
 
 typedef void (*func_D_8006F0A4)(unk_D_86002F34_000* arg0);
 
 typedef struct unk_D_800AA8C8 {
-    /* 0x0000 */ MtxF unk_0000[1];
-    /* 0x0040 */ char unk0040[0xFC0];
-    /* 0x1000 */ MtxF* unk_1000[1];
-    /* 0x1004 */ char unk1004[0x7C];
-    /* 0x1080 */ s8 unk_1080[1];
-    /* 0x1081 */ char unk1081[0x1F];
+    /* 0x0000 */ MtxF unk_0000[64];
+    /* 0x1000 */ MtxF* unk_1000[32];
+    /* 0x1080 */ s8 unk_1080[32];
     /* 0x10A0 */ s32 unk_10A0;
 } unk_D_800AA8C8; // size >= 0x10A4
 
@@ -125,7 +122,7 @@ s32 D_800ABCBC;
 void func_80012180(void) {
     D_800AA8C8.unk_10A0 = 0;
     D_800AA8C8.unk_1080[0] = 0;
-    func_8000ED98(D_800AA8C8.unk_0000);
+    func_8000ED98(&D_800AA8C8.unk_0000[0]);
     D_800AA8C8.unk_1000[0] = func_80005F5C(sizeof(Mtx) * 1);
     func_80010090(D_800AA8C8.unk_1000[0], D_800AA8C8.unk_0000);
 }
@@ -265,8 +262,8 @@ void func_80012870(Vtx* arg0, unk_D_86002F34_00C_0CC* arg1, s16 arg2, s16 arg3,
     s16 tmp2;
 
     a4 = arg4;
-    temp_fv1 = gCosineTable[idx >> 4];
-    temp_fa0 = gSineTable[idx >> 4];
+    temp_fv1 = COSS(idx);
+    temp_fa0 = SINS(idx);
     a5 = arg5;
 
     tmp1 = ((a4 * temp_fv1) - (temp_fa0 * a5));
@@ -589,9 +586,9 @@ void func_80013D34(unk_D_86002F34_000* arg0) {
     *(u32*)light->l.col = arg->unk_18.rgba;
     *(u32*)light->l.colc = arg->unk_18.rgba;
 
-    light->l.dir[0] = (120.0f * gCosineTable[arg->unk_1C >> 4]) * gSineTable[arg->unk_1E >> 4];
-    light->l.dir[1] = (120.0f) * gSineTable[arg->unk_1C >> 4];
-    light->l.dir[2] = (120.0f * gCosineTable[arg->unk_1C >> 4]) * gCosineTable[arg->unk_1E >> 4];
+    light->l.dir[0] = (120.0f * COSS(arg->unk_1C)) * SINS(arg->unk_1E);
+    light->l.dir[1] = (120.0f) * SINS(arg->unk_1C);
+    light->l.dir[2] = (120.0f * COSS(arg->unk_1C)) * COSS(arg->unk_1E);
 
     temp_a4->l.col[0] += ((arg->unk_18.r * arg->unk_18.a) / 100);
     if (temp_a4->l.col[0] > 0xFF) {
diff --git a/src/18480.c b/src/18480.c
index 9c9d0bc..24535ad 100644
--- a/src/18480.c
+++ b/src/18480.c
@@ -1,6 +1,6 @@
 #include "18480.h"
 #include "src/11BA0.h"
-#include "src/E890.h"
+#include "src/F420.h"
 #include "src/util.h"
 
 typedef void (*func_D_8006F2B0)(void);
diff --git a/src/1C720.c b/src/1C720.c
index ab7fc70..46606f5 100644
--- a/src/1C720.c
+++ b/src/1C720.c
@@ -2,7 +2,7 @@
 #include "1C720.h"
 #include "11BA0.h"
 #include "17300.h"
-#include "E890.h"
+#include "F420.h"
 #include "18140.h"
 #include "32D10.h"
 #include "22630.h"
diff --git a/src/1CF30.c b/src/1CF30.c
index 4026a3c..d93490e 100644
--- a/src/1CF30.c
+++ b/src/1CF30.c
@@ -5,7 +5,7 @@
 #include "src/6A40.h"
 #include "src/20470.h"
 #include "src/6BC0.h"
-#include "src/E890.h"
+#include "src/F420.h"
 #include "src/memory.h"
 #include "stdarg.h"
 #include "lib/ultralib/src/libc/xstdio.h"
diff --git a/src/30640.c b/src/30640.c
index 636a396..2f5084d 100644
--- a/src/30640.c
+++ b/src/30640.c
@@ -12,7 +12,7 @@
 #include "src/3FB0.h"
 #include "src/4BDC0.h"
 #include "src/6BC0.h"
-#include "src/E890.h"
+#include "src/F420.h"
 #include "src/math_util.h"
 #include "src/memory.h"
 #include "src/fragments/43/fragment43.h"
diff --git a/src/E890.c b/src/E890.c
index a167240..1751a99 100644
--- a/src/E890.c
+++ b/src/E890.c
@@ -1,7 +1,37 @@
-#include "global.h"
 #include "E890.h"
+#include <PR/leo.h>
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000DC90.s")
+extern char D_8006F000[];
+extern char D_8006F004[];
+
+s32 func_8000DC90(void) {
+    if (osMemSize < 0x800000) {
+        return 2;
+    }
+
+    if (bcmp(&D_800818E0[0x18], D_8006F004, 2) != 0) {
+        return 1;
+    }
+
+    if (bcmp(&D_800818E0[1], D_8006F000, 3) != 0) {
+        return 1;
+    }
+
+    if (D_800818E0[0] < 'E') {
+        return 1;
+    }
+
+    if (D_800818E0[0] > 'Z') {
+        return 1;
+    }
+
+    if (D_800818E0[5] != 1) {
+        return 1;
+    }
+
+    _bcopy(&D_800818E0, &leoBootID, 0x20);
+    return 0;
+}
 
 #pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000DD68.s")
 
@@ -30,103 +60,3 @@
 #pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000E760.s")
 
 #pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000E7E4.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000E820.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000E840.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000E868.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000E88C.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000E8B0.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000E8E8.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000E920.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000E958.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000E990.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000E9D4.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000EA84.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000EAF4.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000EB70.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000EBA8.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000EBE0.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000EC18.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000EC50.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000EC88.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000ED4C.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000ED98.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000EDD8.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000EE1C.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000F174.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000F2C4.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000F3FC.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000F5A8.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000F730.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000F88C.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000FA94.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000FBB0.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000FDE4.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000FF04.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8000FFB8.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_80010090.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_80010228.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_800102A4.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_80010354.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_800103F0.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_8001046C.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_800104AC.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_80010500.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_80010570.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_80010720.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_80010780.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_800107F0.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_80010930.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_80010B20.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_80010BD4.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_80010CA8.s")
-
-#pragma GLOBAL_ASM("asm/us/nonmatchings/E890/func_80010E20.s")
diff --git a/src/E890.h b/src/E890.h
index 32aafb4..b50a8ef 100644
--- a/src/E890.h
+++ b/src/E890.h
@@ -3,24 +3,6 @@
 
 #include "global.h"
 
-void func_8000E840(Color_RGBA8*, u8, u8, u8, u8);
-void func_8000E88C(Vec3f*, f32, f32, f32);
-void func_8000EB70(Vec3s*, s16, s16, s16);
-void func_8000E990(Vec3f*, Vec3s*);
-void func_8000ED4C(MtxF*, MtxF*);
-void func_8000ED98(MtxF*);
-void func_8000F2C4(MtxF*, Vec3f*, Vec3s*);
-void func_8000F3FC(MtxF*, Vec3f*, Vec3s*);
-void func_8000F5A8(MtxF*, Vec3f*, Vec3s*, Vec3f*);
-void func_8000F730(MtxF*, Vec3f*, Vec3s*, Vec3f*);
-void func_8000F88C(MtxF*, MtxF*, MtxF*, Vec3f*, f32);
-void func_8000FA94(MtxF*, Vec3f*, Vec3f*, s16);
-void func_8000FBB0(MtxF*, MtxF*, MtxF*);
-void func_8000FDE4(MtxF*, MtxF*, Vec3f*);
-void func_8000FF04(MtxF*, Vec3f*);
-void func_80010090(MtxF*, MtxF*);
-void func_80010228(MtxF*, Vec3f*, Vec3s*, Vec3f*, MtxF*, MtxF*);
-void func_80010354(Vec3f*, Vec3f*, f32, s16, s32);
-
+s32 func_8000DC90(void);
 
 #endif // _E890_H_
diff --git a/src/F420.c b/src/F420.c
new file mode 100644
index 0000000..d660b41
--- /dev/null
+++ b/src/F420.c
@@ -0,0 +1,949 @@
+#include "F420.h"
+#include "src/math_util.h"
+
+extern u16 D_80073660[];
+
+Vec3f D_8006F050 = { 0.0f, 0.0f, 0.0f };
+Vec3s D_8006F05C = { 0, 0, 0 };
+Vec3f D_8006F064 = { 1.0f, 1.0f, 1.0f };
+u16 D_8006F070[] = { 1, 1, 1 };
+
+Color_RGBA8_u32* func_8000E820(Color_RGBA8_u32* arg0, u8 r, u8 g, u8 b) {
+    arg0->r = r;
+    arg0->g = g;
+    arg0->b = b;
+
+    return arg0;
+}
+
+Color_RGBA8_u32* func_8000E840(Color_RGBA8_u32* arg0, u8 arg1, u8 arg2, u8 arg3, u8 arg4) {
+    arg0->r = arg1;
+    arg0->g = arg2;
+    arg0->b = arg3;
+    arg0->a = arg4;
+
+    return arg0;
+}
+
+Vec3f* func_8000E868(Vec3f* arg0, f32 arg1, f32 arg2, f32 arg3) {
+    arg0->x = arg1;
+    arg0->y = arg2;
+    arg0->z = arg3;
+
+    return arg0;
+}
+
+Vec3f* func_8000E88C(Vec3f* arg0, f32 arg1, f32 arg2, f32 arg3) {
+    arg0->x = arg1;
+    arg0->y = arg2;
+    arg0->z = arg3;
+
+    return arg0;
+}
+
+Vec3f* func_8000E8B0(Vec3f* arg0, Vec3f* arg1) {
+    arg0->x += arg1->x;
+    arg0->y += arg1->y;
+    arg0->z += arg1->z;
+
+    return arg0;
+}
+
+Vec3f* func_8000E8E8(Vec3f* arg0, Vec3f* arg1, Vec3f* arg2) {
+    arg0->x = arg1->x + arg2->x;
+    arg0->y = arg1->y + arg2->y;
+    arg0->z = arg1->z + arg2->z;
+
+    return arg0;
+}
+
+Vec3f* func_8000E920(Vec3f* arg0, Vec3f* arg1) {
+    arg0->x -= arg1->x;
+    arg0->y -= arg1->y;
+    arg0->z -= arg1->z;
+
+    return arg0;
+}
+
+Vec3f* func_8000E958(Vec3f* arg0, Vec3f* arg1, Vec3f* arg2) {
+    arg0->x = arg1->x - arg2->x;
+    arg0->y = arg1->y - arg2->y;
+    arg0->z = arg1->z - arg2->z;
+
+    return arg0;
+}
+
+Vec3f* func_8000E990(Vec3f* arg0, Vec3s* arg1) {
+    arg0->x = arg1->x;
+    arg0->y = arg1->y;
+    arg0->z = arg1->z;
+
+    return arg0;
+}
+
+Vec3f* func_8000E9D4(Vec3f* arg0, Vec3f* arg1, Vec3f* arg2, Vec3f* arg3) {
+    arg0->x = ((arg2->y - arg1->y) * (arg3->z - arg2->z)) - ((arg3->y - arg2->y) * (arg2->z - arg1->z));
+    arg0->y = ((arg2->z - arg1->z) * (arg3->x - arg2->x)) - ((arg3->z - arg2->z) * (arg2->x - arg1->x));
+    arg0->z = ((arg2->x - arg1->x) * (arg3->y - arg2->y)) - ((arg3->x - arg2->x) * (arg2->y - arg1->y));
+
+    return arg0;
+}
+
+Vec3f* func_8000EA84(Vec3f* arg0, Vec3f* arg1, Vec3f* arg2) {
+    arg0->x = (arg1->y * arg2->z) - (arg2->y * arg1->z);
+    arg0->y = (arg1->z * arg2->x) - (arg2->z * arg1->x);
+    arg0->z = (arg1->x * arg2->y) - (arg2->x * arg1->y);
+
+    return arg0;
+}
+
+Vec3f* func_8000EAF4(Vec3f* arg0) {
+    f32 temp_fv1_2 = 1.0f / sqrtf(SQ(arg0->x) + SQ(arg0->y) + SQ(arg0->z));
+
+    arg0->x *= temp_fv1_2;
+    arg0->y *= temp_fv1_2;
+    arg0->z *= temp_fv1_2;
+
+    return arg0;
+}
+
+Vec3s* func_8000EB70(Vec3s* arg0, s16 arg1, s16 arg2, s16 arg3) {
+    arg0->x = arg1;
+    arg0->y = arg2;
+    arg0->z = arg3;
+
+    return arg0;
+}
+
+Vec3s* func_8000EBA8(Vec3s* arg0, Vec3s* arg1) {
+    arg0->x += arg1->x;
+    arg0->y += arg1->y;
+    arg0->z += arg1->z;
+
+    return arg0;
+}
+
+Vec3s* func_8000EBE0(Vec3s* arg0, Vec3s* arg1, Vec3s* arg2) {
+    arg0->x = arg1->x + arg2->x;
+    arg0->y = arg1->y + arg2->y;
+    arg0->z = arg1->z + arg2->z;
+
+    return arg0;
+}
+
+Vec3s* func_8000EC18(Vec3s* arg0, Vec3s* arg1) {
+    arg0->x -= arg1->x;
+    arg0->y -= arg1->y;
+    arg0->z -= arg1->z;
+
+    return arg0;
+}
+
+Vec3s* func_8000EC50(Vec3s* arg0, Vec3s* arg1, Vec3s* arg2) {
+    arg0->x = arg1->x - arg2->x;
+    arg0->y = arg1->y - arg2->y;
+    arg0->z = arg1->z - arg2->z;
+
+    return arg0;
+}
+
+Vec3s* func_8000EC88(Vec3s* arg0, Vec3f* arg1) {
+    arg0->x = ROUND_MAX(arg1->x);
+    arg0->y = ROUND_MAX(arg1->y);
+    arg0->z = ROUND_MAX(arg1->z);
+
+    return arg0;
+}
+
+void func_8000ED4C(MtxF* dest, MtxF* src) {
+    if (dest != src) {
+        s32 i;
+        u32* d = (u32*)dest;
+        u32* s = (u32*)src;
+
+        for (i = 0; i < 16; i++) {
+            *d++ = *s++;
+        }
+    }
+}
+
+void func_8000ED98(MtxF* arg0) {
+    s32 i;
+    f32* dest;
+    // These loops must be one line to match on -O2
+    // clang-format off
+    
+    // initialize everything except the first and last cells to 0
+    for (dest = (f32*)arg0 + 1, i = 0; i < 14; dest++, i++) { *dest = 0.0f; }
+
+    // initialize the diagonal cells to 1
+    for (dest = (f32*)arg0, i = 0; i < 4; dest += 5, i++) { *dest = 1.0f; }
+    // clang-format on
+}
+
+void func_8000EDD8(MtxF* arg0, Vec3f* arg1) {
+    func_8000ED98(arg0);
+
+    arg0->mf[3][0] = arg1->x;
+    arg0->mf[3][1] = arg1->y;
+    arg0->mf[3][2] = arg1->z;
+}
+
+void func_8000EE1C(MtxF* mtx, Vec3f* from, Vec3f* to, u16 roll) {
+    f32 invLength;
+    f32 dx;
+    f32 dz;
+    f32 xColY;
+    f32 yColY;
+    f32 zColY;
+    f32 xColZ;
+    f32 yColZ;
+    f32 zColZ;
+    f32 xColX;
+    f32 yColX;
+    f32 zColX;
+
+    dx = to->x - from->x;
+    dz = to->z - from->z;
+
+    invLength = -1.0 / sqrtf(dx * dx + dz * dz);
+    dx *= invLength;
+    dz *= invLength;
+
+    yColY = COSS(roll);
+    xColY = SINS(roll) * dz;
+    zColY = -SINS(roll) * dx;
+
+    xColZ = to->x - from->x;
+    yColZ = to->y - from->y;
+    zColZ = to->z - from->z;
+
+    invLength = -1.0 / sqrtf(xColZ * xColZ + yColZ * yColZ + zColZ * zColZ);
+    xColZ *= invLength;
+    yColZ *= invLength;
+    zColZ *= invLength;
+
+    xColX = yColY * zColZ - zColY * yColZ;
+    yColX = zColY * xColZ - xColY * zColZ;
+    zColX = xColY * yColZ - yColY * xColZ;
+
+    invLength = 1.0 / sqrtf(xColX * xColX + yColX * yColX + zColX * zColX);
+
+    xColX *= invLength;
+    yColX *= invLength;
+    zColX *= invLength;
+
+    xColY = yColZ * zColX - zColZ * yColX;
+    yColY = zColZ * xColX - xColZ * zColX;
+    zColY = xColZ * yColX - yColZ * xColX;
+
+    invLength = 1.0 / sqrtf(xColY * xColY + yColY * yColY + zColY * zColY);
+    xColY *= invLength;
+    yColY *= invLength;
+    zColY *= invLength;
+
+    mtx->mf[0][0] = xColX;
+    mtx->mf[1][0] = yColX;
+    mtx->mf[2][0] = zColX;
+    mtx->mf[3][0] = -(from->x * xColX + from->y * yColX + from->z * zColX);
+
+    mtx->mf[0][1] = xColY;
+    mtx->mf[1][1] = yColY;
+    mtx->mf[2][1] = zColY;
+    mtx->mf[3][1] = -(from->x * xColY + from->y * yColY + from->z * zColY);
+
+    mtx->mf[0][2] = xColZ;
+    mtx->mf[1][2] = yColZ;
+    mtx->mf[2][2] = zColZ;
+    mtx->mf[3][2] = -(from->x * xColZ + from->y * yColZ + from->z * zColZ);
+
+    mtx->mf[0][3] = 0.0f;
+    mtx->mf[1][3] = 0.0f;
+    mtx->mf[2][3] = 0.0f;
+    mtx->mf[3][3] = 1.0f;
+}
+
+void func_8000F174(MtxF* dest, Vec3s* translate, Vec3s* rotate) {
+    f32 sx = SINS(rotate->x);
+    f32 cx = COSS(rotate->x);
+
+    f32 sy = SINS(rotate->y);
+    f32 cy = COSS(rotate->y);
+
+    f32 sz = SINS(rotate->z);
+    f32 cz = COSS(rotate->z);
+
+    dest->mf[0][0] = cy * cz + (sx * sy) * sz;
+    dest->mf[0][1] = -cy * sz + (sx * sy) * cz;
+    dest->mf[0][2] = cx * sy;
+    dest->mf[0][3] = translate->x;
+
+    dest->mf[1][0] = cx * sz;
+    dest->mf[1][1] = cx * cz;
+    dest->mf[1][2] = -sx;
+    dest->mf[1][3] = translate->y;
+
+    dest->mf[2][0] = -sy * cz + (sx * cy) * sz;
+    dest->mf[2][1] = sy * sz + (sx * cy) * cz;
+    dest->mf[2][2] = cx * cy;
+    dest->mf[2][3] = translate->z;
+
+    dest->mf[3][0] = 0.0f;
+    dest->mf[3][1] = 0.0f;
+    dest->mf[3][2] = 0.0f;
+    dest->mf[3][3] = 1.0f;
+}
+
+void func_8000F2C4(MtxF* arg0, Vec3f* arg1, Vec3s* arg2) {
+    f32 temp_fa0;
+    f32 temp_fa1;
+    f32 temp_ft4;
+    f32 temp_ft5;
+    f32 temp_fv0;
+    f32 temp_fv1;
+    f32 sp0;
+
+    temp_fv0 = SINS(arg2->x);
+    temp_fv1 = COSS(arg2->x);
+
+    temp_fa0 = SINS(arg2->y);
+    temp_fa1 = COSS(arg2->y);
+
+    temp_ft4 = SINS(arg2->z);
+    temp_ft5 = COSS(arg2->z);
+
+    sp0 = temp_fv0 * temp_fa0;
+    arg0->mf[0][0] = (temp_fa1 * temp_ft5) + (sp0 * temp_ft4);
+    arg0->mf[1][0] = (-temp_fa1 * temp_ft4) + (sp0 * temp_ft5);
+    arg0->mf[2][0] = temp_fv1 * temp_fa0;
+    arg0->mf[3][0] = arg1->x;
+
+    arg0->mf[0][1] = temp_fv1 * temp_ft4;
+    arg0->mf[1][1] = temp_fv1 * temp_ft5;
+    arg0->mf[2][1] = -temp_fv0;
+    arg0->mf[3][1] = arg1->y;
+
+    sp0 = temp_fv0 * temp_fa1;
+    arg0->mf[0][2] = (-temp_fa0 * temp_ft5) + (sp0 * temp_ft4);
+    arg0->mf[1][2] = (temp_fa0 * temp_ft4) + (sp0 * temp_ft5);
+    arg0->mf[2][2] = temp_fv1 * temp_fa1;
+    arg0->mf[3][2] = arg1->z;
+
+    arg0->mf[0][3] = 0.0f;
+    arg0->mf[1][3] = 0.0f;
+    arg0->mf[2][3] = 0.0f;
+    arg0->mf[3][3] = 1.0f;
+}
+
+void func_8000F3FC(MtxF* arg0, Vec3f* arg1, Vec3s* arg2) {
+    f32 sx = SINS(arg2->x);
+    f32 cx = COSS(arg2->x);
+    f32 sy = SINS(arg2->y);
+    f32 cy = COSS(arg2->y);
+    f32 sz = SINS(arg2->z);
+    f32 cz = COSS(arg2->z);
+
+    arg0->mf[0][0] = (cy * cz) + ((sx * sy) * sz);
+    arg0->mf[0][1] = (-cy * sz) + ((sx * sy) * cz);
+    arg0->mf[0][2] = cx * sy;
+
+    arg0->mf[1][0] = cx * sz;
+    arg0->mf[1][1] = cx * cz;
+    arg0->mf[1][2] = -sx;
+
+    arg0->mf[2][0] = (-sy * cz) + ((sx * cy) * sz);
+    arg0->mf[2][1] = (sy * sz) + ((sx * cy) * cz);
+    arg0->mf[2][2] = cx * cy;
+
+    arg0->mf[3][0] = (arg0->mf[0][0] * arg1->x) + (arg0->mf[1][0] * arg1->y) + (arg0->mf[2][0] * arg1->z);
+    arg0->mf[3][1] = (arg0->mf[0][1] * arg1->x) + (arg0->mf[1][1] * arg1->y) + (arg0->mf[2][1] * arg1->z);
+    arg0->mf[3][2] = (arg0->mf[0][2] * arg1->x) + (arg0->mf[1][2] * arg1->y) + (arg0->mf[2][2] * arg1->z);
+
+    arg0->mf[0][3] = arg0->mf[1][3] = arg0->mf[2][3] = 0.0f;
+    arg0->mf[3][3] = 1.0f;
+}
+
+void func_8000F5A8(MtxF* dest, Vec3f* b, Vec3s* c, Vec3f* arg3) {
+    f32 sx = SINS(c->x);
+    f32 cx = COSS(c->x);
+
+    f32 sy = SINS(c->y);
+    f32 cy = COSS(c->y);
+
+    f32 sz = SINS(c->z);
+    f32 cz = COSS(c->z);
+
+    dest->mf[0][0] = (cy * cz) * arg3->x;
+    dest->mf[0][1] = (cy * sz) * arg3->x;
+    dest->mf[0][2] = (-sy) * arg3->x;
+    dest->mf[0][3] = 0.0f;
+
+    dest->mf[1][0] = (sx * sy * cz - cx * sz) * arg3->y;
+    dest->mf[1][1] = (sx * sy * sz + cx * cz) * arg3->y;
+    dest->mf[1][2] = (sx * cy) * arg3->y;
+    dest->mf[1][3] = 0.0f;
+
+    dest->mf[2][0] = (cx * sy * cz + sx * sz) * arg3->z;
+    dest->mf[2][1] = (cx * sy * sz - sx * cz) * arg3->z;
+    dest->mf[2][2] = (cx * cy) * arg3->z;
+    dest->mf[2][3] = 0.0f;
+
+    dest->mf[3][0] = b->x;
+    dest->mf[3][1] = b->y;
+    dest->mf[3][2] = b->z;
+    dest->mf[3][3] = 1.0f;
+}
+
+void func_8000F730(MtxF* dest, Vec3f* b, Vec3s* c, Vec3f* arg3) {
+    f32 sx = SINS(c->x);
+    f32 cx = COSS(c->x);
+
+    f32 sy = SINS(c->y);
+    f32 cy = COSS(c->y);
+
+    f32 sz = SINS(c->z);
+    f32 cz = COSS(c->z);
+
+    dest->mf[0][0] = cy * cz;
+    dest->mf[0][1] = cy * sz;
+    dest->mf[0][2] = -sy;
+    dest->mf[0][3] = 0.0f;
+
+    dest->mf[1][0] = sx * sy * cz - cx * sz;
+    dest->mf[1][1] = sx * sy * sz + cx * cz;
+    dest->mf[1][2] = sx * cy;
+    dest->mf[1][3] = 0.0f;
+
+    dest->mf[2][0] = cx * sy * cz + sx * sz;
+    dest->mf[2][1] = cx * sy * sz - sx * cz;
+    dest->mf[2][2] = cx * cy;
+    dest->mf[2][3] = 0.0f;
+
+    dest->mf[3][0] = b->x * arg3->x;
+    dest->mf[3][1] = b->y * arg3->y;
+    dest->mf[3][2] = b->z * arg3->z;
+    dest->mf[3][3] = 1.0f;
+}
+
+void func_8000F88C(MtxF* arg0, MtxF* arg1, MtxF* arg2, Vec3f* arg3, f32 arg4) {
+    f32 sp24;
+    f32 sp20;
+    f32 sp1C;
+
+    sp24 = sqrtf(SQ(arg2->mf[0][0]) + SQ(arg2->mf[0][1]) + SQ(arg2->mf[0][2])) * arg4;
+    sp20 = sqrtf(SQ(arg2->mf[1][0]) + SQ(arg2->mf[1][1]) + SQ(arg2->mf[1][2])) * arg4;
+    sp1C = sqrtf(SQ(arg2->mf[2][0]) + SQ(arg2->mf[2][1]) + SQ(arg2->mf[2][2])) * arg4;
+
+    arg0->mf[0][0] = arg1->mf[0][0] * sp24;
+    arg0->mf[0][1] = arg1->mf[1][0] * sp24;
+    arg0->mf[0][2] = arg1->mf[2][0] * sp24;
+    arg0->mf[0][3] = 0.0f;
+
+    arg0->mf[1][0] = arg1->mf[0][1] * sp20;
+    arg0->mf[1][1] = arg1->mf[1][1] * sp20;
+    arg0->mf[1][2] = arg1->mf[2][1] * sp20;
+    arg0->mf[1][3] = 0.0f;
+
+    arg0->mf[2][0] = arg1->mf[0][2] * sp1C;
+    arg0->mf[2][1] = arg1->mf[1][2] * sp1C;
+    arg0->mf[2][2] = arg1->mf[2][2] * sp1C;
+    arg0->mf[2][3] = 0.0f;
+
+    arg0->mf[3][0] =
+        ((arg2->mf[0][0] * arg3->x) + (arg2->mf[1][0] * arg3->y) + (arg2->mf[2][0] * arg3->z)) + arg2->mf[3][0];
+    arg0->mf[3][1] =
+        ((arg2->mf[0][1] * arg3->x) + (arg2->mf[1][1] * arg3->y) + (arg2->mf[2][1] * arg3->z)) + arg2->mf[3][1];
+    arg0->mf[3][2] =
+        ((arg2->mf[0][2] * arg3->x) + (arg2->mf[1][2] * arg3->y) + (arg2->mf[2][2] * arg3->z)) + arg2->mf[3][2];
+    arg0->mf[3][3] = 1.0f;
+}
+
+void func_8000FA94(MtxF* dest, Vec3f* upDir, Vec3f* pos, s16 yaw) {
+    Vec3f lateralDir;
+    Vec3f leftDir;
+    Vec3f forwardDir;
+
+    func_8000E88C(&lateralDir, SINS(yaw), 0, COSS(yaw));
+    func_8000EAF4(upDir);
+
+    func_8000EA84(&leftDir, upDir, &lateralDir);
+    func_8000EAF4(&leftDir);
+
+    func_8000EA84(&forwardDir, &leftDir, upDir);
+    func_8000EAF4(&forwardDir);
+
+    dest->mf[0][0] = leftDir.x;
+    dest->mf[0][1] = leftDir.y;
+    dest->mf[0][2] = leftDir.z;
+    dest->mf[3][0] = pos->x;
+
+    dest->mf[1][0] = upDir->x;
+    dest->mf[1][1] = upDir->y;
+    dest->mf[1][2] = upDir->z;
+    dest->mf[3][1] = pos->y;
+
+    dest->mf[2][0] = forwardDir.x;
+    dest->mf[2][1] = forwardDir.y;
+    dest->mf[2][2] = forwardDir.z;
+    dest->mf[3][2] = pos->z;
+
+    dest->mf[0][3] = 0.0f;
+    dest->mf[1][3] = 0.0f;
+    dest->mf[2][3] = 0.0f;
+    dest->mf[3][3] = 1.0f;
+}
+
+void func_8000FBB0(MtxF* arg0, MtxF* arg1, MtxF* arg2) {
+    f32 entry0;
+    f32 entry1;
+    f32 entry2;
+
+    entry0 = arg1->mf[0][0];
+    entry1 = arg1->mf[0][1];
+    entry2 = arg1->mf[0][2];
+
+    arg0->mf[0][0] = (entry0 * arg2->mf[0][0]) + (entry1 * arg2->mf[1][0]) + (entry2 * arg2->mf[2][0]);
+    arg0->mf[0][1] = (entry0 * arg2->mf[0][1]) + (entry1 * arg2->mf[1][1]) + (entry2 * arg2->mf[2][1]);
+    arg0->mf[0][2] = (entry0 * arg2->mf[0][2]) + (entry1 * arg2->mf[1][2]) + (entry2 * arg2->mf[2][2]);
+
+    entry0 = arg1->mf[1][0];
+    entry1 = arg1->mf[1][1];
+    entry2 = arg1->mf[1][2];
+
+    arg0->mf[1][0] = (entry0 * arg2->mf[0][0]) + (entry1 * arg2->mf[1][0]) + (entry2 * arg2->mf[2][0]);
+    arg0->mf[1][1] = (entry0 * arg2->mf[0][1]) + (entry1 * arg2->mf[1][1]) + (entry2 * arg2->mf[2][1]);
+    arg0->mf[1][2] = (entry0 * arg2->mf[0][2]) + (entry1 * arg2->mf[1][2]) + (entry2 * arg2->mf[2][2]);
+
+    entry0 = arg1->mf[2][0];
+    entry1 = arg1->mf[2][1];
+    entry2 = arg1->mf[2][2];
+
+    arg0->mf[2][0] = (entry0 * arg2->mf[0][0]) + (entry1 * arg2->mf[1][0]) + (entry2 * arg2->mf[2][0]);
+    arg0->mf[2][1] = (entry0 * arg2->mf[0][1]) + (entry1 * arg2->mf[1][1]) + (entry2 * arg2->mf[2][1]);
+    arg0->mf[2][2] = (entry0 * arg2->mf[0][2]) + (entry1 * arg2->mf[1][2]) + (entry2 * arg2->mf[2][2]);
+
+    entry0 = arg1->mf[3][0];
+    entry1 = arg1->mf[3][1];
+    entry2 = arg1->mf[3][2];
+
+    arg0->mf[3][0] = (entry0 * arg2->mf[0][0]) + (entry1 * arg2->mf[1][0]) + (entry2 * arg2->mf[2][0]) + arg2->mf[3][0];
+    arg0->mf[3][1] = (entry0 * arg2->mf[0][1]) + (entry1 * arg2->mf[1][1]) + (entry2 * arg2->mf[2][1]) + arg2->mf[3][1];
+    arg0->mf[3][2] = (entry0 * arg2->mf[0][2]) + (entry1 * arg2->mf[1][2]) + (entry2 * arg2->mf[2][2]) + arg2->mf[3][2];
+
+    arg0->mf[0][3] = arg0->mf[1][3] = arg0->mf[2][3] = 0.0f;
+    arg0->mf[3][3] = 1.0f;
+}
+
+void func_8000FDE4(MtxF* dest, MtxF* mtx, Vec3f* s) {
+    s32 i;
+
+    for (i = 0; i < 4; i++) {
+        dest->mf[0][i] = mtx->mf[0][i] * s->x;
+        dest->mf[1][i] = mtx->mf[1][i] * s->y;
+        dest->mf[2][i] = mtx->mf[2][i] * s->z;
+        dest->mf[3][i] = mtx->mf[3][i];
+    }
+}
+
+void func_8000FF04(MtxF* arg0, Vec3f* arg1) {
+    arg1->x = sqrtf(SQ(arg0->mf[0][0]) + SQ(arg0->mf[0][1]) + SQ(arg0->mf[0][2]));
+    arg1->y = sqrtf(SQ(arg0->mf[1][0]) + SQ(arg0->mf[1][1]) + SQ(arg0->mf[1][2]));
+    arg1->z = sqrtf(SQ(arg0->mf[2][0]) + SQ(arg0->mf[2][1]) + SQ(arg0->mf[2][2]));
+}
+
+void func_8000FFB8(MtxF* arg0, Vec3s* arg1) {
+    f32 entry0 = arg1->x;
+    f32 entry1 = arg1->y;
+    f32 entry2 = arg1->z;
+
+    arg1->x = ((entry0 * arg0->mf[0][0]) + (entry1 * arg0->mf[1][0]) + (entry2 * arg0->mf[2][0])) + arg0->mf[3][0];
+    arg1->y = ((entry0 * arg0->mf[0][1]) + (entry1 * arg0->mf[1][1]) + (entry2 * arg0->mf[2][1])) + arg0->mf[3][1];
+    arg1->z = ((entry0 * arg0->mf[0][2]) + (entry1 * arg0->mf[1][2]) + (entry2 * arg0->mf[2][2])) + arg0->mf[3][2];
+}
+
+#define GET_HIGH_S16_OF_32(var) (((s16*)&(var))[0])
+#define GET_LOW_S16_OF_32(var) (((s16*)&(var))[1])
+
+void func_80010090(MtxF* dest, MtxF* src) {
+    s32 asFixedPoint;
+    s32 i;
+    s16* a3 = (s16*)dest;      // all integer parts stored in first 16 bytes
+    s16* t0 = (s16*)dest + 16; // all fraction parts stored in last 16 bytes
+    f32* t1 = (f32*)src;
+
+    for (i = 0; i < 16; i++) {
+        asFixedPoint = *t1++ * (1 << 16);         //! float-to-integer conversion responsible for PU crashes
+        *a3++ = GET_HIGH_S16_OF_32(asFixedPoint); // integer part
+        *t0++ = GET_LOW_S16_OF_32(asFixedPoint);  // fraction part
+    }
+}
+
+void func_80010228(MtxF* arg0, Vec3f* arg1, Vec3s* arg2, Vec3f* arg3, MtxF* arg4, MtxF* arg5) {
+    MtxF sp60;
+    MtxF sp20;
+
+    func_8000F88C(&sp60, arg4, arg5, arg1, 1.0f);
+    func_8000F2C4(&sp20, &D_8006F050, arg2);
+    func_8000FBB0(&sp20, &sp20, &sp60);
+    func_8000FDE4(arg0, &sp20, arg3);
+}
+
+void func_800102A4(Vec3f* arg0, Vec3f* arg1, f32* arg2, s16* arg3, s16* arg4) {
+    f32 sp2C = arg1->x - arg0->x;
+    f32 sp28 = arg1->y - arg0->y;
+    f32 sp24 = arg1->z - arg0->z;
+
+    *arg2 = sqrtf(SQ(sp2C) + SQ(sp28) + SQ(sp24));
+    *arg3 = MathUtil_Atan2s(sqrtf(SQ(sp2C) + SQ(sp24)), sp28);
+    *arg4 = MathUtil_Atan2s(sp24, sp2C);
+}
+
+void func_80010354(Vec3f* from, Vec3f* to, f32 dist, s16 pitch, s16 yaw) {
+    to->x = from->x + (dist * COSS(pitch) * SINS(yaw));
+    to->y = from->y + (dist * SINS(pitch));
+    to->z = from->z + (dist * COSS(pitch) * COSS(yaw));
+}
+
+s16 func_800103F0(s16 current, s16 target, s16 inc) {
+    s16 temp_v0 = target - current;
+
+    if (temp_v0 < 0) {
+        temp_v0 += inc;
+        if (temp_v0 > 0) {
+            temp_v0 = 0;
+        }
+    } else {
+        temp_v0 -= inc;
+        if (temp_v0 < 0) {
+            temp_v0 = 0;
+        }
+    }
+
+    return target - temp_v0;
+}
+
+s32 func_8001046C(s32 current, s32 target, s32 inc, s32 dec) {
+    //! If target is close to the max or min s32, then it's possible to overflow
+    // past it without stopping.
+
+    if (current < target) {
+        current += inc;
+        if (current > target) {
+            current = target;
+        }
+    } else {
+        current -= dec;
+        if (current < target) {
+            current = target;
+        }
+    }
+    return current;
+}
+
+f32 func_800104AC(f32 current, f32 target, f32 inc, f32 dec) {
+    if (current < target) {
+        current += inc;
+        if (current > target) {
+            current = target;
+        }
+    } else {
+        current -= dec;
+        if (current < target) {
+            current = target;
+        }
+    }
+    return current;
+}
+
+s16 func_80010500(s16* arg0, s32 arg1, s32 arg2) {
+    Vec2s_s32 spC;
+    s16* temp_a3 = &arg0[(arg1 * arg2) / 16];
+    s16* p_spC = &spC.x;
+
+    p_spC[0] = temp_a3[0];
+    p_spC[1] = temp_a3[1];
+
+    spC.xy <<= ((arg1 * arg2) % 16);
+    spC.xy >>= -arg2;
+    return spC.y;
+}
+
+void func_80010570(f32 arg0, f32 arg1, f32 arg2, Vec3f* arg3) {
+    f32 temp_ft4;
+    f32 var_ft5;
+    f32 var_fv0;
+    f32 var_fv1;
+    s32 var_v0;
+
+    var_v0 = 0x47;
+    if (arg1 <= arg0) {
+        var_fv0 = arg0;
+        var_v0 = 0x52;
+    } else {
+        var_fv0 = arg1;
+    }
+
+    if (var_fv0 < arg2) {
+        var_fv0 = arg2;
+        var_v0 = 0x42;
+    }
+
+    if (arg0 <= arg1) {
+        var_fv1 = arg0;
+    } else {
+        var_fv1 = arg1;
+    }
+
+    if (arg2 < var_fv1) {
+        var_fv1 = arg2;
+    }
+
+    temp_ft4 = var_fv0 + var_fv1;
+    arg3->z = temp_ft4 - 1.0f;
+    if (var_fv0 == var_fv1) {
+        arg3->y = 0.0f;
+        arg3->x = 0.0f;
+        return;
+    }
+
+    if (arg3->z <= 0.0f) {
+        var_ft5 = var_fv0 - var_fv1;
+        arg3->y = var_ft5 / temp_ft4;
+    } else {
+        var_ft5 = var_fv0 - var_fv1;
+        arg3->y = var_ft5 / (2.0 - temp_ft4);
+    }
+
+    if (var_v0 == 0x52) {
+        arg3->x = (arg1 - arg2) / var_ft5;
+    } else if (var_v0 == 0x47) {
+        arg3->x = ((arg2 - arg0) / var_ft5) + 2.0;
+    } else {
+        arg3->x = ((arg0 - arg1) / var_ft5) + 4.0;
+    }
+
+    arg3->x *= 60.0f;
+    if (arg3->x < 0.0f) {
+        arg3->x += 360.0f;
+    }
+}
+
+void func_80010720(Color_RGBA8_u32 arg0, Vec3f* arg1) {
+    func_80010570((s32)arg0.r / 255.0f, (s32)arg0.g / 255.0f, (s32)arg0.b / 255.0f, arg1);
+}
+
+void func_80010780(u16 arg0, Vec3f* arg1) {
+    func_80010570(((arg0 & 0xF800) >> 0xB) / 31.0f, ((arg0 & 0x7C0) >> 6) / 31.0f, ((arg0 & 0x3E) >> 1) / 31.0f, arg1);
+}
+
+f32 func_800107F0(f32 arg0, f32 arg1, f32 arg2) {
+    f32 ret;
+
+    if (arg0 < 0.0f) {
+        arg0 += 360.0f;
+    } else {
+        while (arg0 >= 360.0f) {
+            arg0 -= 360.0f;
+        }
+    }
+
+    if (arg0 < 60.0f) {
+        ret = (((arg2 - arg1) * arg0) / 60.0f) + arg1;
+    } else if ((arg0 >= 60.0f) && (arg0 < 180.0f)) {
+        ret = arg2;
+    } else if ((arg0 >= 180.0f) && (arg0 < 240.0f)) {
+        ret = arg1 + (((arg2 - arg1) * (240.0 - arg0)) / 60.0);
+    } else {
+        ret = arg1;
+    }
+
+    return ret;
+}
+
+void func_80010930(f32* arg0, f32* arg1, f32* arg2, Vec3f* arg3) {
+    f32 sp24;
+    f32 sp20;
+    f32 temp_ft4;
+
+    if (arg3->z < -1.0f) {
+        arg3->z = -1.0f;
+    } else if (arg3->z > 1.0f) {
+        arg3->z = 1.0f;
+    }
+
+    if (arg3->y < 0.0f) {
+        arg3->y = 0.0f;
+    } else {
+        sp24 = 1.0f;
+        if (arg3->y > 1.0f) {
+            arg3->y = 1.0f;
+        }
+    }
+
+    if (arg3->x < 0.0f) {
+        arg3->x += 360.0f;
+    } else {
+        while (arg3->x >= 360.0f) {
+            arg3->x -= 360.0f;
+        }
+    }
+
+    if (arg3->z <= 0.0f) {
+        temp_ft4 = arg3->z + 1.0f;
+        sp24 = temp_ft4 * 0.5f * (1.0f - arg3->y);
+        sp20 = temp_ft4 - sp24;
+    } else {
+        temp_ft4 = arg3->z + 1.0f;
+        sp20 = (temp_ft4 * 0.5 * (1.0f - arg3->y)) + arg3->y;
+        sp24 = temp_ft4 - sp20;
+    }
+
+    *arg0 = func_800107F0(arg3->x + 120.0f, sp24, sp20);
+    *arg1 = func_800107F0(arg3->x, sp24, sp20);
+    *arg2 = func_800107F0(arg3->x - 120.0f, sp24, sp20);
+}
+
+u16 func_80010B20(Vec3f* arg0) {
+    f32 sp2C;
+    f32 sp28;
+    f32 sp24;
+    s32 var_a0;
+    s32 var_a1;
+    s32 var_v1;
+
+    func_80010930(&sp2C, &sp28, &sp24, arg0);
+
+    var_a1 = (sp2C * 31.0f) + 0.5f;
+    if (var_a1 >= 0x20) {
+        var_a1 = 0x1F;
+    }
+
+    var_v1 = (sp28 * 31.0f) + 0.5f;
+    if (var_v1 >= 0x20) {
+        var_v1 = 0x1F;
+    }
+
+    var_a0 = (sp24 * 31.0f) + 0.5f;
+    if (var_a0 >= 0x20) {
+        var_a0 = 0x1F;
+    }
+
+    return (var_a1 << 0xB) | (var_v1 << 6) | (var_a0 * 2) | 1;
+}
+
+Color_RGBA8_u32* func_80010BD4(Color_RGBA8_u32* arg0, Vec3f* arg1, s32 arg2) {
+    f32 sp34;
+    f32 sp30;
+    f32 sp2C;
+    s32 var_a0;
+    s32 var_a1;
+    s32 var_v1;
+    Color_RGBA8_u32 sp1C;
+
+    func_80010930(&sp34, &sp30, &sp2C, arg1);
+
+    var_a1 = (sp34 * 255.0f) + 0.5f;
+    if (var_a1 >= 0x100) {
+        var_a1 = 0xFF;
+    }
+
+    var_v1 = (sp30 * 255.0f) + 0.5f;
+    if (var_v1 >= 0x100) {
+        var_v1 = 0xFF;
+    }
+
+    var_a0 = (sp2C * 255.0f) + 0.5f;
+    if (var_a0 >= 0x100) {
+        var_a0 = 0xFF;
+    }
+
+    sp1C.r = var_a1;
+    sp1C.g = var_v1;
+    sp1C.b = var_a0;
+    sp1C.a = arg2;
+
+    *arg0 = sp1C;
+
+    return arg0;
+}
+
+#ifdef NON_MATCHING
+u16 func_80010CA8(u16 arg0, AllTypeS32 arg1) {
+    Vec3f sp24;
+    s32 a;
+    s32 b;
+
+    if (arg0 & 1) {
+        func_80010780(arg0, &sp24);
+
+        if (arg1.rg != 0) {
+            sp24.x += (arg1.b * 0.015625f);
+        }
+
+        if (arg1.b != 0) {
+            if (arg1.a > 0) {
+                sp24.y += ((1.0f - sp24.y) * arg1.a * 0.125f);
+            } else {
+                sp24.y += (sp24.y * arg1.a * 0.125f);
+            }
+        }
+
+        if (arg1.a != 0) {
+            a = (((sp24.z + 1.0f) * 0.5f * 255.0f));
+            b = (((arg1.a > 0) ? arg1.a + 7 : arg1.a + 8) << 8);
+
+            sp24.z = (2.0f * (D_80073660[b + a] / 65535.0f)) - 1.0f;
+        }
+
+        arg0 = func_80010B20(&sp24);
+    }
+    return arg0;
+}
+#else
+// const f32 D_8007B580 = 65535.0f;
+#pragma GLOBAL_ASM("asm/us/nonmatchings/F420/func_80010CA8.s")
+#endif
+
+#ifdef NON_MATCHING
+Color_RGBA8_u32* func_80010E20(Color_RGBA8_u32 arg0, AllTypeS32 arg1) {
+    Vec3f sp2C;
+    Color_RGBA8_u32* a0 = &arg0;
+    s32 var_v1;
+    s32 a;
+
+    if (a0->a > 0) {
+        func_80010720(arg0, &sp2C);
+
+        if (arg1.rg != 0) {
+            sp2C.x += (arg1.b * 0.015625f);
+        }
+
+        if (arg1.b != 0) {
+            if (arg1.a > 0) {
+                sp2C.y += ((1.0f - sp2C.y) * arg1.a * 0.125f);
+            } else {
+                sp2C.y += (sp2C.y * arg1.a * 0.125f);
+            }
+        }
+
+        if (arg1.a != 0) {
+            a = (((sp2C.z + 1.0f) * 0.5f * 255.0f));
+
+            if (arg1.a > 0) {
+                var_v1 = arg1.a + 7;
+            } else {
+                var_v1 = arg1.a + 8;
+            }
+
+            sp2C.z = (2.0f * (D_80073660[(var_v1 << 8) + a] / 65535.0f)) - 1.0f;
+        }
+
+        func_80010BD4(a0, &sp2C, arg0.a);
+    }
+
+    return a0;
+}
+#else
+// const f32 D_8007B584 = 65535.0f;
+#pragma GLOBAL_ASM("asm/us/nonmatchings/F420/func_80010E20.s")
+#endif
diff --git a/src/F420.h b/src/F420.h
new file mode 100644
index 0000000..4d97406
--- /dev/null
+++ b/src/F420.h
@@ -0,0 +1,62 @@
+#ifndef _F420_H_
+#define _F420_H_
+
+#include "global.h"
+
+extern Vec3f D_8006F050;
+extern Vec3s D_8006F05C;
+extern Vec3f D_8006F064;
+extern u16 D_8006F070[];
+
+Color_RGBA8_u32* func_8000E820(Color_RGBA8_u32* arg0, u8 r, u8 g, u8 b);
+Color_RGBA8_u32* func_8000E840(Color_RGBA8_u32* arg0, u8 arg1, u8 arg2, u8 arg3, u8 arg4);
+Vec3f* func_8000E868(Vec3f* arg0, f32 arg1, f32 arg2, f32 arg3);
+Vec3f* func_8000E88C(Vec3f* arg0, f32 arg1, f32 arg2, f32 arg3);
+Vec3f* func_8000E8B0(Vec3f* arg0, Vec3f* arg1);
+Vec3f* func_8000E8E8(Vec3f* arg0, Vec3f* arg1, Vec3f* arg2);
+Vec3f* func_8000E920(Vec3f* arg0, Vec3f* arg1);
+Vec3f* func_8000E958(Vec3f* arg0, Vec3f* arg1, Vec3f* arg2);
+Vec3f* func_8000E990(Vec3f* arg0, Vec3s* arg1);
+Vec3f* func_8000E9D4(Vec3f* arg0, Vec3f* arg1, Vec3f* arg2, Vec3f* arg3);
+Vec3f* func_8000EA84(Vec3f* arg0, Vec3f* arg1, Vec3f* arg2);
+Vec3f* func_8000EAF4(Vec3f* arg0);
+Vec3s* func_8000EB70(Vec3s* arg0, s16 arg1, s16 arg2, s16 arg3);
+Vec3s* func_8000EBA8(Vec3s* arg0, Vec3s* arg1);
+Vec3s* func_8000EBE0(Vec3s* arg0, Vec3s* arg1, Vec3s* arg2);
+Vec3s* func_8000EC18(Vec3s* arg0, Vec3s* arg1);
+Vec3s* func_8000EC50(Vec3s* arg0, Vec3s* arg1, Vec3s* arg2);
+Vec3s* func_8000EC88(Vec3s* arg0, Vec3f* arg1);
+void func_8000ED4C(MtxF* dest, MtxF* src);
+void func_8000ED98(MtxF* arg0);
+void func_8000EDD8(MtxF* arg0, Vec3f* arg1);
+void func_8000EE1C(MtxF* mtx, Vec3f* from, Vec3f* to, u16 roll);
+void func_8000F174(MtxF* dest, Vec3s* translate, Vec3s* rotate);
+void func_8000F2C4(MtxF* arg0, Vec3f* arg1, Vec3s* arg2);
+void func_8000F3FC(MtxF* arg0, Vec3f* arg1, Vec3s* arg2);
+void func_8000F5A8(MtxF* dest, Vec3f* b, Vec3s* c, Vec3f* arg3);
+void func_8000F730(MtxF* dest, Vec3f* b, Vec3s* c, Vec3f* arg3);
+void func_8000F88C(MtxF* arg0, MtxF* arg1, MtxF* arg2, Vec3f* arg3, f32 arg4);
+void func_8000FA94(MtxF* dest, Vec3f* upDir, Vec3f* pos, s16 yaw);
+void func_8000FBB0(MtxF* arg0, MtxF* arg1, MtxF* arg2);
+void func_8000FDE4(MtxF* dest, MtxF* mtx, Vec3f* s);
+void func_8000FF04(MtxF* arg0, Vec3f* arg1);
+void func_8000FFB8(MtxF* arg0, Vec3s* arg1);
+void func_80010090(MtxF* dest, MtxF* src);
+void func_80010228(MtxF* arg0, Vec3f* arg1, Vec3s* arg2, Vec3f* arg3, MtxF* arg4, MtxF* arg5);
+void func_800102A4(Vec3f* arg0, Vec3f* arg1, f32* arg2, s16* arg3, s16* arg4);
+void func_80010354(Vec3f* from, Vec3f* to, f32 dist, s16 pitch, s16 yaw);
+s16 func_800103F0(s16 current, s16 target, s16 inc);
+s32 func_8001046C(s32 current, s32 target, s32 inc, s32 dec);
+f32 func_800104AC(f32 current, f32 target, f32 inc, f32 dec);
+s16 func_80010500(s16* arg0, s32 arg1, s32 arg2);
+void func_80010570(f32 arg0, f32 arg1, f32 arg2, Vec3f* arg3);
+void func_80010720(Color_RGBA8_u32 arg0, Vec3f* arg1);
+void func_80010780(u16 arg0, Vec3f* arg1);
+f32 func_800107F0(f32 arg0, f32 arg1, f32 arg2);
+void func_80010930(f32* arg0, f32* arg1, f32* arg2, Vec3f* arg3);
+u16 func_80010B20(Vec3f* arg0);
+Color_RGBA8_u32* func_80010BD4(Color_RGBA8_u32* arg0, Vec3f* arg1, s32 arg2);
+u16 func_80010CA8(u16 arg0, AllTypeS32 arg1);
+Color_RGBA8_u32* func_80010E20(Color_RGBA8_u32 arg0, AllTypeS32 arg1);
+
+#endif // _F420_H_
diff --git a/src/dma.c b/src/dma.c
index db9a3f9..d756d86 100644
--- a/src/dma.c
+++ b/src/dma.c
@@ -2,7 +2,6 @@
 #include "dma.h"
 #include "rsp.h"
 
-extern u32 D_800818E0;
 extern s16 D_80083C1C;
 
 s32 func_80000E80(s32 arg0, void* arg1, s32 arg2, s32 arg3, s32 arg4, s32 arg5) {
@@ -102,7 +101,7 @@ s32 func_80001124(s32 arg0, s32 arg1) {
     temp_v0 = Util_Malloc(0x2C);
     if (temp_v0 != NULL) {
         temp_v0->unk0 = 0xC;
-        temp_v0->unk20 = &D_800818E0;
+        temp_v0->unk20 = D_800818E0;
         temp_v0->unk28 = arg0;
         func_80000E2C(temp_v0, arg1);
     }
diff --git a/src/dma.h b/src/dma.h
index 8496de7..7cf69cb 100644
--- a/src/dma.h
+++ b/src/dma.h
@@ -5,7 +5,7 @@ struct UnkStruct80000E80 {
     char unk0;
     char filler4[0x18];
     s32 unk1C;
-    void *unk20;
+    u8* unk20;
     s32 unk24;
     s32 unk28;
 };
diff --git a/src/fragments/10/fragment10.c b/src/fragments/10/fragment10.c
index 9c2fb56..1fd3ac5 100644
--- a/src/fragments/10/fragment10.c
+++ b/src/fragments/10/fragment10.c
@@ -15,7 +15,7 @@
 #include "src/50860.h"
 #include "src/6A40.h"
 #include "src/6BC0.h"
-#include "src/E890.h"
+#include "src/F420.h"
 #include "src/fragments/2/fragment2.h"
 #include "src/memory.h"
 #include "src/stage_loader.h"
diff --git a/src/fragments/11/fragment11.c b/src/fragments/11/fragment11.c
index 9bb480d..f0d9eb1 100644
--- a/src/fragments/11/fragment11.c
+++ b/src/fragments/11/fragment11.c
@@ -14,7 +14,7 @@
 #include "src/50860.h"
 #include "src/6A40.h"
 #include "src/6BC0.h"
-#include "src/E890.h"
+#include "src/F420.h"
 #include "src/fragments/2/fragment2.h"
 #include "src/fragments/5/fragment5.h"
 #include "src/stage_loader.h"
diff --git a/src/fragments/11/fragment11_1.c b/src/fragments/11/fragment11_1.c
index 97b2e53..f9b0bf0 100644
--- a/src/fragments/11/fragment11_1.c
+++ b/src/fragments/11/fragment11_1.c
@@ -1,6 +1,7 @@
 #include "fragment11.h"
 #include "src/49790.h"
 #include "src/6A40.h"
+#include "src/F420.h"
 #include "src/fragments/2/fragment2.h"
 #include "src/fragments/5/fragment5.h"
 
diff --git a/src/fragments/2/fragment2_1.c b/src/fragments/2/fragment2_1.c
index 5043c58..8fe7d67 100644
--- a/src/fragments/2/fragment2_1.c
+++ b/src/fragments/2/fragment2_1.c
@@ -64,7 +64,7 @@ void func_87802360(s16 arg0, s16 arg1, f32* arg2, f32* arg3) {
                 }
             }
 
-            var_fv0 *= ABS_ALT(gSineTable[((u16)temp_ft1 & 0xFFFF) >> 4]);
+            var_fv0 *= ABS_ALT(SINS((temp_ft1 & 0xFFFF)));
 
             *arg3 = 1.0f - var_fv0;
             *arg2 = 1.0f - var_fv0;
diff --git a/src/fragments/37/fragment37.c b/src/fragments/37/fragment37.c
index 38d5f62..5026659 100644
--- a/src/fragments/37/fragment37.c
+++ b/src/fragments/37/fragment37.c
@@ -9,7 +9,7 @@
 #include "src/4F410.h"
 #include "src/6A40.h"
 #include "src/DDC0.h"
-#include "src/E890.h"
+#include "src/F420.h"
 #include "src/controller.h"
 #include "src/memory.h"
 #include "src/stage_loader.h"
@@ -230,8 +230,8 @@ void func_82200A5C(void) {
 
         temp_fv0 = (D_82203160[0].unk_06 * D_82203160[0].unk_04) / 100;
 
-        D_82203160[i].unk_0C[0].unk_00 = D_82203160[0].unk_00 + (gCosineTable[(var_v0 & 0xFFFF) >> 4] * temp_fv0);
-        D_82203160[i].unk_0C[0].unk_02 = D_82203160[0].unk_02 + (gSineTable[(var_v0 & 0xFFFF) >> 4] * temp_fv0);
+        D_82203160[i].unk_0C[0].unk_00 = D_82203160[0].unk_00 + (COSS((var_v0)) * temp_fv0);
+        D_82203160[i].unk_0C[0].unk_02 = D_82203160[0].unk_02 + (SINS((var_v0)) * temp_fv0);
         D_82203160[i].unk_0C[0].unk_04 = (D_82203160[0].unk_06 * 0x48) / 100;
 
         var_v0 -= 0x5555;
diff --git a/src/fragments/6/fragment6.c b/src/fragments/6/fragment6.c
index cc5bde2..3c17d92 100644
--- a/src/fragments/6/fragment6.c
+++ b/src/fragments/6/fragment6.c
@@ -18,7 +18,7 @@
 #include "src/20470.h"
 #include "src/6BC0.h"
 #include "src/2E110.h"
-#include "src/E890.h"
+#include "src/F420.h"
 #include "src/12D80.h"
 #include "src/17300.h"
 
diff --git a/src/fragments/8/fragment8.c b/src/fragments/8/fragment8.c
index 9b907cf..88b4668 100644
--- a/src/fragments/8/fragment8.c
+++ b/src/fragments/8/fragment8.c
@@ -14,7 +14,7 @@
 #include "src/6BC0.h"
 #include "src/4BDC0.h"
 #include "src/6A40.h"
-#include "src/E890.h"
+#include "src/F420.h"
 #include "src/4BA90.h"
 #include "src/490A0.h"
 #include "src/30640.h"
diff --git a/src/fragments/9/fragment9.c b/src/fragments/9/fragment9.c
index ea84645..a01cba6 100644
--- a/src/fragments/9/fragment9.c
+++ b/src/fragments/9/fragment9.c
@@ -12,7 +12,7 @@
 #include "src/3FB0.h"
 #include "src/6A40.h"
 #include "src/6BC0.h"
-#include "src/E890.h"
+#include "src/F420.h"
 #include "src/controller.h"
 #include "src/fragments/2/fragment2.h"
 #include "src/fragments/4/fragment4.h"
diff --git a/src/main.c b/src/main.c
index c273e28..820e834 100644
--- a/src/main.c
+++ b/src/main.c
@@ -14,8 +14,7 @@ u8 unk_8007F330[0x400];
 OSThread pThreads;
 u8 unk_8007F8E0[0x720];
 u8 D_80080000[0x18E0];
-u8 D_800818E0[0x18];
-u8 D_800818F8[0x8];
+u8 D_800818E0[0x20];
 
 /**
  * Initialize hardware, start main thread, then idle.
diff --git a/yamls/us/rom.yaml b/yamls/us/rom.yaml
index 92bc045..d6c2dd0 100644
--- a/yamls/us/rom.yaml
+++ b/yamls/us/rom.yaml
@@ -54,6 +54,7 @@
     - [0xE1C0, c]
     - [0xE570, c] #
     - [0xE890, c] #
+    - [0xF420, c] #
     - [0x11BA0, c] #  
     - [0x12D80, c] # 
     - [0x17300, c] #
@@ -340,10 +341,12 @@
     - [0x6A3E0, data, rom_data_6A3E0]
     - [0x6A3F0, .data, math_util]
     - [0x6FC00, data, rom_data_6FC00]
+    - [0x6FC50, .data, F420]
     - [0x6FC80, .data, 12D80]
     - [0x6FEB0, data, rom_data_6FEB0]
     - [0x70070, .data, 20470]
     - [0x703E0, data, rom_data_703E0]
+    - [0x74260, data, rom_data_74260]
     - [0x76260, .data, 29BA0]
     - [0x76280, data, rom_data_76280]
     - [0x78570, .data, 373A0]
@@ -406,7 +409,7 @@
     - [0x7BFA0, .rodata, profiler]
     - [0x7BFC0, .rodata, gb_tower]
     - [0x7C000, rodata, rom_rodata_7C000]
-    - [0x7C180, rodata, rom_rodata_7C180]
+    - [0x7C180, .rodata, F420]
     - [0x7C190, rodata, rom_rodata_7C190]
     - [0x7C220, rodata, rom_rodata_7C220]
     - [0x7C750, rodata, rom_rodata_7C750]