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/global.h b/include/global.h
index a137740..7559615 100644
--- a/include/global.h
+++ b/include/global.h
@@ -84,7 +84,12 @@ typedef struct unk_D_86002F58_004_000_054 {
     /* 0x04 */ unk_D_86002F58_004_000_054_004* unk_04;
     /* 0x08 */ s16 unk_08;
     /* 0x0A */ s16 unk_0A;
-} unk_D_86002F58_004_000_054; // size >= 0xC
+} unk_D_86002F58_004_000_054; // size = 0xC
+
+typedef struct unk_D_86002F58_004_000_0A8 {
+    /* 0x00 */ u16 unk_00;
+    /* 0x04 */ Vec3f unk_04;
+} unk_D_86002F58_004_000_0A8; // size = 0x10
 
 typedef struct unk_D_86002F58_004_000 {
     /* 0x000 */ unk_D_86002F58_004_000_000 unk_000;
@@ -95,18 +100,17 @@ typedef struct unk_D_86002F58_004_000 {
     /* 0x01E */ Vec3s unk_01E;
     /* 0x024 */ Vec3f unk_024;
     /* 0x030 */ Vec3f unk_030;
-    /* 0x03C */ s32 unk_03C;
+    /* 0x03C */ Color_RGBA8_u32 unk_03C;
     /* 0x040 */ unk_D_86002F58_004_000_040 unk_040;
     /* 0x050 */ char pad050[2];
     /* 0x052 */ s16 unk_052;
     /* 0x054 */ unk_D_86002F58_004_000_054 unk_054;
-    /* 0x060 */ s32 unk_060;
-    /* 0x064 */ char pad064[0x3C];
-    /* 0x0A0 */ s32 unk_0A0;
+    /* 0x060 */ MtxF unk_060;
+    /* 0x0A0 */ Color_RGBA8_u32 unk_0A0;
     /* 0x0A4 */ char pad0A4[2];
-    /* 0x0A6 */ s8 unk_0A6;
-    /* 0x0A7 */ char pad0A7[5];
-    /* 0x0AC */ Vec3f unk_0AC;
+    /* 0x0A6 */ u8 unk_0A6;
+    /* 0x0A7 */ u8 unk_0A7;
+    /* 0x0A8 */ unk_D_86002F58_004_000_0A8 unk_0A8[1];
     /* 0x0B8 */ char pad0B8[0x24];
     /* 0x0DC */ Vec3f unk_0DC;
     /* 0x0E0 */ char pad0E0[0x4];
@@ -114,26 +118,182 @@ typedef struct unk_D_86002F58_004_000 {
     /* 0x0F8 */ char pad0F8[0x70];
 } unk_D_86002F58_004_000; // size = 0x168
 
+typedef struct unk_D_86002F34_000 {
+    /* 0x00 */ u8 unk_00;
+    /* 0x01 */ u8 unk_01;
+    /* 0x02 */ u8 unk_02;
+    /* 0x03 */ u8 unk_03;
+    /* 0x04 */ char pad04[0x4];
+    /* 0x08 */ struct unk_D_86002F34_000* unk_08;
+    /* 0x0C */ struct unk_D_86002F34_000* unk_0C;
+    /* 0x10 */ s32 (*unk_10)(s32, struct unk_D_86002F34_000*);
+    /* 0x14 */ char unk14[0x4];
+} unk_D_86002F34_000; // size >= 0x18
+
+typedef struct unk_D_86002F34_00C_018 {
+    /* 0x00 */ Vp* vp;
+    /* 0x04 */ s16 x;
+    /* 0x06 */ s16 y;
+    /* 0x08 */ s16 width;
+    /* 0x0A */ s16 height;
+} unk_D_86002F34_00C_018; // size = 0xC
+
+typedef struct unk_D_86002F34_00C_024 {
+    /* 0x00 */ Mtx* mtx;
+    /* 0x04 */ u16 perspNorm;
+    /* 0x08 */ f32 fovy;
+    /* 0x0C */ f32 aspect;
+    /* 0x10 */ f32 near;
+    /* 0x14 */ f32 far;
+    /* 0x18 */ f32 scale;
+} unk_D_86002F34_00C_024; // size = 0x1C
+
+typedef struct unk_D_86002F34_00C_040 {
+    /* 0x00 */ Mtx* mtx;
+    /* 0x04 */ f32 l;
+    /* 0x08 */ f32 r;
+    /* 0x0C */ f32 b;
+    /* 0x10 */ f32 t;
+    /* 0x14 */ f32 n;
+    /* 0x18 */ f32 f;
+    /* 0x1C */ f32 scale;
+} unk_D_86002F34_00C_040; // size = 0x20
+
+typedef struct unk_D_86002F34_00C_060 {
+    /* 0x00 */ MtxF* p_mtxf;
+    /* 0x04 */ MtxF mtxf;
+    /* 0x44 */ LookAt* lookat;
+    /* 0x48 */ Vec3f eye;
+    /* 0x54 */ Vec3f at;
+    /* 0x60 */ Vec3f up;
+} unk_D_86002F34_00C_060; // size >= 0x6C
+
+typedef struct unk_D_86002F34_00C_0CC {
+    /* 0x00 */ u16 unk_00;
+    /* 0x02 */ u16 unk_02;
+    /* 0x04 */ Color_RGBA8_u32 color;
+    /* 0x08 */ u16 unk_08;
+    /* 0x0A */ u16 unk_0A;
+    /* 0x0C */ s16 unk_0C;
+    /* 0x0E */ s16 unk_0E;
+    /* 0x10 */ s16 unk_10;
+    /* 0x12 */ s16 unk_12;
+    /* 0x14 */ s16 unk_14;
+    /* 0x16 */ s16 unk_16;
+    /* 0x18 */ s16 unk_18;
+    /* 0x1A */ s16 unk_1A;
+    /* 0x1C */ u8* texture;
+} unk_D_86002F34_00C_0CC; // size >= 0x20
+
 typedef struct unk_D_86002F34_00C {
-    /* 0x00 */ char pad0[0x24];
-    /* 0x24 */ MtxF* unk_024;
-    /* 0x28 */ u16 unk_028;
-    /* 0x2C */ f32 unk_02C;
-    /* 0x30 */ char pad30[4];
-    /* 0x34 */ f32 unk_034;
-    /* 0x38 */ f32 unk_038;
-    /* 0x3C */ char pad3C[0x24];
-    /* 0x60 */ MtxF* unk_060;
-    /* 0x64 */ MtxF unk_064;
-    /* 0xA4 */ char padA4[0x4];
-    /* 0xA8 */ Vec3f unk_0A8;
-    /* 0xB4 */ Vec3f unk_0B4;
-} unk_D_86002F34_00C; // size >= 0xC0
+    /* 0x00 */ unk_D_86002F34_000 unk_00;
+    /* 0x18 */ unk_D_86002F34_00C_018 unk_18;
+    /* 0x24 */ unk_D_86002F34_00C_024 unk_24;
+    /* 0x40 */ unk_D_86002F34_00C_040 unk_40;
+    /* 0x60 */ unk_D_86002F34_00C_060 unk_60;
+    /* 0xCC */ unk_D_86002F34_00C_0CC unk_CC;
+} unk_D_86002F34_00C; // size >= 0xEC
+
+typedef struct unk_D_86002F34_alt1 {
+    /* 0x00 */ unk_D_86002F34_000 unk_00;
+    /* 0x18 */ s16 unk_18;
+    /* 0x1A */ u16 unk_1A;
+    /* 0x1C */ s8 unk_1C;
+    /* 0x1D */ s8 unk_1D;
+    /* 0x20 */ s32 unk_20;
+    /* 0x24 */ Lights7* lights;
+} unk_D_86002F34_alt1; // size >= 0x28
+
+typedef struct unk_D_86002F34_alt2 {
+    /* 0x00 */ unk_D_86002F34_000 unk_00;
+    /* 0x18 */ u32 unk_18;
+} unk_D_86002F34_alt2; // size >= 0x1C
+
+typedef struct unk_D_86002F34_alt3 {
+    /* 0x00 */ unk_D_86002F34_000 unk_00;
+    /* 0x18 */ s16 unk_18;
+    /* 0x1A */ s16 unk_1A;
+    /* 0x1C */ s32 unk_1C;
+} unk_D_86002F34_alt3; // size >= 0x20
+
+typedef struct unk_D_86002F34_alt4 {
+    /* 0x00 */ unk_D_86002F34_000 unk_00;
+    /* 0x18 */ Color_RGBA8_u32 unk_18;
+    /* 0x1C */ u16 unk_1C;
+    /* 0x1E */ u16 unk_1E;
+} unk_D_86002F34_alt4; // size >= 0x20
+
+typedef struct unk_D_86002F34_alt5 {
+    /* 0x00 */ unk_D_86002F34_000 unk_00;
+    /* 0x18 */ Vec3f unk_18;
+    /* 0x24 */ Vec3s unk_24;
+} unk_D_86002F34_alt5; // size >= 0x2C
+
+typedef struct unk_D_86002F34_alt6 {
+    /* 0x00 */ unk_D_86002F34_000 unk_00;
+    /* 0x18 */ Vec3s unk_18;
+    /* 0x1E */ Vec3s unk_1E;
+    /* 0x24 */ Vec3f unk_24;
+    /* 0x30 */ u8 unk_30;
+    /* 0x31 */ u8 unk_31;
+    /* 0x32 */ s16 unk_32;
+} unk_D_86002F34_alt6; // size >= 0x58
+
+typedef struct unk_D_86002F34_alt7 {
+    /* 0x00 */ unk_D_86002F34_000 unk_00;
+    /* 0x18 */ Gfx* unk_18;
+    /* 0x1C */ s16 unk_1C;
+} unk_D_86002F34_alt7; // size >= 0x20
+
+typedef struct unk_D_86002F34_alt8 {
+    /* 0x00 */ unk_D_86002F34_000 unk_00;
+    /* 0x18 */ Gfx* unk_18;
+    /* 0x1C */ MtxF unk_1C;
+} unk_D_86002F34_alt8; // size >= 0x5C
+
+typedef struct unk_D_86002F34_alt9 {
+    /* 0x00 */ unk_D_86002F34_000 unk_00;
+    /* 0x18 */ Gfx* unk_18;
+    /* 0x1C */ Vec3f unk_1C;
+    /* 0x28 */ f32 unk_28;
+} unk_D_86002F34_alt9; // size >= 0x2C
+
+typedef struct unk_D_86002F34_alt10 {
+    /* 0x00 */ unk_D_86002F34_000 unk_00;
+    /* 0x18 */ s32 unk_18;
+    /* 0x1C */ s16 unk_1C;
+    /* 0x1E */ s16 unk_1E;
+    /* 0x20 */ s16 unk_20;
+    /* 0x22 */ u8 unk_22;
+    /* 0x24 */ Color_RGBA8_u32 unk_24;
+} unk_D_86002F34_alt10; // size >= 0x28
+
+typedef struct unk_D_86002F34_alt11_018 {
+    /* 0x00 */ u8 fmt;
+    /* 0x01 */ u8 unk_01;
+    /* 0x02 */ s16 unk_02;
+    /* 0x04 */ char unk04[0x4];
+    /* 0x08 */ u8* texture;
+} unk_D_86002F34_alt11_018; // size >= 0xC
+
+typedef struct unk_D_86002F34_alt11 {
+    /* 0x00 */ unk_D_86002F34_000 unk_00;
+    /* 0x18 */ unk_D_86002F34_alt11_018* unk_18;
+    /* 0x1C */ unk_D_86002F34_alt11_018* unk_1C;
+} unk_D_86002F34_alt11; // size >= 0x20
+
+typedef struct unk_D_86002F34_alt12 {
+    /* 0x00 */ unk_D_86002F34_000 unk_00;
+    /* 0x18 */ s16 unk_18;
+    /* 0x1A */ s16 unk_1A;
+    /* 0x1C */ s16 unk_1C;
+    /* 0x1E */ s16 unk_1E;
+} unk_D_86002F34_alt12; // size >= 0x20
 
 typedef struct unk_D_86002F34 {
-    /* 0x00 */ char pad00[0xC];
-    /* 0x0C */ unk_D_86002F34_00C* unk_0C;
-} unk_D_86002F34; // size >= 0x10
+    /* 0x00 */ unk_D_86002F34_000 unk_00;
+    /* 0x18 */ unk_D_86002F34_000* unk_18;
+} unk_D_86002F34; // size >= 0x1C
 
 // Are unk_D_86002F30 and unk_D_800AC840 the same?
 typedef struct unk_D_86002F30 {
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 ad41b2a..bcff160 100644
--- a/include/variables.h
+++ b/include/variables.h
@@ -51,7 +51,15 @@ extern u8 gPool[];
 extern Gfx* gDisplayListHead;
 extern u64 _binary_assets_us_F3DEX2_bin_start[];
 
+extern f32 gSineTable[];
+extern f32 gCosineTable[0x1000];
+extern s16 gArctanTable[0x401];
+
 extern u8 D_1000000[];
+extern u8 D_1001800[];
+extern Gfx D_1002480[];
+extern Gfx D_1002508[];
+extern Gfx D_1002590[];
 extern u8 D_2000000[];
 extern u8 D_3000000[];
 extern u8 D_4000000[];
@@ -71,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;
@@ -86,7 +96,6 @@ extern unk_D_80068BA0* D_80068BA8;
 extern unk_D_80068BA0* D_80068BAC;
 extern Gfx D_8006F518[];
 extern Gfx D_8006F630[];
-
 extern u8 D_82000000;
 extern u8 D_81400000;
 extern u8 D_86B00000;
@@ -111,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/lib/ultralib/include/PR/gbi.h b/lib/ultralib/include/PR/gbi.h
index 95ad82b..d37b335 100644
--- a/lib/ultralib/include/PR/gbi.h
+++ b/lib/ultralib/include/PR/gbi.h
@@ -3050,10 +3050,10 @@ _DW({									\
 }
 
 #define	gsDPSetCombine(muxs0, muxs1)					\
-{{									\
+{									\
 	_SHIFTL(G_SETCOMBINE, 24, 8) | _SHIFTL(muxs0, 0, 24),		\
 	(unsigned int)(muxs1)						\
-}}
+}
 
 #define	GCCc0w0(saRGB0, mRGB0, saA0, mA0)				\
 		(_SHIFTL((saRGB0), 20, 4) | _SHIFTL((mRGB0), 15, 5) | 	\
diff --git a/linker_scripts/us/symbol_addrs.txt b/linker_scripts/us/symbol_addrs.txt
index e06da2f..56adc11 100644
--- a/linker_scripts/us/symbol_addrs.txt
+++ b/linker_scripts/us/symbol_addrs.txt
@@ -290,3 +290,7 @@ rspbootTextStart = 0x80065FC0;
 aspMainTextStart = 0x80067420;
 aspMainDataStart = 0x8007EA70;
 audDMAMessageQ = 0x800FCAE0;
+D_8006F010 = 0x8006F010; // size:0x40
+D_8006F050 = 0x8006F050; // size:0xC
+D_8006F05C = 0x8006F05C; // size:0x6
+D_8006F064 = 0x8006F064; // size:0xC
diff --git a/src/11BA0.c b/src/11BA0.c
index 1d47a3f..c4beac0 100644
--- a/src/11BA0.c
+++ b/src/11BA0.c
@@ -82,8 +82,8 @@ unk_D_86002F58_004_000* func_80011938(MainPoolState* arg0, unk_D_86002F58_004_00
         arg1->unk_01D = 0xFF;
         arg1->unk_01C = 0;
         arg1->unk_0A6 = 0;
-        arg1->unk_0A0 = -0x100;
-        arg1->unk_03C = -0x100;
+        arg1->unk_0A0.rgba = 0xFFFFFF00;
+        arg1->unk_03C.rgba = 0xFFFFFF00;
         arg1->unk_040.unk_00 = 0;
         arg1->unk_040.unk_04 = NULL;
         arg1->unk_040.unk_08 = 0;
diff --git a/src/12D80.c b/src/12D80.c
index 4122632..ba1493e 100644
--- a/src/12D80.c
+++ b/src/12D80.c
@@ -1,146 +1,1522 @@
-#include "global.h"
 #include "12D80.h"
+#include "src/12D80.h"
+#include "src/1CF30.h"
+#include "src/1CF30.h"
+#include "src/17300.h"
+#include "src/18140.h"
+#include "src/6A40.h"
+#include "src/6BC0.h"
+#include "src/32D10.h"
+#include "src/F420.h"
+#include "src/memmap.h"
+#include "src/util.h"
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80012180.s")
+typedef void (*func_D_8006F0A4)(unk_D_86002F34_000* arg0);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_800121C8.s")
+typedef struct unk_D_800AA8C8 {
+    /* 0x0000 */ MtxF unk_0000[64];
+    /* 0x1000 */ MtxF* unk_1000[32];
+    /* 0x1080 */ s8 unk_1080[32];
+    /* 0x10A0 */ s32 unk_10A0;
+} unk_D_800AA8C8; // size >= 0x10A4
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80012230.s")
+s32 D_8006F080 = 0;
+u16 D_8006F084 = 0;
+unk_D_86002F34_00C* D_8006F088 = NULL;
+unk_D_86002F34_alt1* D_8006F08C = NULL;
+unk_D_86002F34_alt1* D_8006F090 = NULL;
+unk_D_86002F34_00C* D_8006F094 = NULL;
+unk_D_86002F34_alt1* D_8006F098 = NULL;
+unk_D_86002F58_004_000* D_8006F09C = NULL;
+unk_D_86002F34_alt11* D_8006F0A0 = NULL;
+func_D_8006F0A4 D_8006F0A4[] = {
+    func_80013330, func_800133D8, func_80013464, func_80013764, func_8001378C, func_8001395C, func_800139E8,
+    func_80013AF8, func_80013B8C, func_80013C14, func_80013C1C, func_80013D34, func_80013F7C, func_80013F84,
+    func_80014124, func_80014D70, func_80014214, func_800142BC, func_80014334, func_80014384, func_800143C0,
+    func_80014624, func_80014690, func_800148D8, func_80014980, func_80014A60, func_80014AEC, func_80014D24,
+    func_80014D50, NULL,          NULL,
+};
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_800122B4.s")
+s32 D_8006F120 = 0;
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80012344.s")
+u32 D_8006F124[4][9] = {
+    {
+        0x3024000,
+        0x3024000,
+        0x3024000,
+        0x3024000,
+        0x3027008,
+        0x104240,
+        0x104240,
+        0x104240,
+        0x104240,
+    },
+    {
+        0x3124370,
+        0x112230,
+        0x112E10,
+        0x112230,
+        0x113238,
+        0x104A50,
+        0x104E50,
+        0x104A50,
+        0x104A70,
+    },
+    {
+        0x3024000,
+        0x112048,
+        0x112048,
+        0x112048,
+        0x113048,
+        0x1041C8,
+        0x1041C8,
+        0x1041C8,
+        0x1041C8,
+    },
+    {
+        0x3124370,
+        0x112078,
+        0x112D58,
+        0x112478,
+        0x113078,
+        0x1049D8,
+        0x104DD8,
+        0x1045D8,
+        0x1049F8,
+    },
+};
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_800123D4.s")
+u8 D_8006F1B4[15][16] = {
+    { 0x1F, 0x1F, 0x1F, 3, 7, 7, 7, 3, 0, 0x1F, 4, 0x1F, 0, 7, 6, 7 },
+    { 1, 0x1F, 3, 0x1F, 7, 7, 7, 1, 0, 0x1F, 4, 0x1F, 0, 7, 6, 7 },
+    { 1, 3, 8, 3, 7, 7, 3, 7, 0, 0x1F, 4, 0x1F, 0, 7, 6, 7 },
+    { 1, 0x1F, 3, 0x1F, 7, 7, 7, 3, 0, 0x1F, 4, 0x1F, 0, 7, 6, 7 },
+    { 1, 0x1F, 3, 0x1F, 1, 7, 3, 7, 0, 0x1F, 4, 0x1F, 0, 7, 6, 7 },
+    { 0x1F, 0x1F, 0x1F, 3, 7, 7, 7, 3, 0x1F, 0x1F, 0x1F, 0, 0, 7, 6, 7 },
+    { 1, 0x1F, 3, 0x1F, 7, 7, 7, 1, 0x1F, 0x1F, 0x1F, 0, 0, 7, 6, 7 },
+    { 1, 3, 8, 3, 7, 7, 3, 7, 0x1F, 0x1F, 0x1F, 0, 0, 7, 6, 7 },
+    { 1, 0x1F, 3, 0x1F, 7, 7, 7, 3, 0x1F, 0x1F, 0x1F, 0, 0, 7, 6, 7 },
+    { 1, 0x1F, 3, 0x1F, 1, 7, 3, 7, 0x1F, 0x1F, 0x1F, 0, 0, 7, 6, 7 },
+    { 0x1F, 0x1F, 0x1F, 4, 7, 7, 7, 4, 0x1F, 0x1F, 0x1F, 0, 0, 7, 6, 7 },
+    { 1, 0x1F, 4, 0x1F, 7, 7, 7, 1, 0x1F, 0x1F, 0x1F, 0, 0, 7, 6, 7 },
+    { 1, 4, 8, 4, 7, 7, 3, 7, 0x1F, 0x1F, 0x1F, 0, 0, 7, 6, 7 },
+    { 1, 0x1F, 4, 0x1F, 7, 7, 7, 4, 0x1F, 0x1F, 0x1F, 0, 0, 7, 6, 7 },
+    { 1, 0x1F, 4, 0x1F, 1, 7, 4, 7, 0x1F, 0x1F, 0x1F, 0, 0, 7, 6, 7 },
+};
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80012400.s")
+s16 D_8006F2A4[] = { 16, 8, 4, 2, 0, 0 };
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80012428.s")
+s32 D_800AA6C0;
+MtxF* D_800AA6C8[8];
+u8 pad_D_800AA6E8[0x1E0];
+unk_D_800AA8C8 D_800AA8C8;
+unk_D_800AB970 D_800AB970;
+s32 D_800ABB00;
+s32 D_800ABB04;
+s32 D_800ABB08;
+unk_D_800ABB10 D_800ABB10;
+unk_D_800ABB28 D_800ABB28[10];
+unk_D_800ABB28* D_800ABCB8;
+s32 D_800ABCBC;
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80012458.s")
+void func_80012180(void) {
+    D_800AA8C8.unk_10A0 = 0;
+    D_800AA8C8.unk_1080[0] = 0;
+    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);
+}
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_800124D4.s")
+void func_800121C8(void) {
+    D_800AA8C8.unk_1080[D_800AA8C8.unk_10A0] = 0;
+    D_800AA8C8.unk_1000[D_800AA8C8.unk_10A0] = func_80005F5C(sizeof(MtxF) * 1);
+    func_80010090(D_800AA8C8.unk_1000[D_800AA8C8.unk_10A0], &D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0]);
+}
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80012768.s")
+void func_80012230(MtxF* arg0) {
+    func_8000ED4C(&D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0], arg0);
+    D_800AA8C8.unk_1080[D_800AA8C8.unk_10A0] = 0;
+    D_800AA8C8.unk_1000[D_800AA8C8.unk_10A0] = func_80005F5C(sizeof(MtxF) * 1);
+    func_80010090(D_800AA8C8.unk_1000[D_800AA8C8.unk_10A0], &D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0]);
+}
 
+void func_800122B4(MtxF* arg0) {
+    MtxF* temp_a0;
+
+    D_800AA8C8.unk_10A0++;
+    temp_a0 = &D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0];
+
+    func_8000FBB0(&temp_a0[0], arg0, &temp_a0[-1]);
+    D_800AA8C8.unk_1080[D_800AA8C8.unk_10A0] = 0;
+    D_800AA8C8.unk_1000[D_800AA8C8.unk_10A0] = func_80005F5C(sizeof(MtxF) * 1);
+    func_80010090(D_800AA8C8.unk_1000[D_800AA8C8.unk_10A0], &D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0]);
+}
+
+void func_80012344(Vec3f* arg0) {
+    MtxF* temp_a0;
+
+    D_800AA8C8.unk_10A0++;
+    temp_a0 = &D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0];
+
+    func_8000FDE4(&temp_a0[0], &temp_a0[-1], arg0);
+
+    D_800AA8C8.unk_1080[D_800AA8C8.unk_10A0] = 0;
+    D_800AA8C8.unk_1000[D_800AA8C8.unk_10A0] = func_80005F5C(sizeof(MtxF) * 1);
+
+    func_80010090(D_800AA8C8.unk_1000[D_800AA8C8.unk_10A0], &D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0]);
+}
+
+MtxF* func_800123D4(s32 arg0) {
+    MtxF* var_v1 = NULL;
+
+    if (arg0 <= 0) {
+        var_v1 = &(&D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0])[arg0];
+    }
+
+    return var_v1;
+}
+
+MtxF* func_80012400(s32 arg0) {
+    MtxF* var_v1 = NULL;
+
+    if ((arg0 >= 0) && (arg0 < 0x20)) {
+        var_v1 = &D_800AA8C8.unk_0000[arg0];
+    }
+
+    return var_v1;
+}
+
+void func_80012428(void) {
+    D_800AB970.unk_180 = 0;
+    D_800AB970.unk_000[0] = D_8006F064;
+}
+
+void func_80012458(Vec3f* arg0) {
+    D_800AB970.unk_000[D_800AB970.unk_180 + 1].x = D_800AB970.unk_000[D_800AB970.unk_180].x * arg0->x;
+    D_800AB970.unk_000[D_800AB970.unk_180 + 1].y = D_800AB970.unk_000[D_800AB970.unk_180].y * arg0->y;
+    D_800AB970.unk_000[D_800AB970.unk_180 + 1].z = D_800AB970.unk_000[D_800AB970.unk_180].z * arg0->z;
+
+    D_800AB970.unk_180++;
+}
+
+Vtx* func_800124D4(unk_D_86002F34_00C_0CC* arg0, unk_D_86002F34_00C_040* arg1) {
+    u8 sp47;
+    Vtx* temp_v0 = func_80005F5C(sizeof(Vtx) * 4);
+
+    if (temp_v0 != NULL) {
+        switch (arg0->unk_00) {
+            case 1:
+                sp47 = 0xFF;
+                break;
+
+            case 2:
+                sp47 = 0xFF - ((arg0->unk_0A * 0xFF) / arg0->unk_08);
+                break;
+
+            case 3:
+                sp47 = (arg0->unk_0A * 0xFF) / arg0->unk_08;
+                break;
+        }
+
+        func_8001E680(&temp_v0[0], arg1->l, arg1->t, -1, 0, 0, arg0->color.r, arg0->color.g, arg0->color.b, sp47);
+        func_8001E680(&temp_v0[1], arg1->l, arg1->b, -1, 0, 0, arg0->color.r, arg0->color.g, arg0->color.b, sp47);
+        func_8001E680(&temp_v0[2], arg1->r, arg1->b, -1, 0, 0, arg0->color.r, arg0->color.g, arg0->color.b, sp47);
+        func_8001E680(&temp_v0[3], arg1->r, arg1->t, -1, 0, 0, arg0->color.r, arg0->color.g, arg0->color.b, sp47);
+    }
+
+    return temp_v0;
+}
+
+void func_80012768(unk_D_86002F34_00C_0CC* arg0, unk_D_86002F34_00C_040* arg1) {
+    Vtx* temp_v0 = func_800124D4(arg0, arg1);
+
+    if (temp_v0 != NULL) {
+        gDPSetCombineMode(gDisplayListHead++, G_CC_SHADE, G_CC_SHADE);
+        gDPSetRenderMode(gDisplayListHead++, G_RM_AA_XLU_SURF, G_RM_AA_XLU_SURF2);
+
+        gSPVertex(gDisplayListHead++, (u32)temp_v0 & 0x1FFFFFFF, 4, 0);
+        gSP2Triangles(gDisplayListHead++, 0, 1, 2, 0, 0, 2, 3, 0);
+    }
+
+    if (arg0->unk_00 != 1) {
+        arg0->unk_0A++;
+        if (arg0->unk_0A == arg0->unk_08) {
+            if (arg0->unk_00 == 2) {
+                arg0->unk_00 = 0;
+            } else {
+                arg0->unk_00 = 1;
+            }
+        }
+    }
+}
+
+#ifdef NON_MATCHING
+void func_80012870(Vtx* arg0, unk_D_86002F34_00C_0CC* arg1, s16 arg2, s16 arg3, s16 arg4, s16 arg5, s16 arg6,
+                   s16 arg7) {
+    f32 temp_fa0;
+    f32 temp_fv1;
+    u16 idx = arg1->unk_18;
+    f32 a4;
+    f32 a5;
+    s16 tmp1;
+    s16 tmp2;
+
+    a4 = arg4;
+    temp_fv1 = COSS(idx);
+    temp_fa0 = SINS(idx);
+    a5 = arg5;
+
+    tmp1 = ((a4 * temp_fv1) - (temp_fa0 * a5));
+    tmp2 = ((temp_fv1 * a5) + (a4 * temp_fa0));
+
+    func_8001E680(arg0, tmp1 + arg2, tmp2 + arg3, -1, arg6 * 32, arg7 * 32, arg1->color.r, arg1->color.g, arg1->color.b,
+                  0xFF);
+}
+#else
+void func_80012870(Vtx* arg0, unk_D_86002F34_00C_0CC* arg1, s16 arg2, s16 arg3, s16 arg4, s16 arg5, s16 arg6, s16 arg7);
 #pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80012870.s")
+#endif
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80012960.s")
+Vtx* func_80012960(unk_D_86002F34_00C_0CC* arg0) {
+    Vtx* temp_v0 = func_80005F5C(sizeof(Vtx) * 8);
+    Vtx* temp_s0;
+    s16 temp_s2;
+    s16 temp_s4;
+    s16 temp_s5;
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80012D88.s")
+    if (temp_v0 != NULL) {
+        temp_s0 = temp_v0;
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_800131B4.s")
+        temp_s4 = arg0->unk_10 + (((arg0->unk_14 - arg0->unk_10) * arg0->unk_0A) / arg0->unk_08);
+        temp_s5 = arg0->unk_12 + (((arg0->unk_16 - arg0->unk_12) * arg0->unk_0A) / arg0->unk_08);
+        temp_s2 = arg0->unk_0C + (((arg0->unk_0E - arg0->unk_0C) * arg0->unk_0A) / arg0->unk_08);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80013330.s")
+        if (arg0->unk_00 == 2) {
+            func_80012870(temp_s0++, arg0, temp_s4, temp_s5, -temp_s2, -temp_s2, -0x1F, 0x3F);
+            func_80012870(temp_s0++, arg0, temp_s4, temp_s5, temp_s2, -temp_s2, 0x1F, 0x3F);
+            func_80012870(temp_s0++, arg0, temp_s4, temp_s5, temp_s2, temp_s2, 0x1F, 0);
+            func_80012870(temp_s0++, arg0, temp_s4, temp_s5, -temp_s2, temp_s2, -0x1F, 0);
+        } else {
+            func_80012870(temp_s0++, arg0, temp_s4, temp_s5, -temp_s2, -temp_s2, 0, 0x3F);
+            func_80012870(temp_s0++, arg0, temp_s4, temp_s5, temp_s2, -temp_s2, 0x3F, 0x3F);
+            func_80012870(temp_s0++, arg0, temp_s4, temp_s5, temp_s2, temp_s2, 0x3F, 0);
+            func_80012870(temp_s0++, arg0, temp_s4, temp_s5, -temp_s2, temp_s2, 0, 0);
+        }
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_800133D8.s")
+        func_80012870(temp_s0++, arg0, temp_s4, temp_s5, -0x7D0, -0x7D0, 0, 0);
+        func_80012870(temp_s0++, arg0, temp_s4, temp_s5, 0x7D0, -0x7D0, 0, 0);
+        func_80012870(temp_s0++, arg0, temp_s4, temp_s5, 0x7D0, 0x7D0, 0, 0);
+        func_80012870(temp_s0++, arg0, temp_s4, temp_s5, -0x7D0, 0x7D0, 0, 0);
+    }
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80013464.s")
+    arg0->unk_18 += arg0->unk_1A;
+    return temp_v0;
+}
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80013764.s")
+void func_80012D88(unk_D_86002F34_00C_0CC* arg0, UNUSED unk_D_86002F34_00C_040* arg1) {
+    Vtx* temp_v0 = func_80012960(arg0);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_8001378C.s")
+    if (temp_v0 != 0) {
+        gDPSetCombineMode(gDisplayListHead++, G_CC_SHADE, G_CC_SHADE);
+        gDPSetRenderMode(gDisplayListHead++, G_RM_AA_OPA_SURF, G_RM_AA_OPA_SURF2);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_800138F0.s")
+        gSPVertex(gDisplayListHead++, (u32)temp_v0 & 0x1FFFFFFF, 8, 0);
+        gSP2Triangles(gDisplayListHead++, 0, 4, 1, 0, 1, 4, 5, 0);
+        gSP2Triangles(gDisplayListHead++, 1, 5, 2, 0, 2, 5, 6, 0);
+        gSP2Triangles(gDisplayListHead++, 2, 6, 7, 0, 2, 7, 3, 0);
+        gSP2Triangles(gDisplayListHead++, 3, 4, 0, 0, 3, 7, 4, 0);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_8001395C.s")
+        gDPPipeSync(gDisplayListHead++);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_800139E8.s")
+        gDPSetCombineMode(gDisplayListHead++, G_CC_MODULATEIDECALA, G_CC_MODULATEIDECALA);
+        gDPSetRenderMode(gDisplayListHead++, G_RM_AA_XLU_SURF, G_RM_AA_XLU_SURF2);
+        gDPSetTextureFilter(gDisplayListHead++, G_TF_BILERP);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80013AF8.s")
+        if (arg0->unk_02 == 0) {
+            gDPLoadTextureBlock(gDisplayListHead++, arg0->texture, G_IM_FMT_IA, G_IM_SIZ_8b, 64, 64, 0,
+                                G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, 6, 6, G_TX_NOLOD, G_TX_NOLOD);
+        } else {
+            gDPLoadTextureBlock(gDisplayListHead++, arg0->texture, G_IM_FMT_IA, G_IM_SIZ_8b, 32, 64, 0,
+                                G_TX_MIRROR | G_TX_WRAP, G_TX_MIRROR | G_TX_WRAP, 5, 6, G_TX_NOLOD, G_TX_NOLOD);
+        }
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80013B8C.s")
+        gSPTexture(gDisplayListHead++, 0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80013C14.s")
+        gSPVertex(gDisplayListHead++, (u32)temp_v0 & 0x1FFFFFFF, 4, 0);
+        gSP2Triangles(gDisplayListHead++, 0, 1, 2, 0, 0, 2, 3, 0);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80013C1C.s")
+        gSPTexture(gDisplayListHead++, 0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF);
+        gDPSetTextureFilter(gDisplayListHead++, G_TF_BILERP);
+    }
 
+    arg0->unk_0A++;
+    if (arg0->unk_0A == arg0->unk_08) {
+        if (arg0->unk_00 == 4) {
+            arg0->unk_00 = 0;
+        } else {
+            arg0->unk_00 = 1;
+        }
+    }
+}
+
+void func_800131B4(unk_D_86002F34_00C_0CC* arg0, unk_D_86002F34_00C_040* arg1) {
+    if (arg0->unk_00 != 0) {
+        gDPPipeSync(gDisplayListHead++);
+
+        gDPSetCycleType(gDisplayListHead++, G_CYC_1CYCLE);
+        gSPClearGeometryMode(gDisplayListHead++, G_ZBUFFER | G_LIGHTING);
+        gSPPerspNormalize(gDisplayListHead++, 0xFFFF);
+        gSPMatrix(gDisplayListHead++, (u32)arg1->mtx & 0x1FFFFFFF, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
+        gSPMatrix(gDisplayListHead++, (u32)&D_8006F010 & 0x1FFFFFFF, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+
+        if ((arg0->unk_00 == 1) || (arg0->unk_00 == 2) || (arg0->unk_00 == 3)) {
+            func_80012768(arg0, arg1);
+        } else {
+            func_80012D88(arg0, arg1);
+        }
+
+        gDPPipeSync(gDisplayListHead++);
+        gDPSetCycleType(gDisplayListHead++, G_CYC_2CYCLE);
+    }
+}
+
+void func_80013330(unk_D_86002F34_000* arg0) {
+    unk_D_86002F34_000* temp_s2 = arg0->unk_0C;
+    unk_D_86002F34_000* var_s0 = temp_s2;
+
+    if (temp_s2 != NULL) {
+        do {
+            if (var_s0->unk_01 & 1) {
+                D_800AA6C0 = 0;
+                if (var_s0->unk_10 != NULL) {
+                    D_800AA6C0 = var_s0->unk_10(2, var_s0);
+                }
+                D_8006F0A4[var_s0->unk_00](var_s0);
+            }
+            var_s0 = var_s0->unk_08;
+        } while (var_s0 != temp_s2);
+    }
+}
+
+void func_800133D8(unk_D_86002F34_000* arg0) {
+    UNUSED s32 pad;
+    unk_D_86002F34_000* temp_a1 = ((unk_D_86002F34*)arg0)->unk_18;
+
+    if ((temp_a1 != NULL) && (temp_a1->unk_01 & 1)) {
+        D_800AA6C0 = 0;
+        if (temp_a1->unk_10 != NULL) {
+            D_800AA6C0 = temp_a1->unk_10(2, temp_a1);
+        }
+        D_8006F0A4[temp_a1->unk_00](temp_a1);
+    }
+
+    func_80013330(arg0);
+}
+
+void func_80013464(unk_D_86002F34_000* arg0) {
+    UNUSED MtxF pad_mtx;
+    unk_D_86002F34_00C* arg = (unk_D_86002F34_00C*)arg0;
+    unk_D_86002F34_00C_040* temp_s2 = &arg->unk_40;
+    unk_D_86002F34_00C_060* temp_s1 = &arg->unk_60;
+    unk_D_86002F34_00C_024* sp48 = &arg->unk_24;
+    unk_D_86002F34_00C_018* temp_s0 = &arg->unk_18;
+
+    temp_s0->vp = func_80005F5C(sizeof(Vp) * 1);
+    temp_s2->mtx = func_80005F5C(sizeof(Mtx) * 1);
+    sp48->mtx = func_80005F5C(sizeof(MtxF) * 1);
+    temp_s1->p_mtxf = func_80005F5C(sizeof(MtxF) * 1);
+    temp_s1->lookat = func_80005F5C(sizeof(LookAt) * 1);
+
+    temp_s0->vp->vp.vtrans[0] = (temp_s0->x * 4) + (temp_s0->width * 2);
+    temp_s0->vp->vp.vtrans[1] = (temp_s0->y * 4) + (temp_s0->height * 2);
+    temp_s0->vp->vp.vtrans[2] = 0x1FF;
+
+    temp_s0->vp->vp.vscale[0] = temp_s0->width * 2;
+    temp_s0->vp->vp.vscale[1] = temp_s0->height * 2;
+    temp_s0->vp->vp.vscale[2] = 0x1FF;
+
+    gSPViewport(gDisplayListHead++, (u32)temp_s0->vp & 0x1FFFFFFF);
+    gDPSetScissorFrac(gDisplayListHead++, G_SC_NON_INTERLACE, temp_s0->x * 4.0f, temp_s0->y * 4.0f,
+                      (temp_s0->x + temp_s0->width) * 4.0f, (temp_s0->y + temp_s0->height) * 4.0f);
+
+    guOrtho(temp_s2->mtx, temp_s2->l, temp_s2->r, temp_s2->b, temp_s2->t, temp_s2->n, temp_s2->f, temp_s2->scale);
+    guPerspective(sp48->mtx, &sp48->perspNorm, sp48->fovy, sp48->aspect, sp48->near, sp48->far, sp48->scale);
+    guLookAtReflectF(&temp_s1->mtxf, temp_s1->lookat, temp_s1->eye.x, temp_s1->eye.y, temp_s1->eye.z, temp_s1->at.x,
+                     temp_s1->at.y, temp_s1->at.z, temp_s1->up.x, temp_s1->up.y, temp_s1->up.z);
+    func_80010090(temp_s1->p_mtxf, &temp_s1->mtxf);
+
+    D_8006F088 = arg;
+    if ((arg->unk_CC.unk_00 != 1) && (arg->unk_00.unk_0C != NULL)) {
+        func_80013330(&arg->unk_00);
+    }
+    func_800131B4(&arg->unk_CC, temp_s2);
+    func_80006200(&gDisplayListHead);
+    D_8006F088 = NULL;
+}
+
+void func_80013764(unk_D_86002F34_000* arg0) {
+    D_8006F08C = arg0;
+    func_80013330(arg0);
+    D_8006F08C = NULL;
+}
+
+void func_8001378C(unk_D_86002F34_000* arg0) {
+    unk_D_86002F34_alt1* arg = (unk_D_86002F34_alt1*)arg0;
+
+    if (arg->unk_00.unk_0C != NULL) {
+        arg->unk_1D = 0;
+        arg->unk_20 = -1;
+        arg->lights = func_80005F5C(sizeof(Lights7));
+        arg->unk_1C = 0;
+        arg->lights->a.l.col[0] = 0;
+        arg->lights->a.l.col[1] = 0;
+        arg->lights->a.l.col[2] = 0;
+
+        gSPClearGeometryMode(gDisplayListHead++, G_ZBUFFER | G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING |
+                                                     G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH);
+        gSPSetGeometryMode(gDisplayListHead++, G_SHADE | G_CULL_BACK | G_SHADING_SMOOTH);
+        gSPTexture(gDisplayListHead++, 0, 0, 0, G_TX_RENDERTILE, G_OFF);
+        gDPSetCycleType(gDisplayListHead++, G_CYC_2CYCLE);
+
+        func_80017080();
+        func_800175D8();
+        func_80012180();
+        func_80012428();
+
+        gSPMatrix(gDisplayListHead++, (u32)D_800AA8C8.unk_1000[D_800AA8C8.unk_10A0] & 0x1FFFFFFF,
+                  G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+
+        D_8006F090 = arg;
+        func_80013330(arg0);
+        D_8006F090 = NULL;
+    }
+
+    arg->unk_1A = D_8006F084;
+}
+
+void func_800138F0(unk_D_86002F34_000* arg0) {
+    unk_D_86002F34_00C* arg = (unk_D_86002F34_00C*)arg0;
+
+    if ((D_8006F094 == NULL) && (arg->unk_00.unk_0C != NULL)) {
+        D_8006F094 = arg;
+        func_8001638C(arg->unk_00.unk_02 & 3, D_8006F080);
+        func_80013330(arg0);
+        func_8001660C();
+        D_8006F094 = NULL;
+    }
+}
+
+void func_8001395C(unk_D_86002F34_000* arg0) {
+    if ((D_8006F094 == NULL) && (arg0->unk_0C != NULL)) {
+        gSPPerspNormalize(gDisplayListHead++, 0xFFFF);
+        gSPMatrix(gDisplayListHead++, (u32)D_8006F088->unk_40.mtx & 0x1FFFFFFF,
+                  G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
+
+        func_800138F0(arg0);
+    }
+}
+
+void func_800139E8(unk_D_86002F34_000* arg0) {
+    if ((D_8006F094 == NULL) && (arg0->unk_0C != NULL)) {
+        gSPLookAt(gDisplayListHead++, (u32)&D_8006F088->unk_60.lookat->l & 0x1FFFFFFF);
+
+        gSPPerspNormalize(gDisplayListHead++, D_8006F088->unk_24.perspNorm);
+
+        gSPMatrix(gDisplayListHead++, (u32)D_8006F088->unk_24.mtx & 0x1FFFFFFF,
+                  G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
+        gSPMatrix(gDisplayListHead++, (u32)D_8006F088->unk_60.p_mtxf & 0x1FFFFFFF,
+                  G_MTX_NOPUSH | G_MTX_MUL | G_MTX_PROJECTION);
+
+        func_800138F0(arg0);
+    }
+}
+
+void func_80013AF8(unk_D_86002F34_000* arg0) {
+    unk_D_86002F34_alt2* arg = (unk_D_86002F34_alt2*)arg0;
+    unk_D_86002F34_00C_018* ptr = &D_8006F088->unk_18;
+
+    func_800065B4(&gDisplayListHead, ptr->x, ptr->y, ptr->width, ptr->height, arg->unk_18);
+
+    gDPPipeSync(gDisplayListHead++);
+    gDPSetCycleType(gDisplayListHead++, G_CYC_2CYCLE);
+}
+
+void func_80013B8C(UNUSED unk_D_86002F34_000* arg0) {
+    unk_D_86002F34_00C_018* ptr = &D_8006F088->unk_18;
+
+    func_800067E4(&gDisplayListHead, ptr->x, ptr->y, ptr->width, ptr->height);
+
+    gDPPipeSync(gDisplayListHead++);
+    gDPSetCycleType(gDisplayListHead++, G_CYC_2CYCLE);
+}
+
+void func_80013C14(UNUSED unk_D_86002F34_000* arg0) {
+}
+
+void func_80013C1C(unk_D_86002F34_000* arg0) {
+    unk_D_86002F34_alt3* arg = (unk_D_86002F34_alt3*)arg0;
+
+    D_8006F090->unk_1D = 1;
+    D_8006F090->unk_20 = arg->unk_1C;
+
+    gSPFogPosition(gDisplayListHead++, arg->unk_18, arg->unk_1A);
+    gSPSetGeometryMode(gDisplayListHead++, G_FOG);
+    gDPSetColor(gDisplayListHead++, G_SETFOGCOLOR, arg->unk_1C);
+}
+
+#ifdef NON_MATCHING
+void func_80013D34(unk_D_86002F34_000* arg0) {
+    unk_D_86002F34_alt4* arg = (unk_D_86002F34_alt4*)arg0;
+    Lights7* lights;
+    unk_D_86002F34_alt1* new_var;
+    Light* light;
+    Ambient* temp_a4;
+
+    if (D_8006F090->unk_1C >= 7) {
+        // light = &lights->l[D_8006F090->unk_1C];
+        return;
+    }
+
+    new_var = D_8006F090;
+    lights = new_var->lights;
+    temp_a4 = &lights->a;
+
+    light = &lights->l[D_8006F090->unk_1C];
+
+    *(u32*)light->l.col = arg->unk_18.rgba;
+    *(u32*)light->l.colc = arg->unk_18.rgba;
+
+    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) {
+        temp_a4->l.col[0] = 0xFF;
+    }
+
+    temp_a4->l.col[1] += ((arg->unk_18.g * arg->unk_18.a) / 100);
+    if (temp_a4->l.col[1] > 0xFF) {
+        temp_a4->l.col[1] = 0xFF;
+    }
+
+    temp_a4->l.col[2] += ((arg->unk_18.b * arg->unk_18.a) / 100);
+    if (temp_a4->l.col[2] > 0xFF) {
+        temp_a4->l.col[2] = 0xFF;
+    }
+
+    D_8006F090->unk_1C++;
+}
+#else
 #pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80013D34.s")
+#endif
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80013F7C.s")
+void func_80013F7C(UNUSED unk_D_86002F34_000* arg0) {
+}
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80013F84.s")
+void func_80013F84(unk_D_86002F34_000* arg0) {
+    unk_D_86002F34_alt4* arg = (unk_D_86002F34_alt4*)arg0;
+    s32 i;
+    Lights7* lights;
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80014124.s")
+    lights = D_8006F090->lights;
+    if ((arg->unk_18.r == 0xFF) && (arg->unk_18.g == 0xFF) && (arg->unk_18.b == 0xFF)) {
+        lights->a.l.colc[0] = lights->a.l.col[0];
+        lights->a.l.colc[1] = lights->a.l.col[1];
+        lights->a.l.colc[2] = lights->a.l.col[2];
+    } else {
+        lights->a.l.colc[0] = lights->a.l.col[0] = arg->unk_18.r;
+        lights->a.l.colc[1] = lights->a.l.col[1] = arg->unk_18.g;
+        lights->a.l.colc[2] = lights->a.l.col[2] = arg->unk_18.b;
+    }
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80014214.s")
+    gSPSetGeometryMode(gDisplayListHead++, G_LIGHTING);
+    gMoveWd(gDisplayListHead++, 2, 0, D_8006F090->unk_1C * 0x18);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_800142BC.s")
+    for (i = 0; i < D_8006F090->unk_1C; i++) {
+        gSPLight(gDisplayListHead++, &D_8006F090->lights->l[i], i + 1);
+    }
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80014334.s")
+    gSPLight(gDisplayListHead++, D_8006F090->lights, i + 1);
+}
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80014384.s")
+void func_80014124(unk_D_86002F34_000* arg0) {
+    unk_D_86002F34_alt11* arg = (unk_D_86002F34_alt11*)arg0;
+    MtxF* temp_v0 = &D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0];
+    Vec3f sp2C;
+    Vec3s sp24;
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_800143C0.s")
+    if (D_8006F09C->unk_000.unk_02 & 2) {
+        func_8000E88C(&sp2C, temp_v0->xw, 0.0f, temp_v0->zw);
+        func_8000EB70(&sp24, 0, D_8006F09C->unk_01E.y, 0);
+        func_8000F2C4(&D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0 + 1], &sp2C, &sp24);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80014624.s")
+        D_800AA8C8.unk_10A0++;
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80014690.s")
+        func_800121C8();
+        func_800160E0(0, D_800AA8C8.unk_1000[D_800AA8C8.unk_10A0]);
+        func_80016274(D_1002590, 1);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_800148D8.s")
+        D_800AA8C8.unk_10A0--;
+    }
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80014980.s")
+    D_8006F0A0 = arg;
+    func_80013330(arg0);
+    D_8006F0A0 = NULL;
+}
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80014A60.s")
+void func_80014214(unk_D_86002F34_000* arg0) {
+    unk_D_86002F34_alt3* arg = (unk_D_86002F34_alt3*)arg0;
+    MtxF* mtx2 = &D_8006F088->unk_60.mtxf;
+    f32 a = D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0].mf[3][0];
+    f32 b = D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0].mf[3][1];
+    f32 c = D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0].mf[3][2];
+    s16 temp_ft5 = ((a * mtx2->mf[0][2]) + (b * mtx2->mf[1][2]) + (c * mtx2->mf[2][2])) + mtx2->mf[3][2];
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80014AEC.s")
+    if ((temp_ft5 >= arg->unk_18) && (temp_ft5 < arg->unk_1A)) {
+        func_80013330(arg0);
+    }
+}
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80014CB8.s")
+void func_800142BC(unk_D_86002F34_000* arg0) {
+    unk_D_86002F34_alt3* arg = (unk_D_86002F34_alt3*)arg0;
+    s32 i;
+    unk_D_86002F34_000* var_a1 = arg->unk_00.unk_0C;
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80014D24.s")
+    if (var_a1 != NULL) {
+        for (i = 0; i < arg->unk_1A; i++) {
+            var_a1 = var_a1->unk_08;
+        }
+    }
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80014D50.s")
+    if (var_a1->unk_01 & 1) {
+        D_8006F0A4[var_a1->unk_00](var_a1);
+    }
+}
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80014D70.s")
+void func_80014334(unk_D_86002F34_000* arg0) {
+    MtxF sp20;
+    unk_D_86002F34_alt5* arg = (unk_D_86002F34_alt5*)arg0;
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80015094.s")
+    func_8000F2C4(&sp20, &arg->unk_18, &arg->unk_24);
+    func_800122B4(&sp20);
+    func_80013330(arg0);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80015220.s")
+    D_800AA8C8.unk_10A0--;
+}
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_8001533C.s")
+void func_80014384(unk_D_86002F34_000* arg0) {
+    unk_D_86002F34_alt5* arg = (unk_D_86002F34_alt5*)arg0;
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80015348.s")
+    func_80012344(&arg->unk_18);
+    func_80013330(arg0);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80015360.s")
+    D_800AA8C8.unk_10A0--;
+}
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80015390.s")
+void func_800143C0(unk_D_86002F34_000* arg0) {
+    Vec3s sp90;
+    Vec3f sp84;
+    Vec3f sp78;
+    MtxF sp38;
+    unk_D_86002F34_alt6* arg = (unk_D_86002F34_alt6*)arg0;
+    s32 sp30;
 
+    sp30 = 0;
+    sp90 = arg->unk_1E;
+    sp78 = arg->unk_24;
+
+    func_8000E990(&sp84, &arg->unk_18);
+    func_800171A8(&sp84, &sp90, &sp78, arg->unk_32 * 3);
+
+    if (arg->unk_31 & 2) {
+        func_80010228(&sp38, &sp84, &sp90, &sp78, &D_8006F088->unk_60.mtxf, &D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0]);
+        D_800AA8C8.unk_10A0++;
+        func_80012230(&sp38);
+    } else if (arg->unk_31 & 1) {
+        func_8000F5A8(&sp38, &sp84, &sp90, &sp78);
+        func_800122B4(&sp38);
+    } else {
+        func_8000F730(&sp38, &sp84, &sp90, &D_800AB970.unk_000[D_800AB970.unk_180]);
+
+        D_800AA8C8.unk_10A0++;
+
+        func_80012458(&sp78);
+        if (D_800AA8C8.unk_1080[D_800AA8C8.unk_10A0 - 1] == 1) {
+            func_8000FBB0(&D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0 + 32], &sp38,
+                          &D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0 + 31]);
+        } else {
+            func_8000FBB0(&D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0 + 32], &sp38,
+                          &D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0 - 1]);
+        }
+        func_8000FDE4(&D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0], &D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0 + 32],
+                      &D_800AB970.unk_000[D_800AB970.unk_180]);
+        func_800121C8();
+        D_800AA8C8.unk_1080[D_800AA8C8.unk_10A0] = 1;
+        sp30 = 1;
+    }
+
+    D_800AA6C8[arg->unk_30] = D_800AA8C8.unk_1000[D_800AA8C8.unk_10A0];
+    func_80013330(arg0);
+    D_800AA6C8[arg->unk_30] = NULL;
+    D_800AA8C8.unk_10A0--;
+
+    if (sp30 != 0) {
+        D_800AB970.unk_180--;
+    }
+}
+
+void func_80014624(unk_D_86002F34_000* arg0) {
+    unk_D_86002F34_alt7* arg = (unk_D_86002F34_alt7*)arg0;
+
+    if (arg->unk_18 != NULL) {
+        func_800160E0(arg->unk_00.unk_03, D_800AA6C8[arg->unk_1C]);
+        func_80016274(arg->unk_18, (arg->unk_00.unk_02 & 4) != 0);
+    }
+
+    func_80013330(arg0);
+}
+
+void func_80014690(unk_D_86002F34_000* arg0) {
+    MtxF sp38;
+    Color_RGBA8_u32 sp34;
+    unk_D_86002F58_004_000* arg = (unk_D_86002F58_004_000*)arg0;
+
+    if (D_8006F090->unk_18 == arg->unk_018) {
+        arg->unk_0A7 = 0;
+        func_80017090(&arg->unk_040, D_8006F084, (arg->unk_000.unk_02 & 0x20) != 0);
+        func_800175E8(&arg->unk_054, D_8006F084, (arg->unk_000.unk_02 & 0x20) != 0);
+
+        if (arg->unk_000.unk_02 & 0x10) {
+            func_8000FBB0(&sp38, &arg->unk_060, &D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0]);
+        } else if (arg->unk_000.unk_02 & 8) {
+            func_8000F88C(&sp38, &D_8006F088->unk_60.mtxf, &D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0], &arg->unk_024,
+                          1.0f);
+        } else if (arg->unk_000.unk_02 & 0x80) {
+            func_8000F3FC(&sp38, &arg->unk_024, &arg->unk_01E);
+            func_8000FBB0(&sp38, &sp38, &D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0]);
+        } else {
+            func_8000F2C4(&sp38, &arg->unk_024, &arg->unk_01E);
+            func_8000FBB0(&sp38, &sp38, &D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0]);
+        }
+
+        func_8000FDE4(&D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0 + 1], &sp38, &arg->unk_030);
+
+        if (!(arg->unk_000.unk_02 & 4)) {
+            D_800AA8C8.unk_10A0++;
+
+            func_800121C8();
+            D_8006F09C = arg0;
+
+            func_80016344(arg->unk_0A0, arg->unk_01D, arg->unk_01C);
+
+            if ((D_8006F08C->unk_18 < 0) && (arg->unk_01A > 0)) {
+                func_80032670(arg->unk_0A6, arg->unk_01A);
+                func_80013330(arg0);
+                func_80032738(arg->unk_0A6, arg->unk_01A);
+            } else {
+                func_80013330(arg0);
+            }
+
+            sp34.rgba = 0xFFFFFF00;
+            func_80016344(sp34, 0xFF, 0);
+            D_8006F09C = NULL;
+        }
+
+        func_80017188();
+        func_800176BC();
+        D_800AA8C8.unk_10A0 -= 1;
+    }
+}
+
+void func_800148D8(unk_D_86002F34_000* arg0) {
+    unk_D_86002F34_alt8* arg = (unk_D_86002F34_alt8*)arg0;
+
+    func_800122B4(&arg->unk_1C);
+
+    if ((arg->unk_18 != NULL) || (arg->unk_00.unk_10 != NULL)) {
+        func_800160E0(arg->unk_00.unk_03, D_800AA8C8.unk_1000[D_800AA8C8.unk_10A0]);
+        if (arg->unk_00.unk_10 != NULL) {
+            arg->unk_00.unk_10(5, arg0);
+        }
+        func_80016274(arg->unk_18, (arg->unk_00.unk_02 & 4) != 0);
+    }
+    func_80013330(arg0);
+    D_800AA8C8.unk_10A0--;
+}
+
+void func_80014980(unk_D_86002F34_000* arg0) {
+    MtxF sp30;
+    unk_D_86002F34_alt9* arg = (unk_D_86002F34_alt9*)arg0;
+
+    func_8000F88C(&sp30, &D_8006F088->unk_60.mtxf, &D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0], &arg->unk_1C,
+                  arg->unk_28);
+    D_800AA8C8.unk_10A0++;
+    func_80012230(&sp30);
+
+    if ((arg->unk_18 != NULL) || (arg->unk_00.unk_10 != NULL)) {
+        func_800160E0(arg->unk_00.unk_03, D_800AA8C8.unk_1000[D_800AA8C8.unk_10A0]);
+        if (arg->unk_00.unk_10 != NULL) {
+            arg->unk_00.unk_10(5, arg0);
+        }
+        func_80016274(arg->unk_18, (arg->unk_00.unk_02 & 4) != 0);
+    }
+
+    func_80013330(arg0);
+    D_800AA8C8.unk_10A0--;
+}
+
+void func_80014A60(unk_D_86002F34_000* arg0) {
+    unk_D_86002F34_alt9* arg = (unk_D_86002F34_alt9*)arg0;
+
+    if ((arg->unk_18 != NULL) || (arg->unk_00.unk_10 != NULL)) {
+        func_800160E0(arg->unk_00.unk_03, D_800AA8C8.unk_1000[D_800AA8C8.unk_10A0]);
+        if (arg->unk_00.unk_10 != NULL) {
+            arg->unk_00.unk_10(5, arg0);
+        }
+        func_80016274(arg->unk_18, (arg->unk_00.unk_02 & 4) != 0);
+    }
+    func_80013330(arg0);
+}
+
+void func_80014AEC(unk_D_86002F34_000* arg0) {
+    Color_RGBA8_u32 sp44;
+    unk_D_86002F34_alt10* arg = (unk_D_86002F34_alt10*)arg0;
+    unk_D_86002F34_alt11_018* sp3C;
+    unk_D_86002F34_alt11_018* sp38;
+    s32 sp34;
+
+    sp3C = NULL;
+    sp38 = NULL;
+    sp34 = arg->unk_18;
+
+    if (arg->unk_22 == 1) {
+        sp44.rgba = 0xFFFFFFFF;
+    } else {
+        sp44.rgba = arg->unk_24.rgba;
+    }
+
+    if (arg->unk_1C >= 0) {
+        sp3C = &D_8006F0A0->unk_18[arg->unk_1C];
+    }
+
+    if (arg->unk_1E >= 0) {
+        sp38 = &D_8006F0A0->unk_1C[arg->unk_1E];
+    }
+
+    if (D_8006F09C != NULL) {
+        sp44.r = (sp44.r * D_8006F09C->unk_03C.r) / 255;
+        sp44.g = (sp44.g * D_8006F09C->unk_03C.g) / 255;
+        sp44.b = (sp44.b * D_8006F09C->unk_03C.b) / 255;
+    }
+
+    func_800176DC(&sp3C, D_8006F0A0->unk_18, arg->unk_20);
+    func_80016364(arg->unk_22, sp44, sp3C, sp38, sp34);
+    func_80013330(arg0);
+}
+
+void func_80014CB8(s32 arg0) {
+    MtxF* temp_a1;
+    unk_D_86002F58_004_000_0A8* ptr;
+
+    if (D_8006F09C != NULL) {
+        if (D_8006F09C->unk_0A7 < 0xC) {
+            ptr = &D_8006F09C->unk_0A8[D_8006F09C->unk_0A7++];
+            temp_a1 = &D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0];
+
+            ptr->unk_00 = arg0;
+            ptr->unk_04.x = temp_a1->mf[3][0];
+            ptr->unk_04.y = temp_a1->mf[3][1];
+            ptr->unk_04.z = temp_a1->mf[3][2];
+        }
+    }
+}
+
+void func_80014D24(unk_D_86002F34_000* arg0) {
+    unk_D_86002F34_alt3* arg = (unk_D_86002F34_alt3*)arg0;
+
+    func_80014CB8(arg->unk_18);
+    func_80013330(arg0);
+}
+
+void func_80014D50(unk_D_86002F34_000* arg0) {
+    func_80013330(arg0);
+}
+
+void func_80014D70(unk_D_86002F34_000* arg0) {
+    Vec3f sp9C;
+    Vec3f sp90;
+    Vec3f sp84;
+    f32 sp80;
+    MtxF sp40;
+    MtxF* sp3C;
+    unk_D_86002F34_alt12* arg = (unk_D_86002F34_alt12*)arg0;
+    Gfx* temp_s1;
+
+    sp3C = &D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0];
+    temp_s1 = func_80005F5C(sizeof(Gfx) * 2);
+
+    if (func_80015390(D_8006F09C, 0x64, NULL) == 0) {
+        func_80014CB8(0x64);
+    }
+
+    func_8000E88C(&sp9C, sp3C->mf[3][0], sp3C->mf[3][1] + arg->unk_1E, sp3C->mf[3][2]);
+    sp9C.y = 0.0f;
+
+    if (D_8006F09C->unk_000.unk_02 & 0x40) {
+        func_8000E88C(&sp90, 0.0f, 1.0f, 0.0f);
+        func_8000FF04(sp3C, &sp84);
+
+        sp80 = 1.0f - ((sp3C->mf[3][1] - sp9C.y) / 1000.0f);
+        if (sp80 < 0.5f) {
+            sp80 = 0.5f;
+        }
+
+        if (sp80 > 1.0f) {
+            sp80 = 1.0f;
+        }
+
+        sp84.x *= (arg->unk_1A / 100.0f) * sp80;
+        sp84.z *= (arg->unk_1C / 100.0f) * sp80;
+        func_8000FA94(&sp40, &sp90, &sp9C, D_8006F09C->unk_01E.y);
+        func_8000FDE4(&D_800AA8C8.unk_0000[D_800AA8C8.unk_10A0 + 1], &sp40, &sp84);
+
+        D_800AA8C8.unk_10A0++;
+        func_800121C8();
+
+        if (arg->unk_18 == 0) {
+            gSPBranchList(&temp_s1[1], Util_ConvertAddrToVirtAddr(D_1002480));
+        } else {
+            gSPBranchList(&temp_s1[1], Util_ConvertAddrToVirtAddr(D_1002508));
+        }
+        gDPSetEnvColor(&temp_s1[0], 0, 0, 0, (s32)(150.0f * sp80));
+
+        if (D_8006F09C->unk_000.unk_02 & 2) {
+            func_800160E0(6, D_800AA8C8.unk_1000[D_800AA8C8.unk_10A0]);
+        } else {
+            func_800160E0(5, D_800AA8C8.unk_1000[D_800AA8C8.unk_10A0]);
+        }
+
+        gDPSetFogColor(gDisplayListHead++, 255, 255, 255, 0);
+        gDPSetPrimColor(gDisplayListHead++, 0, D_8006F09C->unk_01D, 255, 255, 255, 255);
+
+        func_80016274((u32)temp_s1 & 0x1FFFFFFF, 1);
+        func_80013330(arg0);
+
+        D_800AA8C8.unk_10A0--;
+    }
+}
+
+void func_80015094(unk_D_86002F34_000* arg0) {
+    unk_D_86002F34_alt1* arg = (unk_D_86002F34_alt1*)arg0;
+
+    if (arg0->unk_01 & 1) {
+        gDPPipeSync(gDisplayListHead++);
+
+        gDPSetTextureLOD(gDisplayListHead++, G_TL_TILE);
+        gDPSetTextureLUT(gDisplayListHead++, G_TT_NONE);
+        gDPSetTextureDetail(gDisplayListHead++, G_TD_CLAMP);
+        gDPSetTexturePersp(gDisplayListHead++, G_TP_PERSP);
+        gDPSetTextureFilter(gDisplayListHead++, G_TF_BILERP);
+        gDPSetTextureConvert(gDisplayListHead++, G_TC_FILT);
+        gDPSetCombineKey(gDisplayListHead++, G_CK_NONE);
+        gDPSetAlphaCompare(gDisplayListHead++, G_AC_NONE);
+        gDPSetColorDither(gDisplayListHead++, G_CD_MAGICSQ);
+        gDPSetAlphaDither(gDisplayListHead++, G_AD_PATTERN);
+
+        D_8006F08C = arg;
+        func_80013330(arg0);
+        D_8006F08C = NULL;
+    }
+
+    D_8006F080 = 0;
+}
+
+void func_80015220(unk_D_86002F34_000* arg0, s32 arg1) {
+    unk_D_86002F34_000* var_s1 = arg0;
+    unk_D_86002F34_000** var_s0;
+
+    do {
+        if (var_s1->unk_10 != NULL) {
+            var_s1->unk_10(arg1, var_s1);
+        }
+
+        if (var_s1->unk_0C != NULL) {
+            switch (var_s1->unk_00) {
+                default:
+                    var_s0 = NULL;
+                    break;
+
+                case 2:
+                    var_s0 = &D_8006F088;
+                    break;
+
+                case 4:
+                    var_s0 = &D_8006F090;
+                    break;
+
+                case 6:
+                    var_s0 = &D_8006F098;
+                    break;
+
+                case 0x16:
+                    var_s0 = &D_8006F09C;
+                    break;
+            }
+
+            if (var_s0 != NULL) {
+                *var_s0 = var_s1;
+            }
+
+            func_80015220(var_s1->unk_0C, arg1);
+
+            if (var_s0 != NULL) {
+                *var_s0 = NULL;
+            }
+        }
+
+        var_s1 = var_s1->unk_08;
+    } while (var_s1 != arg0);
+}
+
+void func_8001533C(s32 arg0) {
+    D_8006F080 = arg0;
+}
+
+void func_80015348(void) {
+    D_8006F084++;
+}
+
+s32 func_80015360(void) {
+    s32 var_v1 = 1;
+
+    if (D_8006F090 != NULL) {
+        var_v1 = D_8006F090->unk_1A == D_8006F084;
+    }
+    return var_v1;
+}
+
+Vec3f* func_80015390(unk_D_86002F58_004_000* arg0, s16 arg1, Vec3f* arg2) {
+    s32 i;
+    s32 var_v0;
+    u8 temp_v1;
+    unk_D_86002F58_004_000* var_a2;
+
+    for (i = 0; i < arg0->unk_0A7; i++) {
+        if (arg1 == arg0->unk_0A8[i].unk_00) {
+            if (arg2 != NULL) {
+                *arg2 = arg0->unk_0A8[i].unk_04;
+            }
+            return &arg0->unk_0A8[i].unk_04;
+        }
+    }
+
+    return NULL;
+}
+
+#ifdef NON_MATCHING
+void func_80015400(Gfx* arg0, u8* arg1) {
+    /*
+    gDPSetCombineLERP(arg0++,
+                      arg1[0], arg1[1], arg1[2], arg1[3], arg1[4], arg1[5], arg1[6],
+                      arg1[7], arg1[8], arg1[9], arg1[10], arg1[11], arg1[12], arg1[13],
+                      arg1[14], arg1[15]);
+    */
+
+    gDPSetCombine(arg0++, GCCc0w0(arg1[0], arg1[2], arg1[4], arg1[6]) | GCCc1w0(arg1[8], arg1[10]),
+                  GCCc0w1(arg1[1], arg1[3], arg1[5], arg1[7]) |
+                      GCCc1w1(arg1[9], arg1[12], arg1[14], arg1[11], arg1[13], arg1[15]));
+
+    /*
+    arg0->words.w0 = ((((arg1->unk_0 & 0xF) << 0x14) |
+                       ((arg1->unk_2 & 0x1F) << 0xF) |
+                       ((arg1->unk_4 & 7) << 0xC) |
+                       ((arg1->unk_6 & 7) << 9) |
+                       ((arg1->unk_8 & 0xF) << 5) | (arg1->unk_A & 0x1F)) & 0xFFFFFF) |
+                        0xFC000000;
+    arg0->words.w1 = (arg1->unk_1 << 0x1C) |
+                    ((arg1->unk_3 & 7) << 0xF) |
+                    ((arg1->unk_5 & 7) << 0xC) |
+                    ((arg1->unk_7 & 7) << 9) |
+                    ((arg1->unk_9 & 0xF) << 0x18) |
+                    ((arg1->unk_C & 7) << 0x15) |
+                    ((arg1->unk_E & 7) << 0x12) |
+                    ((arg1->unk_B & 7) << 6) |
+                    ((arg1->unk_D & 7) * 8) |
+                    (arg1->unk_F & 7);
+    */
+}
+#else
 #pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80015400.s")
+#endif
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_8001550C.s")
+void func_8001550C(void) {
+    if (D_800ABB08 == 0) {
+        D_800ABB08 = 1;
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_8001554C.s")
+        gDPPipeSync(gDisplayListHead++);
+    }
+}
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80015684.s")
+void func_8001554C(void) {
+    s32 var_v0 = D_8006F124[D_800ABB00][D_800ABCB8->unk_24];
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_8001587C.s")
+    D_800ABB08 = 1;
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80015948.s")
+    gDPPipeSync(gDisplayListHead++);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80015984.s")
+    D_800ABCB8->unk_14.rgba = 0x00000000;
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80015A44.s")
+    gDPSetColor(gDisplayListHead++, G_SETFOGCOLOR, D_8006F090->unk_20);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80015AC4.s")
+    if ((D_800ABB04 & 1) && (D_800ABB00 == 1) && (D_800ABCB8->unk_24 == 5)) {
+        var_v0 = 0x107A58;
+    }
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80015B20.s")
+    if (D_8006F090->unk_1D != 0) {
+        gDPSetRenderMode(gDisplayListHead++, var_v0, 0xC8000000);
+    } else {
+        gDPSetRenderMode(gDisplayListHead++, var_v0, 0x0C080000);
+    }
+}
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80015DD8.s")
+void func_80015684(void) {
+    Color_RGBA8_u32 sp1C;
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80015F64.s")
+    sp1C.rgba = D_800ABCB8->unk_10.rgba;
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80016010.s")
+    D_800ABCB8->unk_18 = NULL;
+    D_800ABCB8->unk_1C = NULL;
+    D_800ABCB8->unk_0C = NULL;
+    D_800ABCB8->unk_27 = 0;
+    D_800ABB08 = 1;
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80016060.s")
+    gDPPipeSync(gDisplayListHead++);
+    gDPSetPrimColor(gDisplayListHead++, 0, D_800ABCB8->unk_26, sp1C.r, sp1C.g, sp1C.b, sp1C.a);
+    gDPSetTextureLUT(gDisplayListHead++, G_TT_NONE);
+    gSPTexture(gDisplayListHead++, 0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_800160E0.s")
+    func_80015400(gDisplayListHead++, D_8006F1B4[D_800ABCB8->unk_25]);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80016274.s")
+    gSPSetGeometryMode(gDisplayListHead++, G_SHADE | G_CULL_BACK | G_SHADING_SMOOTH);
+    gSPClearGeometryMode(gDisplayListHead++, G_FOG | G_TEXTURE_GEN);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80016344.s")
+    gSPLookAt(gDisplayListHead++, (u32)&D_8006F088->unk_60.lookat->l & 0x1FFFFFFF);
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_80016364.s")
+    if (D_8006F090->unk_1D != 0) {
+        gSPSetGeometryMode(gDisplayListHead++, G_FOG);
+    }
+}
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_8001638C.s")
+void func_8001587C(unk_D_800ABB10* arg0) {
+    if (arg0->unk_08.rgba != D_800ABCB8->unk_14.rgba) {
+        func_8001550C();
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/12D80/func_8001660C.s")
+        gDPSetColor(gDisplayListHead++, G_SETFOGCOLOR, arg0->unk_08.rgba);
+        gDPSetRenderMode(gDisplayListHead++, D_8006F124[D_800ABB00][D_800ABCB8->unk_24], 0xC4000000);
+
+        D_800ABCB8->unk_14.rgba = arg0->unk_08.rgba;
+    }
+}
+
+void func_80015948(UNUSED unk_D_800ABB10* arg0) {
+    if (D_800ABCB8->unk_14.rgba & 0xFF) {
+        func_8001554C();
+    }
+}
+
+void func_80015984(unk_D_800ABB10* arg0) {
+    if ((arg0->unk_04.rgba != D_800ABCB8->unk_10.rgba) || (arg0->unk_01 != D_800ABCB8->unk_26)) {
+        func_8001550C();
+
+        gDPSetPrimColor(gDisplayListHead++, 0, arg0->unk_01, arg0->unk_04.r, arg0->unk_04.g, arg0->unk_04.b,
+                        arg0->unk_04.a);
+
+        D_800ABCB8->unk_10.rgba = arg0->unk_04.rgba;
+        D_800ABCB8->unk_26 = arg0->unk_01;
+    }
+}
+
+void func_80015A44(unk_D_800ABB10* arg0) {
+    if (arg0->unk_00 != D_800ABCB8->unk_25) {
+        func_8001550C();
+        func_80015400(gDisplayListHead++, D_8006F1B4[arg0->unk_00]);
+        D_800ABCB8->unk_25 = arg0->unk_00;
+    }
+}
+
+void func_80015AC4(UNUSED unk_D_800ABB10* arg0) {
+    if (D_800ABCB8->unk_18 != NULL) {
+        gSPTexture(gDisplayListHead++, 0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF);
+    }
+
+    D_800ABCB8->unk_18 = NULL;
+    D_800ABCB8->unk_1C = NULL;
+    D_800ABCB8->unk_20 = NULL;
+}
+
+void func_80015B20(unk_D_800ABB10* arg0) {
+    unk_D_86002F34_alt11_018* temp_t0;
+    s32 var_a3;
+
+    if (D_800ABCB8->unk_18 == NULL) {
+        gSPTexture(gDisplayListHead++, 0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON);
+    }
+
+    if ((arg0->unk_0C != D_800ABCB8->unk_18) || (arg0->unk_14 != D_800ABCB8->unk_20)) {
+        temp_t0 = arg0->unk_0C;
+
+        if (arg0->unk_10 != NULL) {
+            gSPDisplayList(gDisplayListHead++, arg0->unk_10->unk_08);
+        } else {
+            gDPSetTextureLUT(gDisplayListHead++, G_TT_NONE);
+        }
+
+        if (temp_t0->unk_01 == 0) {
+            if ((temp_t0->unk_02 % D_8006F2A4[0]) == 0) {
+                gDPSetTextureImage(gDisplayListHead++, temp_t0->fmt, G_IM_SIZ_16b, 1, temp_t0->texture);
+            } else {
+                gDPSetTextureImage(gDisplayListHead++, temp_t0->fmt, G_IM_SIZ_8b, temp_t0->unk_02 >> 1,
+                                   temp_t0->texture);
+            }
+        } else if ((temp_t0->unk_02 % D_8006F2A4[temp_t0->unk_01]) == 0) {
+            if (temp_t0->unk_01 == 3) {
+                var_a3 = 3;
+            } else {
+                var_a3 = 2;
+            }
+
+            gDPSetTextureImage(gDisplayListHead++, temp_t0->fmt, var_a3, 1, temp_t0->texture);
+        } else {
+            gDPSetTextureImage(gDisplayListHead++, temp_t0->fmt, temp_t0->unk_01, temp_t0->unk_02, temp_t0->texture);
+        }
+
+        gSPDisplayList(gDisplayListHead++, arg0->unk_14);
+    }
+
+    D_800ABCB8->unk_18 = arg0->unk_0C;
+    D_800ABCB8->unk_1C = arg0->unk_10;
+    D_800ABCB8->unk_20 = arg0->unk_14;
+}
+
+void func_80015DD8(UNUSED unk_D_800ABB10* arg0) {
+    if (D_800ABCB8->unk_27 == 0) {
+        gDPLoadTextureBlock(gDisplayListHead++, D_1001800, G_IM_FMT_RGBA, G_IM_SIZ_16b, 32, 32, 0,
+                            G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, 5, 5, 1, 1);
+        gSPTexture(gDisplayListHead++, 0x1194, 0x1194, 0, G_TX_RENDERTILE, G_ON);
+
+        gSPSetGeometryMode(gDisplayListHead++, G_TEXTURE_GEN);
+        gSPClearGeometryMode(gDisplayListHead++, G_TEXTURE_GEN_LINEAR);
+        gDPSetCombineMode(gDisplayListHead++, G_CC_MODULATEIDECALA, G_CC_PASS2);
+
+        D_800ABCB8->unk_27 = 1;
+    }
+}
+
+void func_80015F64(s16 arg0) {
+    if (arg0 == D_800ABCBC) {
+        return;
+    }
+
+    D_800ABCB8->unk_08 = gDisplayListHead;
+
+    gSPBranchList(gDisplayListHead++, NULL);
+
+    D_800ABCBC = arg0;
+    D_800ABCB8 = &D_800ABB28[D_800ABCBC];
+
+    if (D_800ABCB8->unk_04 == NULL) {
+        D_800ABCB8->unk_04 = gDisplayListHead;
+    } else if (D_800ABCB8->unk_08 != NULL) {
+        gSPBranchList(D_800ABCB8->unk_08, gDisplayListHead);
+    }
+}
+
+void func_80016010(s16 arg0) {
+    if (((arg0 > 0) && (arg0 < 4)) || (arg0 == 0x84) || (arg0 == 6)) {
+        D_800ABB10.unk_03 = D_800ABB10.unk_02;
+    } else {
+        D_800ABB10.unk_03 = 0;
+    }
+}
+
+s16 func_80016060(s16 arg0) {
+    s16 var_v1 = arg0 & 0xF;
+
+    if (D_800ABB10.unk_01 < 0xFF) {
+        switch (var_v1) {
+            case 1:
+                var_v1 = 8;
+                break;
+            case 2:
+                var_v1 = 6;
+                break;
+            case 3:
+                var_v1 = 7;
+                break;
+            case 4:
+                var_v1 = 5;
+                break;
+        }
+    }
+
+    return var_v1;
+}
+
+void func_800160E0(s16 arg0, MtxF* arg1) {
+    if ((D_8006F120 != 0) && !(D_800ABB04 & 2) && (D_800ABB10.unk_01 > 0)) {
+        func_80016010(arg0);
+        func_80015F64(func_80016060(arg0));
+        D_800ABB08 = 0;
+
+        if (D_800ABCB8->unk_00 == 0) {
+            func_8001554C();
+            func_80015684();
+            D_800ABCB8->unk_00 = 1;
+        }
+
+        if (D_800ABB10.unk_08.rgba & 0xFF) {
+            func_8001587C(&D_800ABB10);
+        } else {
+            func_80015948(&D_800ABB10);
+        }
+
+        if (D_800ABB10.unk_03 != 0) {
+            func_80015DD8(&D_800ABB10);
+        } else {
+            if (D_800ABCB8->unk_27 == 1) {
+                func_80015684();
+            }
+
+            if (D_800ABB10.unk_0C != 0) {
+                func_80015B20(&D_800ABB10);
+            } else {
+                func_80015AC4(&D_800ABB10);
+            }
+
+            func_80015984(&D_800ABB10);
+            func_80015A44(&D_800ABB10);
+        }
+
+        if (arg1 != D_800ABCB8->unk_0C) {
+            D_800ABCB8->unk_0C = arg1;
+            gSPMatrix(gDisplayListHead++, (u32)arg1 & 0x1FFFFFFF, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+        }
+    }
+}
+
+void func_80016274(Gfx* arg0, s32 arg1) {
+    if ((D_8006F120 != 0) && !(D_800ABB04 & 2) && (D_800ABB10.unk_01 > 0)) {
+        if (arg0 != NULL) {
+            if (((u32)arg0 >= 0x81000000) && ((u32)arg0 < 0x90000000)) {
+                gSPDisplayList(gDisplayListHead++, Memmap_GetFragmentVaddr((u32)arg0));
+            } else {
+                gSPDisplayList(gDisplayListHead++, arg0);
+            }
+        }
+
+        if (arg1 != 0) {
+            func_80015684();
+        }
+    }
+}
+
+void func_80016344(Color_RGBA8_u32 arg0, u8 arg1, u32 arg2) {
+    D_800ABB10.unk_08.rgba = arg0.rgba;
+    D_800ABB10.unk_01 = arg1;
+    D_800ABB10.unk_02 = arg2;
+}
+
+void func_80016364(s32 arg0, Color_RGBA8_u32 arg1, unk_D_86002F34_alt11_018* arg2, unk_D_86002F34_alt11_018* arg3,
+                   s32 arg4) {
+    D_800ABB10.unk_00 = arg0;
+    D_800ABB10.unk_04.rgba = arg1.rgba;
+    D_800ABB10.unk_0C = arg2;
+    D_800ABB10.unk_10 = arg3;
+    D_800ABB10.unk_14 = arg4;
+}
+
+void func_8001638C(s32 arg0, s32 arg1) {
+    s32 i;
+    unk_D_800ABB28* ptr = D_800ABB28;
+
+    gDPPipeSync(gDisplayListHead++);
+    gDPSetCycleType(gDisplayListHead++, G_CYC_2CYCLE);
+
+    if (arg0 & 1) {
+        gSPSetGeometryMode(gDisplayListHead++, G_ZBUFFER);
+    } else {
+        gSPClearGeometryMode(gDisplayListHead++, G_ZBUFFER);
+    }
+
+    for (i = 0; i < 10; i++, ptr++) {
+        ptr->unk_04 = NULL;
+        ptr->unk_08 = NULL;
+
+        ptr->unk_00 = 0;
+        ptr->unk_0C = 0;
+
+        ptr->unk_10.rgba = 0xFFFFFFFF;
+        ptr->unk_14.rgba = 0xFFFFFF00;
+
+        ptr->unk_18 = NULL;
+        ptr->unk_1C = NULL;
+        ptr->unk_20 = NULL;
+
+        ptr->unk_24 = i;
+        ptr->unk_25 = 0;
+        ptr->unk_27 = 0;
+        ptr->unk_26 = 0xFF;
+    }
+
+    D_800ABB10.unk_00 = 0;
+    D_800ABB10.unk_01 = 0xFF;
+    D_800ABB10.unk_02 = 0;
+    D_800ABB10.unk_03 = 0;
+    D_800ABB10.unk_04.rgba = -1;
+    D_800ABB10.unk_08.rgba = 0xFFFFFF00;
+    D_800ABB10.unk_0C = 0;
+    D_800ABB10.unk_10 = 0;
+    D_800ABB10.unk_14 = 0;
+
+    D_800ABB00 = arg0;
+    D_800ABB04 = arg1;
+
+    D_800ABB28[0].unk_04 = gDisplayListHead;
+
+    D_800ABCBC = 0;
+    D_800ABCB8 = D_800ABB28;
+
+    D_8006F120 = 1;
+}
+
+void func_8001660C(void) {
+    s32 sp1C = 0;
+    Gfx* temp_t0;
+    s32 temp_v0;
+
+    func_80015F64(9);
+
+    if (D_800ABB28[0].unk_08 != NULL) {
+        while (sp1C < 9) {
+            temp_v0 = sp1C + 1;
+            temp_t0 = D_800ABB28[sp1C].unk_08;
+            sp1C++;
+
+            while (D_800ABB28[temp_v0].unk_04 == NULL) {
+                temp_v0 = sp1C + 1;
+                sp1C++;
+            }
+
+            gSPBranchList(temp_t0, D_800ABB28[sp1C].unk_04);
+        }
+    }
+
+    func_80015684();
+
+    if (D_800ABB00 & 1) {
+        gSPClearGeometryMode(gDisplayListHead++, G_ZBUFFER);
+    }
+
+    D_8006F120 = 0;
+}
diff --git a/src/12D80.h b/src/12D80.h
index 649177c..6addc2d 100644
--- a/src/12D80.h
+++ b/src/12D80.h
@@ -3,9 +3,118 @@
 
 #include "global.h"
 
-void func_80015094(unk_D_86002F34*);
-void func_80015348(void);
-s32 func_80015390(unk_D_86002F58_004_000*, s16, Vec3f*);
+typedef struct unk_D_800AB970 {
+    /* 0x000 */ Vec3f unk_000[1];
+    /* 0x00C */ char unk00C[0x174];
+    /* 0x180 */ s32 unk_180;
+    /* 0x184 */ char unk184[0xC];
+} unk_D_800AB970; // size = 0x190?
 
+typedef struct unk_D_800ABB00 {
+    /* 0x00 */ void* unk_00;
+    /* 0x04 */ void* unk_04;
+    /* 0x08 */ char unk08[0x8];
+} unk_D_800ABB00; // size >= 0x10?
+
+typedef struct unk_D_800ABB28 {
+    /* 0x00 */ s32 unk_00;
+    /* 0x04 */ Gfx* unk_04;
+    /* 0x08 */ Gfx* unk_08;
+    /* 0x0C */ MtxF* unk_0C;
+    /* 0x10 */ Color_RGBA8_u32 unk_10;
+    /* 0x14 */ Color_RGBA8_u32 unk_14;
+    /* 0x18 */ unk_D_86002F34_alt11_018* unk_18;
+    /* 0x1C */ struct unk_D_800ABB28* unk_1C;
+    /* 0x20 */ Gfx* unk_20;
+    /* 0x24 */ u8 unk_24;
+    /* 0x24 */ u8 unk_25;
+    /* 0x24 */ u8 unk_26;
+    /* 0x24 */ u8 unk_27;
+} unk_D_800ABB28; // size = 0x28
+
+typedef struct unk_D_800ABB10 {
+    /* 0x00 */ u8 unk_00;
+    /* 0x01 */ u8 unk_01;
+    /* 0x02 */ u8 unk_02;
+    /* 0x03 */ u8 unk_03;
+    /* 0x04 */ Color_RGBA8_u32 unk_04;
+    /* 0x08 */ Color_RGBA8_u32 unk_08;
+    /* 0x0C */ unk_D_86002F34_alt11_018* unk_0C;
+    /* 0x10 */ unk_D_800ABB28* unk_10;
+    /* 0x14 */ Gfx* unk_14;
+} unk_D_800ABB10; // size = 0x18?
+
+void func_80012180(void);
+void func_800121C8(void);
+void func_80012230(MtxF* arg0);
+void func_800122B4(MtxF* arg0);
+void func_80012344(Vec3f* arg0);
+MtxF* func_800123D4(s32 arg0);
+MtxF* func_80012400(s32 arg0);
+void func_80012428(void);
+void func_80012458(Vec3f* arg0);
+Vtx* func_800124D4(unk_D_86002F34_00C_0CC* arg0, unk_D_86002F34_00C_040* arg1);
+void func_80012768(unk_D_86002F34_00C_0CC* arg0, unk_D_86002F34_00C_040* arg1);
+void func_80012870(Vtx* arg0, unk_D_86002F34_00C_0CC* arg1, s16 arg2, s16 arg3, s16 arg4, s16 arg5, s16 arg6, s16 arg7);
+Vtx* func_80012960(unk_D_86002F34_00C_0CC* arg0);
+void func_80012D88(unk_D_86002F34_00C_0CC* arg0, UNUSED unk_D_86002F34_00C_040* arg1);
+void func_800131B4(unk_D_86002F34_00C_0CC* arg0, unk_D_86002F34_00C_040* arg1);
+void func_80013330(unk_D_86002F34_000* arg0);
+void func_800133D8(unk_D_86002F34_000* arg0);
+void func_80013464(unk_D_86002F34_000* arg0);
+void func_80013764(unk_D_86002F34_000* arg0);
+void func_8001378C(unk_D_86002F34_000* arg0);
+void func_800138F0(unk_D_86002F34_000* arg0);
+void func_8001395C(unk_D_86002F34_000* arg0);
+void func_800139E8(unk_D_86002F34_000* arg0);
+void func_80013AF8(unk_D_86002F34_000* arg0);
+void func_80013B8C(UNUSED unk_D_86002F34_000* arg0);
+void func_80013C14(UNUSED unk_D_86002F34_000* arg0);
+void func_80013C1C(unk_D_86002F34_000* arg0);
+void func_80013D34(unk_D_86002F34_000* arg0);
+void func_80013F7C(UNUSED unk_D_86002F34_000* arg0);
+void func_80013F84(unk_D_86002F34_000* arg0);
+void func_80014124(unk_D_86002F34_000* arg0);
+void func_80014214(unk_D_86002F34_000* arg0);
+void func_800142BC(unk_D_86002F34_000* arg0);
+void func_80014334(unk_D_86002F34_000* arg0);
+void func_80014384(unk_D_86002F34_000* arg0);
+void func_800143C0(unk_D_86002F34_000* arg0);
+void func_80014624(unk_D_86002F34_000* arg0);
+void func_80014690(unk_D_86002F34_000* arg0);
+void func_800148D8(unk_D_86002F34_000* arg0);
+void func_80014980(unk_D_86002F34_000* arg0);
+void func_80014A60(unk_D_86002F34_000* arg0);
+void func_80014AEC(unk_D_86002F34_000* arg0);
+void func_80014CB8(s32 arg0);
+void func_80014D24(unk_D_86002F34_000* arg0);
+void func_80014D50(unk_D_86002F34_000* arg0);
+void func_80014D70(unk_D_86002F34_000* arg0);
+void func_80015094(unk_D_86002F34_000* arg0);
+void func_80015220(unk_D_86002F34_000* arg0, s32 arg1);
+void func_8001533C(s32 arg0);
+void func_80015348(void);
+s32 func_80015360(void);
+Vec3f* func_80015390(unk_D_86002F58_004_000* arg0, s16 arg1, Vec3f* arg2);
+void func_80015400(Gfx* arg0, u8* arg1);
+void func_8001550C(void);
+void func_8001554C(void);
+void func_80015684(void);
+void func_8001587C(unk_D_800ABB10* arg0);
+void func_80015948(UNUSED unk_D_800ABB10* arg0);
+void func_80015984(unk_D_800ABB10* arg0);
+void func_80015A44(unk_D_800ABB10* arg0);
+void func_80015AC4(UNUSED unk_D_800ABB10* arg0);
+void func_80015B20(unk_D_800ABB10* arg0);
+void func_80015DD8(UNUSED unk_D_800ABB10* arg0);
+void func_80015F64(s16 arg0);
+void func_80016010(s16 arg0);
+s16 func_80016060(s16 arg0);
+void func_800160E0(s16 arg0, MtxF* arg1);
+void func_80016274(Gfx* arg0, s32 arg1);
+void func_80016344(Color_RGBA8_u32 arg0, u8 arg1, u32 arg2);
+void func_80016364(s32 arg0, Color_RGBA8_u32 arg1, unk_D_86002F34_alt11_018* arg2, unk_D_86002F34_alt11_018* arg3, s32 arg4);
+void func_8001638C(s32 arg0, s32 arg1);
+void func_8001660C(void);
 
 #endif // _12D80_H_
diff --git a/src/17300.h b/src/17300.h
index 33d2fc6..dd180ca 100644
--- a/src/17300.h
+++ b/src/17300.h
@@ -3,11 +3,18 @@
 
 #include "global.h"
 
+void func_80017080(void);
+void func_80017090(unk_D_86002F58_004_000_040*, u16, s32);
+void func_80017188(void);
+void func_800171A8(Vec3f*, Vec3s*, Vec3f*, s32);
 void func_800173CC(unk_D_86002F58_004_000* arg0);
 s32 func_800173DC(unk_D_86002F58_004_000* arg0, s16 arg1, s32 arg2, s32 arg3);
 void func_80017464(unk_D_86002F58_004_000* arg0, s16 arg1);
 s32 func_80017484(unk_D_86002F58_004_000* arg0, s16 arg1);
 void func_800174E4(unk_D_86002F58_004_000* arg0);
 s32 func_80017514(unk_D_86002F58_004_000* arg0);
+void func_800175D8(void);
+void func_800175E8(unk_D_86002F58_004_000_054*, u16, s32);
+void func_800176BC(void);
 
 #endif // _17300_H_
diff --git a/src/18140.h b/src/18140.h
index 0d57e34..9a3e46b 100644
--- a/src/18140.h
+++ b/src/18140.h
@@ -3,6 +3,7 @@
 
 #include "global.h"
 
+void func_800176DC(unk_D_86002F34_alt11_018**, unk_D_86002F34_alt11_018*, s16);
 void func_80017788(unk_D_86002F58_004_000* arg0);
 s16 func_80017798(unk_D_86002F58_004_000* arg0, s16 arg1, s32 arg2);
 void func_80017804(unk_D_86002F58_004_000* arg0, s16 arg1);
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 491fcad..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"
@@ -43,8 +43,8 @@ void func_8001BC34(unk_D_86002F58_004_000* arg0, s16 arg1, s16 arg2, unk_D_86002
     arg0->unk_000.unk_02 |= 0x40;
     arg0->unk_000.unk_02 &= ~0x2;
 
-    arg0->unk_0A0 = -0x100;
-    arg0->unk_03C = -0x100;
+    arg0->unk_0A0.rgba = 0xFFFFFF00;
+    arg0->unk_03C.rgba = 0xFFFFFF00;
     arg0->unk_040.unk_00 = -1;
     arg0->unk_040.unk_04 = NULL;
     arg0->unk_054.unk_00 = -1;
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/32D10.c b/src/32D10.c
index f8baba6..c89874a 100644
--- a/src/32D10.c
+++ b/src/32D10.c
@@ -1,9 +1,115 @@
-#include "global.h"
 #include "32D10.h"
+#include "334D0.h"
+#include "src/util.h"
+#include "src/fragments/31/fragment31.h"
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/32D10/func_80032110.s")
+extern s16 D_800AF778[4];
+extern s16 D_800AF780[4];
+extern s16 D_800AF788[4];
+extern s16 D_800AF790[4];
+extern s16 D_800AF798[4];
+extern s16 D_800AF7A0[4];
+extern s16 D_800AF7AE;
+extern s16 D_800AF7C0[];
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/32D10/func_80032244.s")
+void func_80032110(u8 arg0, s16 arg1) {
+    D_800AF778[arg0] = 0x167 - ((arg1 % 10) * 0x24);
+    D_800AF780[arg0] = 0x167 - (((arg1 / 10) % 10) * 0x24);
+    D_800AF788[arg0] = 0x167 - (((arg1 / 100) % 10) * 0x24);
+}
+
+void func_80032244(u8 arg0, s16 arg1) {
+    s16 tmp;
+    s16 tmp2;
+
+    D_800AF790[arg0] = 0x167 - ((arg1 % 10) * 0x24);
+    D_800AF798[arg0] = 0x167 - (((arg1 / 10) % 10) * 0x24);
+    D_800AF7A0[arg0] = 0x167 - (((arg1 / 100) % 10) * 0x24);
+
+    tmp2 = D_800AF790[arg0];
+    tmp = D_800AF778[arg0];
+    if (((tmp2 < 0x5A) && (tmp >= 0x10F)) || ((tmp < 0x5A) && (tmp2 >= 0x10F))) {
+        if (tmp < tmp2) {
+            D_800AF778[arg0] -= 6;
+        }
+
+        if (tmp2 < tmp) {
+            D_800AF778[arg0] += 6;
+        }
+    } else {
+        if (tmp < tmp2) {
+            D_800AF778[arg0] += 6;
+        }
+
+        if (tmp2 < tmp) {
+            D_800AF778[arg0] -= 6;
+        }
+    }
+
+    if (D_800AF778[arg0] < 0) {
+        D_800AF778[arg0] += 0x168;
+    }
+
+    if (D_800AF778[arg0] >= 0x168) {
+        D_800AF778[arg0] -= 0x168;
+    }
+
+    tmp2 = D_800AF798[arg0];
+    tmp = D_800AF780[arg0];
+    if (((tmp2 < 0x5A) && (tmp >= 0x10F)) || ((tmp < 0x5A) && (tmp2 >= 0x10F))) {
+        if (tmp < tmp2) {
+            D_800AF780[arg0] -= 6;
+        }
+
+        if (tmp2 < tmp) {
+            D_800AF780[arg0] += 6;
+        }
+    } else {
+        if (tmp < tmp2) {
+            D_800AF780[arg0] += 6;
+        }
+
+        if (tmp2 < tmp) {
+            D_800AF780[arg0] -= 6;
+        }
+    }
+
+    if (D_800AF780[arg0] < 0) {
+        D_800AF780[arg0] += 0x168;
+    }
+
+    if (D_800AF780[arg0] >= 0x168) {
+        D_800AF780[arg0] -= 0x168;
+    }
+
+    tmp2 = D_800AF7A0[arg0];
+    tmp = D_800AF788[arg0];
+    if (((tmp2 < 0x5A) && (tmp >= 0x10F)) || ((tmp < 0x5A) && (tmp2 >= 0x10F))) {
+        if (tmp < tmp2) {
+            D_800AF788[arg0] -= 6;
+        }
+
+        if (tmp2 < tmp) {
+            D_800AF788[arg0] += 6;
+        }
+    } else {
+        if (tmp < tmp2) {
+            D_800AF788[arg0] += 6;
+        }
+
+        if (tmp2 < tmp) {
+            D_800AF788[arg0] -= 6;
+        }
+    }
+
+    if (D_800AF788[arg0] < 0) {
+        D_800AF788[arg0] += 0x168;
+    }
+
+    if (D_800AF788[arg0] >= 0x168) {
+        D_800AF788[arg0] -= 0x168;
+    }
+}
 
 #pragma GLOBAL_ASM("asm/us/nonmatchings/32D10/func_80032570.s")
 
@@ -13,7 +119,20 @@
 
 #pragma GLOBAL_ASM("asm/us/nonmatchings/32D10/func_800325E0.s")
 
-#pragma GLOBAL_ASM("asm/us/nonmatchings/32D10/func_8003260C.s")
+void func_8003260C(unk_D_86002F58_004_000* arg0) {
+    void (*func)(void*);
+    s32 unk1A = arg0->unk_01A;
+    s32 idx = arg0->unk_0A6;
+
+    D_800AF7AE = 0;
+
+    if (unk1A < 0x98) {
+        D_800AF7C0[idx & 1] = 0;
+        func_80032A34(idx & 1);
+        func = Util_ConvertAddrToVirtAddr(func_810007A8);
+        func(arg0);
+    }
+}
 
 #pragma GLOBAL_ASM("asm/us/nonmatchings/32D10/func_80032670.s")
 
diff --git a/src/32D10.h b/src/32D10.h
index 2dd9d4e..07f37ec 100644
--- a/src/32D10.h
+++ b/src/32D10.h
@@ -3,9 +3,10 @@
 
 #include "global.h"
 
-void func_80032110(u8, s32);
+void func_80032110(u8, s16);
 void func_80032244(u8, s16);
 void func_8003260C(unk_D_86002F58_004_000*);
-
+void func_80032670(u8, u32);
+void func_80032738(u8, u32);
 
 #endif // _32D10_H_
diff --git a/src/334D0.c b/src/334D0.c
index 083f8c1..512ad98 100644
--- a/src/334D0.c
+++ b/src/334D0.c
@@ -1,4 +1,4 @@
-#include "global.h"
+#include "334D0.h"
 
 #pragma GLOBAL_ASM("asm/us/nonmatchings/334D0/func_800328D0.s")
 
diff --git a/src/334D0.h b/src/334D0.h
new file mode 100644
index 0000000..2fdcd3a
--- /dev/null
+++ b/src/334D0.h
@@ -0,0 +1,8 @@
+#ifndef _334D0_H_
+#define _334D0_H_
+
+#include "global.h"
+
+void func_80032A34(s32);
+
+#endif // _334D0_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 4fa3429..b50a8ef 100644
--- a/src/E890.h
+++ b/src/E890.h
@@ -3,14 +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_8000ED98(s32*);
-void func_8000F2C4(MtxF*, MtxF*, Vec3s*);
-void func_8000FDE4(MtxF*, MtxF*, Vec3f*);
-void func_80010090(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 ae11722..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"
@@ -350,7 +350,7 @@ void func_86400860(UNUSED s32 arg0) {
 
         gSPEndDisplayList(temp_v0++);
 
-        D_864052C8->unk_190->unk_1C = D_864052C8->unk_028.unk_0AC;
+        D_864052C8->unk_190->unk_1C = D_864052C8->unk_028.unk_0A8[0].unk_04;
     }
 }
 
@@ -813,19 +813,19 @@ void func_86401EEC(void) {
 }
 
 void func_86401F74(void) {
-    D_87B000EC = D_87B000E8->unk_0C;
+    D_87B000EC = D_87B000E8->unk_00.unk_0C;
 
     D_87B000F0 = 0x900;
     D_87B000F2 = 0;
     D_87B000F4 = 0x190;
 
-    D_87B000EC->unk_034 = 50.0f;
-    D_87B000EC->unk_038 = 6400.0f;
-    D_87B000EC->unk_02C = 27.5f;
+    D_87B000EC->unk_24.near = 50.0f;
+    D_87B000EC->unk_24.far = 6400.0f;
+    D_87B000EC->unk_24.fovy = 27.5f;
 
-    D_87B000EC->unk_0B4.y = 25.0f;
+    D_87B000EC->unk_60.at.y = 25.0f;
 
-    func_80010354(&D_87B000EC->unk_0B4, &D_87B000EC->unk_0A8, D_87B000F4, D_87B000F0, D_87B000F2);
+    func_80010354(&D_87B000EC->unk_60.at, &D_87B000EC->unk_60.eye, D_87B000F4, D_87B000F0, D_87B000F2);
 }
 
 void func_8640203C(void) {
diff --git a/src/fragments/11/fragment11.c b/src/fragments/11/fragment11.c
index f05ae43..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"
@@ -712,18 +712,19 @@ void func_86501964(void) {
 }
 
 void func_865019E4(void) {
-    D_87B000EC = D_87B000E8->unk_0C;
+    D_87B000EC = D_87B000E8->unk_00.unk_0C;
 
     D_87B000F0 = -0x200;
     D_87B000F2 = 0;
     D_87B000F4 = 0xBE;
 
-    D_87B000EC->unk_034 = 50.0f;
-    D_87B000EC->unk_038 = 6400.0f;
-    D_87B000EC->unk_02C = 40.0f;
-    D_87B000EC->unk_0B4.y = 51.0f;
+    D_87B000EC->unk_24.near = 50.0f;
+    D_87B000EC->unk_24.far = 6400.0f;
+    D_87B000EC->unk_24.fovy = 40.0f;
 
-    func_80010354(&D_87B000EC->unk_0B4, &D_87B000EC->unk_0A8, D_87B000F4, D_87B000F0, D_87B000F2);
+    D_87B000EC->unk_60.at.y = 51.0f;
+
+    func_80010354(&D_87B000EC->unk_60.at, &D_87B000EC->unk_60.eye, D_87B000F4, D_87B000F0, D_87B000F2);
 }
 
 void func_86501AAC(void) {
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/31/fragment31.h b/src/fragments/31/fragment31.h
new file mode 100644
index 0000000..42bc2c7
--- /dev/null
+++ b/src/fragments/31/fragment31.h
@@ -0,0 +1,8 @@
+#ifndef _FRAGMENT31_H_
+#define _FRAGMENT31_H_
+
+#include "global.h"
+
+void func_810007A8(unk_D_86002F58_004_000*);
+
+#endif // _FRAGMENT31_H_
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/4/fragment4.c b/src/fragments/4/fragment4.c
index ec2c938..553d27a 100644
--- a/src/fragments/4/fragment4.c
+++ b/src/fragments/4/fragment4.c
@@ -86,9 +86,9 @@ void func_87A00020(unk_D_86002F34_00C* arg0) {
 }
 
 Gfx* func_87A0002C(Gfx* arg0) {
-    gSPPerspNormalize(arg0++, D_87A01330->unk_028);
-    gSPMatrix(arg0++, (u32)D_87A01330->unk_024 & 0x1FFFFFFF, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
-    gSPMatrix(arg0++, (u32)D_87A01330->unk_060 & 0x1FFFFFFF, G_MTX_NOPUSH | G_MTX_MUL | G_MTX_PROJECTION);
+    gSPPerspNormalize(arg0++, D_87A01330->unk_24.perspNorm);
+    gSPMatrix(arg0++, (u32)D_87A01330->unk_24.mtx & 0x1FFFFFFF, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
+    gSPMatrix(arg0++, (u32)D_87A01330->unk_60.p_mtxf & 0x1FFFFFFF, G_MTX_NOPUSH | G_MTX_MUL | G_MTX_PROJECTION);
 
     return arg0;
 }
diff --git a/src/fragments/6/fragment6.c b/src/fragments/6/fragment6.c
index a858d18..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"
 
@@ -285,24 +285,25 @@ s32 func_86000410(void) {
 }
 
 void func_86000478(void) {
-    D_86002F38 = D_86002F34->unk_0C;
+    D_86002F38 = D_86002F34->unk_00.unk_0C;
     func_87A00020(D_86002F38);
     D_86002F3C = 0x600;
     D_86002F3E = 0;
     D_86002F40 = 1000;
-    D_86002F38->unk_034 = 100.0f;
-    D_86002F38->unk_038 = 12800.0f;
-    D_86002F38->unk_02C = 10.0f;
 
-    D_86002F38->unk_0B4.x = 0.0f;
-    D_86002F38->unk_0B4.y = 70.0f;
-    D_86002F38->unk_0B4.z = 0.0f;
+    D_86002F38->unk_24.near = 100.0f;
+    D_86002F38->unk_24.far = 12800.0f;
+    D_86002F38->unk_24.fovy = 10.0f;
 
-    func_80010354(&D_86002F38->unk_0B4, &D_86002F38->unk_0A8, D_86002F40, D_86002F3C, D_86002F3E);
+    D_86002F38->unk_60.at.x = 0.0f;
+    D_86002F38->unk_60.at.y = 70.0f;
+    D_86002F38->unk_60.at.z = 0.0f;
+
+    func_80010354(&D_86002F38->unk_60.at, &D_86002F38->unk_60.eye, D_86002F40, D_86002F3C, D_86002F3E);
 }
 
 void func_86000564(void) {
-    func_80010354(&D_86002F38->unk_0B4, &D_86002F38->unk_0A8, D_86002F40, D_86002F3C, D_86002F3E);
+    func_80010354(&D_86002F38->unk_60.at, &D_86002F38->unk_60.eye, D_86002F40, D_86002F3C, D_86002F3E);
 }
 
 #ifdef NON_MATCHING
@@ -496,8 +497,8 @@ void func_86000C18(void) {
 
     for (i = 0; i < 4; i++) {
         D_86003B60 = &D_86002F58[i].unk_004;
-        temp_f20 = (410.0f - D_86003B60->unk_000.unk_0AC.y) / 510.0f;
-        guTranslate(&sp100, D_86003B60->unk_000.unk_0AC.x, 0.0f, 0.0f);
+        temp_f20 = (410.0f - D_86003B60->unk_000.unk_0A8[0].unk_04.y) / 510.0f;
+        guTranslate(&sp100, D_86003B60->unk_000.unk_0A8[0].unk_04.x, 0.0f, 0.0f);
         guScale(&spC0, temp_f20, temp_f20, temp_f20);
         guMtxCatL(&spC0, &sp100, var_s1);
 
diff --git a/src/fragments/7/fragment7.c b/src/fragments/7/fragment7.c
index 825b955..fd0f55b 100644
--- a/src/fragments/7/fragment7.c
+++ b/src/fragments/7/fragment7.c
@@ -522,24 +522,24 @@ void func_86100AEC(void) {
 }
 
 void func_86100B48(void) {
-    D_86105488 = D_86105484->unk_0C;
+    D_86105488 = D_86105484->unk_00.unk_0C;
     func_87A00020(D_86105488);
 
     D_86105490 = 0x600;
     D_86105492 = 0;
     D_86105494 = 0xBB8;
 
-    D_86105488->unk_034 = 100.0f;
-    D_86105488->unk_038 = 12800.0f;
-    D_86105488->unk_02C = 30.0f;
+    D_86105488->unk_24.near = 100.0f;
+    D_86105488->unk_24.far = 12800.0f;
+    D_86105488->unk_24.fovy = 30.0f;
 
-    D_86105488->unk_0B4.x = 0.0f;
-    D_86105488->unk_0B4.y = 371.2f;
-    D_86105488->unk_0B4.z = -732.6f;
+    D_86105488->unk_60.at.x = 0.0f;
+    D_86105488->unk_60.at.y = 371.2f;
+    D_86105488->unk_60.at.z = -732.6f;
 
-    D_86105488->unk_0A8.x = 0.0f;
-    D_86105488->unk_0A8.y = 990.0f;
-    D_86105488->unk_0A8.z = 2659.0f;
+    D_86105488->unk_60.eye.x = 0.0f;
+    D_86105488->unk_60.eye.y = 990.0f;
+    D_86105488->unk_60.eye.z = 2659.0f;
 }
 
 void func_86100C28(void) {
@@ -1832,7 +1832,7 @@ void func_8610426C(void) {
     func_80015094(D_86105484);
 
     for (i = 0; i < 12; i++) {
-        if (func_80015390(&D_86105D38, i + 1, &sp48) != 0) {
+        if (func_80015390(&D_86105D38, (s16)(i + 1), &sp48) != 0) {
             D_86105BC8 = &D_86106450[i].unk_004;
             D_86105BC8->unk_024.x = sp48.x / 10.0f;
             D_86105BC8->unk_024.y = sp48.y / 10.0f;
diff --git a/src/fragments/8/fragment8.c b/src/fragments/8/fragment8.c
index 9641339..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"
@@ -174,7 +174,7 @@ void func_86200034(void) {
     s32 i;
     UNUSED s32 pad2[1];
 
-    func_80031EF4(&spDC, &D_86203E3C->unk_064);
+    func_80031EF4(&spDC, &D_86203E3C->unk_60.mtxf);
     guMtxF2L(spDC.mf, &sp98);
 
     for (i = 0; i < 4; i++) {
@@ -269,20 +269,22 @@ void func_862004D8(void) {
 
 void func_86200528(void) {
     D_8620829C = 0;
-    D_86203E3C = D_86203E38->unk_0C;
+    D_86203E3C = D_86203E38->unk_00.unk_0C;
+
     func_87A00020(D_86203E3C);
     D_86203E40 = 0x1300;
     D_86203E42 = -0x6700;
     D_86203E44 = 0x14A;
-    D_86203E3C->unk_034 = 50.0f;
-    D_86203E3C->unk_038 = 6400.0f;
-    D_86203E3C->unk_02C = 30.0f;
 
-    D_86203E3C->unk_0B4.x = 0.0f;
-    D_86203E3C->unk_0B4.y = 0.0f;
-    D_86203E3C->unk_0B4.z = 5.0f;
+    D_86203E3C->unk_24.near = 50.0f;
+    D_86203E3C->unk_24.far = 6400.0f;
+    D_86203E3C->unk_24.fovy = 30.0f;
 
-    func_80010354(&D_86203E3C->unk_0B4, &D_86203E3C->unk_0A8, D_86203E44, D_86203E40, D_86203E42);
+    D_86203E3C->unk_60.at.x = 0.0f;
+    D_86203E3C->unk_60.at.y = 0.0f;
+    D_86203E3C->unk_60.at.z = 5.0f;
+
+    func_80010354(&D_86203E3C->unk_60.at, &D_86203E3C->unk_60.eye, D_86203E44, D_86203E40, D_86203E42);
 }
 
 void func_86200620(void) {
@@ -367,7 +369,7 @@ void func_86200620(void) {
         D_86203E44 = 0x32;
     }
 
-    func_80010354(&D_86203E3C->unk_0B4, &D_86203E3C->unk_0A8, D_86203E44, D_86203E40, D_86203E42);
+    func_80010354(&D_86203E3C->unk_60.at, &D_86203E3C->unk_60.eye, D_86203E44, D_86203E40, D_86203E42);
 }
 
 void func_86200938(void) {
diff --git a/src/fragments/9/fragment9.c b/src/fragments/9/fragment9.c
index 860454d..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"
@@ -107,21 +107,21 @@ void func_8630011C(void) {
 }
 
 void func_86300154(void) {
-    D_86301718 = D_86301714->unk_0C;
+    D_86301718 = D_86301714->unk_00.unk_0C;
 
     D_8630171C = 0x600;
     D_8630171E = 0;
     D_86301720 = 0x15E;
 
-    D_86301718->unk_034 = 100.0f;
-    D_86301718->unk_038 = 12800.0f;
-    D_86301718->unk_02C = 30.0f;
+    D_86301718->unk_24.near = 100.0f;
+    D_86301718->unk_24.far = 12800.0f;
+    D_86301718->unk_24.fovy = 30.0f;
 
-    D_86301718->unk_0B4.x = 0.0f;
-    D_86301718->unk_0B4.y = 70.0f;
-    D_86301718->unk_0B4.z = 0.0f;
+    D_86301718->unk_60.at.x = 0.0f;
+    D_86301718->unk_60.at.y = 70.0f;
+    D_86301718->unk_60.at.z = 0.0f;
 
-    func_80010354(&D_86301718->unk_0B4, &D_86301718->unk_0A8, D_86301720, D_8630171C, D_8630171E);
+    func_80010354(&D_86301718->unk_60.at, &D_86301718->unk_60.eye, D_86301720, D_8630171C, D_8630171E);
 }
 
 void func_86300230(void) {
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 e073e15..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,8 +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]
@@ -404,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]
@@ -483,6 +488,8 @@
     - {vram: 0x800A74C0, type: .bss, name: crash_screen}
     - {vram: 0x800A7EA0, type: .bss, name: profiler}
     - {vram: 0x800A8100, type:  bss, name: unk_bss_2}
+    - {vram: 0x800AA6C0, type:  .bss, name: 12D80}
+    - {vram: 0x800ABCC0, type:  bss, name: unk_bss_13}
     - {vram: 0x800AC880, type:  .bss, name: 20330}
     - {vram: 0x800AC890, type:  bss, name: unk_bss_11}
     - {vram: 0x800AE520, type:  .bss, name: 29BA0}