Merge pull request #179 from Kelebek1/fragment41

fragment41
2026-09-29 05:18:50 -05:00 · 2025-04-14 19:41:23 +01:00
parent 197157892f efd70d4bc1
commit e96a7e34d6
24 changed files with 6876 additions and 328 deletions
--- a/include/macros.h
+++ b/include/macros.h
@@ -43,8 +43,8 @@
 #define CLAMP(x, min, max) ((x) < (min) ? (min) : (x) > (max) ? (max) : (x))
 //! checks max first
 #define CLAMP_ALT(x, min, max) ((x) > (max) ? (max) : (x) < (min) ? (min) : (x))
-#define CLAMP_MAX(x, max) ((x) > (max) ? (max) : (x))
-#define CLAMP_MIN(x, min) ((x) < (min) ? (min) : (x))
+#define CLAMP_MAX(x, max) ((x) > (max) ? (x) : (max))
+#define CLAMP_MIN(x, min) ((x) < (min) ? (x) : (min))

 #define ROUND_MAX(x) ((x) + ((x) > 0.0f ? 0.5f : -0.5f))

--- a/include/variables.h
+++ b/include/variables.h
@@ -350,6 +350,129 @@ extern u8 D_4001FB8[];
 extern u8 D_30015E0[];
 extern u8 D_30025E0[];
 extern u8 D_3002C00[];
+extern u8 D_302F690[];
+extern u8 D_302F588[];
+extern u8 D_302F5C8[];
+extern u8 D_302F608[];
+extern u8 D_302F648[];
+extern u8 D_30387B0[];
+extern u8 D_30387F0[];
+extern u8 D_3038830[];
+extern u8 D_3038870[];
+extern u8 D_302F6E0[];
+extern u8 D_302F740[];
+extern u8 D_302F7A0[];
+extern u8 D_302F800[];
+extern u8 D_302F860[];
+extern u8 D_302F8C0[];
+extern u8 D_302F928[];
+extern u8 D_302F988[];
+extern u8 D_302F9E8[];
+extern u8 D_302FA48[];
+extern u8 D_3038C70[];
+extern u8 D_3038D70[];
+extern u8 D_3038E70[];
+extern u8 D_3038F70[];
+extern u8 D_3027168[];
+extern u8 D_3027EE8[];
+extern u8 D_3039070[];
+extern u8 D_3039540[];
+extern u8 D_3039A10[];
+extern u8 D_3039FB0[];
+extern u8 D_303A550[];
+extern u8 D_303AAF0[];
+extern u8 D_303B090[];
+extern u8 D_303B630[];
+extern u8 D_303BBD0[];
+extern u8 D_303C170[];
+extern u8 D_303C710[];
+extern u8 D_303CCB0[];
+extern u8 D_303D250[];
+extern u8 D_303D7F0[];
+extern u8 D_303DD90[];
+extern u8 D_30388B0[];
+extern u8 D_3038990[];
+extern u8 D_3028C68[];
+extern u8 D_3029468[];
+extern u8 D_3029C68[];
+extern u8 D_302A468[];
+extern u8 D_30386B0[];
+extern u8 D_30386F0[];
+extern u8 D_3038730[];
+extern u8 D_3038770[];
+extern u8 D_3014468[];
+extern u8 D_302DE68[];
+extern u8 D_302E418[];
+extern u8 D_302E9C8[];
+extern u8 D_302EF78[];
+extern u8 D_302F528[];
+extern u8 D_303E330[];
+extern u8 D_303FC30[];
+extern u8 D_3040590[];
+extern u8 D_3040270[];
+extern u8 D_303F910[];
+extern u8 D_303F5F0[];
+extern u8 D_3040590[];
+extern u8 D_303FF50[];
+extern u8 D_3040BD0[];
+extern u8 D_303E650[];
+extern u8 D_303E970[];
+extern u8 D_303EFB0[];
+extern u8 D_303F2D0[];
+extern u8 D_30408B0[];
+extern u8 D_303EC90[];
+extern u8 D_3040EF0[];
+extern u8 D_302F6E0[];
+extern u8 D_302F7A0[];
+extern u8 D_302F800[];
+extern u8 D_302F860[];
+extern u8 D_302F8C0[];
+extern u8 D_302F928[];
+extern u8 D_302F988[];
+extern u8 D_302F9E8[];
+extern u8 D_302FA48[];
+extern u8 D_302FAB0[];
+extern u8 D_302FDB0[];
+extern u8 D_30300B0[];
+extern u8 D_30303B0[];
+extern u8 D_302BE68[];
+extern u8 D_30306B0[];
+extern u8 D_30326B0[];
+extern u8 D_30346B0[];
+extern u8 D_30366B0[];
+extern u8 D_302AC68[];
+extern u8 D_302B568[];
+extern u8 D_3026168[];
+extern u8 D_3026368[];
+extern u8 D_3026568[];
+extern u8 D_3026768[];
+extern u8 D_3026968[];
+extern u8 D_3026B68[];
+extern u8 D_3026D68[];
+extern u8 D_3026F68[];
+extern u8 D_300D868[];
+extern u8 D_300EA68[];
+extern u8 D_300FC68[];
+extern u8 D_3010E68[];
+extern u8 D_3012068[];
+extern u8 D_3013268[];
+extern u8 D_3012068[];
+extern u8 D_3010E68[];
+extern u8 D_300FC68[];
+extern u8 D_300EA68[];
+extern u8 D_3005D28[];
+extern u8 D_300D108[];
+extern u8 D_300D278[];
+extern u8 D_3006000[];
+extern u8 D_3009DC8[];
+extern u8 D_300B768[];
+extern u8 D_30079A0[];
+extern u8 D_3009BC0[];
+extern u8 D_30081A8[];
+extern u8 D_3038A70[];
+extern u8 D_3038AF0[];
+extern u8 D_3038B70[];
+extern u8 D_3038BF0[];

 extern LEODiskID D_800818E0;

@@ -476,7 +599,9 @@ typedef struct unk_D_80072B00 {
 extern unk_D_80072B00 D_80072B00[];

 typedef struct unk_D_80072338 {
-    /* 0x00 */ char unk00[0xC];
+    /* 0x00 */ char unk00[0x1];
+    /* 0x01 */ u8 unk_01;
+    /* 0x02 */ char unk02[0xA];
 } unk_D_80072338; // size = 0xC
 extern unk_D_80072338 D_80072338[];

--- a/linker_scripts/us/symbol_addrs.txt
+++ b/linker_scripts/us/symbol_addrs.txt
@@ -601,4 +601,119 @@ D_800FCEB8 = 0x800FCEB8; // size:0x8
 D_800FCEB6 = 0x800FCEB6; // size:0x2
 D_30015E0 = 0x30015E0;
 D_30025E0 = 0x30025E0;
-D_3002C00 = 0x3002C00;
+D_3002C00 = 0x3002C00;
+D_82F144D0 = 0x82F144D0; // size:0xC530
+D_302F690 = 0x302F690;
+D_302F588 = 0x302F588;
+D_302F5C8 = 0x302F5C8;
+D_302F608 = 0x302F608;
+D_302F648 = 0x302F648;
+D_30387B0 = 0x30387B0;
+D_30387F0 = 0x30387F0;
+D_3038830 = 0x3038830;
+D_3038870 = 0x3038870;
+D_302F6E0 = 0x302F6E0;
+D_302F740 = 0x302F740;
+D_302F7A0 = 0x302F7A0;
+D_302F800 = 0x302F800;
+D_302F860 = 0x302F860;
+D_302F8C0 = 0x302F8C0;
+D_302F928 = 0x302F928;
+D_302F988 = 0x302F988;
+D_302F9E8 = 0x302F9E8;
+D_302FA48 = 0x302FA48;
+D_3038C70 = 0x3038C70;
+D_3038D70 = 0x3038D70;
+D_3038E70 = 0x3038E70;
+D_3038F70 = 0x3038F70;
+D_3027168 = 0x3027168;
+D_3027EE8 = 0x3027EE8;
+D_3039070 = 0x3039070;
+D_3039540 = 0x3039540;
+D_3039A10 = 0x3039A10;
+D_3039FB0 = 0x3039FB0;
+D_303A550 = 0x303A550;
+D_303AAF0 = 0x303AAF0;
+D_303B090 = 0x303B090;
+D_303B630 = 0x303B630;
+D_303BBD0 = 0x303BBD0;
+D_303C170 = 0x303C170;
+D_303C710 = 0x303C710;
+D_303CCB0 = 0x303CCB0;
+D_303D250 = 0x303D250;
+D_303D7F0 = 0x303D7F0;
+D_303DD90 = 0x303DD90;
+D_30388B0 = 0x30388B0;
+D_3038990 = 0x3038990;
+D_3028C68 = 0x3028C68;
+D_3029468 = 0x3029468;
+D_3029C68 = 0x3029C68;
+D_302A468 = 0x302A468;
+D_30386B0 = 0x30386B0;
+D_30386F0 = 0x30386F0;
+D_3038730 = 0x3038730;
+D_3038770 = 0x3038770;
+D_3014468 = 0x3014468;
+D_302DE68 = 0x302DE68;
+D_302E418 = 0x302E418;
+D_302E9C8 = 0x302E9C8;
+D_302EF78 = 0x302EF78;
+D_302F528 = 0x302F528;
+D_303E330 = 0x303E330;
+D_303FC30 = 0x303FC30;
+D_3040590 = 0x3040590;
+D_3040270 = 0x3040270;
+D_303F910 = 0x303F910;
+D_303F5F0 = 0x303F5F0;
+D_303FF50 = 0x303FF50;
+D_3040BD0 = 0x3040BD0;
+D_303E650 = 0x303E650;
+D_303E970 = 0x303E970;
+D_303EFB0 = 0x303EFB0;
+D_303F2D0 = 0x303F2D0;
+D_30408B0 = 0x30408B0;
+D_303EC90 = 0x303EC90;
+D_3040EF0 = 0x3040EF0;
+D_302FAB0 = 0x302FAB0;
+D_302FDB0 = 0x302FDB0;
+D_30300B0 = 0x30300B0;
+D_30303B0 = 0x30303B0;
+D_302BE68 = 0x302BE68;
+D_30306B0 = 0x30306B0;
+D_30326B0 = 0x30326B0;
+D_30346B0 = 0x30346B0;
+D_30366B0 = 0x30366B0;
+D_302AC68 = 0x302AC68;
+D_302B568 = 0x302B568;
+D_82F210E0 = 0x82F210E0; // size:0x3C
+D_82F21140 = 0x82F21140; // size:0x1C
+D_82F21160 = 0x82F21160; // size:0x40
+D_82F211A0 = 0x82F211A0; // size:0x98
+D_82F21238 = 0x82F21238; // size:0x30
+D_3026168 = 0x3026168;
+D_3026368 = 0x3026368;
+D_3026568 = 0x3026568;
+D_3026768 = 0x3026768;
+D_3026968 = 0x3026968;
+D_3026B68 = 0x3026B68;
+D_3026D68 = 0x3026D68;
+D_3026F68 = 0x3026F68;
+D_300D868 = 0x300D868;
+D_300EA68 = 0x300EA68;
+D_300FC68 = 0x300FC68;
+D_3010E68 = 0x3010E68;
+D_3012068 = 0x3012068;
+D_3013268 = 0x3013268;
+D_3005D28 = 0x3005D28;
+D_300D108 = 0x300D108;
+D_300D278 = 0x300D278;
+D_3006000 = 0x3006000;
+D_3009DC8 = 0x3009DC8;
+D_300B768 = 0x300B768;
+D_30079A0 = 0x30079A0;
+D_3009BC0 = 0x3009BC0;
+D_30081A8 = 0x30081A8;
+D_3038A70 = 0x3038A70;
+D_3038AF0 = 0x3038AF0;
+D_3038B70 = 0x3038B70;
+D_3038BF0 = 0x3038BF0;
--- a/linker_scripts/us/undefined_syms.ld
+++ b/linker_scripts/us/undefined_syms.ld
@@ -196,3 +196,112 @@ D_04001C28 = 0x04001C28;
 D_4001FB8 = 0x4001FB8;
 D_4001010 = 0x4001010;
 D_4006AB8 = 0x4006AB8;
+D_302F690 = 0x302F690;
+D_302F588 = 0x302F588;
+D_302F5C8 = 0x302F5C8;
+D_302F608 = 0x302F608;
+D_302F648 = 0x302F648;
+D_30387B0 = 0x30387B0;
+D_30387F0 = 0x30387F0;
+D_3038830 = 0x3038830;
+D_3038870 = 0x3038870;
+D_302F6E0 = 0x302F6E0;
+D_302F740 = 0x302F740;
+D_302F7A0 = 0x302F7A0;
+D_302F800 = 0x302F800;
+D_302F860 = 0x302F860;
+D_302F8C0 = 0x302F8C0;
+D_302F928 = 0x302F928;
+D_302F988 = 0x302F988;
+D_302F9E8 = 0x302F9E8;
+D_302FA48 = 0x302FA48;
+D_3038C70 = 0x3038C70;
+D_3038D70 = 0x3038D70;
+D_3038E70 = 0x3038E70;
+D_3038F70 = 0x3038F70;
+D_3027168 = 0x3027168;
+D_3027EE8 = 0x3027EE8;
+D_3039070 = 0x3039070;
+D_3039540 = 0x3039540;
+D_3039A10 = 0x3039A10;
+D_3039FB0 = 0x3039FB0;
+D_303A550 = 0x303A550;
+D_303AAF0 = 0x303AAF0;
+D_303B090 = 0x303B090;
+D_303B630 = 0x303B630;
+D_303BBD0 = 0x303BBD0;
+D_303C170 = 0x303C170;
+D_303C710 = 0x303C710;
+D_303CCB0 = 0x303CCB0;
+D_303D250 = 0x303D250;
+D_303D7F0 = 0x303D7F0;
+D_303DD90 = 0x303DD90;
+D_30388B0 = 0x30388B0;
+D_3038990 = 0x3038990;
+D_3028C68 = 0x3028C68;
+D_3029468 = 0x3029468;
+D_3029C68 = 0x3029C68;
+D_302A468 = 0x302A468;
+D_30386B0 = 0x30386B0;
+D_30386F0 = 0x30386F0;
+D_3038730 = 0x3038730;
+D_3038770 = 0x3038770;
+D_3014468 = 0x3014468;
+D_302DE68 = 0x302DE68;
+D_302E418 = 0x302E418;
+D_302E9C8 = 0x302E9C8;
+D_302EF78 = 0x302EF78;
+D_302F528 = 0x302F528;
+D_303E330 = 0x303E330;
+D_303FC30 = 0x303FC30;
+D_3040590 = 0x3040590;
+D_3040270 = 0x3040270;
+D_303F910 = 0x303F910;
+D_303F5F0 = 0x303F5F0;
+D_303FF50 = 0x303FF50;
+D_3040BD0 = 0x3040BD0;
+D_303E650 = 0x303E650;
+D_303E970 = 0x303E970;
+D_303EFB0 = 0x303EFB0;
+D_303F2D0 = 0x303F2D0;
+D_30408B0 = 0x30408B0;
+D_303EC90 = 0x303EC90;
+D_3040EF0 = 0x3040EF0;
+D_302FAB0 = 0x302FAB0;
+D_302FDB0 = 0x302FDB0;
+D_30300B0 = 0x30300B0;
+D_30303B0 = 0x30303B0;
+D_302BE68 = 0x302BE68;
+D_30306B0 = 0x30306B0;
+D_30326B0 = 0x30326B0;
+D_30346B0 = 0x30346B0;
+D_30366B0 = 0x30366B0;
+D_302AC68 = 0x302AC68;
+D_302B568 = 0x302B568;
+D_3026168 = 0x3026168;
+D_3026368 = 0x3026368;
+D_3026568 = 0x3026568;
+D_3026768 = 0x3026768;
+D_3026968 = 0x3026968;
+D_3026B68 = 0x3026B68;
+D_3026D68 = 0x3026D68;
+D_3026F68 = 0x3026F68;
+D_300D868 = 0x300D868;
+D_300EA68 = 0x300EA68;
+D_300FC68 = 0x300FC68;
+D_3010E68 = 0x3010E68;
+D_3012068 = 0x3012068;
+D_3013268 = 0x3013268;
+D_3005D28 = 0x3005D28;
+D_300D108 = 0x300D108;
+D_300D278 = 0x300D278;
+D_3006000 = 0x3006000;
+D_3009DC8 = 0x3009DC8;
+D_300B768 = 0x300B768;
+D_30079A0 = 0x30079A0;
+D_3009BC0 = 0x3009BC0;
+D_30081A8 = 0x30081A8;
+D_3038A70 = 0x3038A70;
+D_3038AF0 = 0x3038AF0;
+D_3038B70 = 0x3038B70;
+D_3038BF0 = 0x3038BF0;
--- a/src/1AB70.c
+++ b/src/1AB70.c
@@ -259,7 +259,7 @@ void func_8001B058(void) {
    D_800ABE10.unk_A04.unk_10 = func_800044F4(0x820000, NULL, 1, 1);
 }

-void func_8001B088(unk_func_88201DA0_034_008* arg0, s32 arg1) {
+void func_8001B088(u16* arg0, s32 arg1) {
    BinArchive* temp_v1;
    u8* temp_a1;

@@ -270,7 +270,7 @@ void func_8001B088(unk_func_88201DA0_034_008* arg0, s32 arg1) {
    }
 }

-void func_8001B0DC(unk_func_88201DA0_034_008* arg0, s32 arg1, unk_func_80026268_arg0* arg2) {
+void func_8001B0DC(u16* arg0, s32 arg1, unk_func_80026268_arg0* arg2) {
    arg1_func_80010CA8 sp1C;

    if (arg2 == 0) {
--- a/src/1AB70.h
+++ b/src/1AB70.h
@@ -6,10 +6,6 @@
 #include "F420.h"
 #include "29BA0.h"

-typedef struct unk_func_88201DA0_034_008 {
-    /* 0x00 */ char unk00[0x4];
-} unk_func_88201DA0_034_008; // size >= 0x4
-
 typedef struct unk_func_8001B1FC {
    /* 0x00 */ u16 unk_00;
    /* 0x02 */ u16 unk_02;
@@ -66,7 +62,7 @@ void func_8001A324(unk_func_8001A024*, s32, s32, u16);
 s32 func_8001ABAC(unk_func_8001A024*, s32);
 void* func_8001AFD8(unk_func_8001A024*, s32);
 void func_8001B058(void);
-void func_8001B0DC(unk_func_88201DA0_034_008*, s32, unk_func_80026268_arg0*);
+void func_8001B0DC(u16*, s32, unk_func_80026268_arg0*);
 unk_func_8001B1FC* func_8001B1FC(unk_D_86002F58_004_000_010*, s16, s16, s16, s16, s16, s16, u8*);
 void func_8001B2D8(unk_func_8001B1FC* arg0, unk_func_80026268_arg0* arg1, u16 arg2);
 void func_8001B480(unk_func_8001B1FC*, s32, u16);
--- a/src/22630.c
+++ b/src/22630.c
@@ -7,8 +7,6 @@
 #include "src/hal_libc.h"
 #include "src/util.h"

-extern unk_D_80070F84 D_80070F84[];
-
 u16 func_80021A30(u8* arg0) {
    return (arg0[0] << 8) | arg0[1];
 }
--- a/src/22630.h
+++ b/src/22630.h
@@ -25,6 +25,12 @@ typedef struct unk_D_80070F84 {
 extern unk_D_80070F84 D_80070F84[];
 extern unk_D_80070F84 D_80070FA0[];

+typedef struct unk_D_80071D88 {
+    /* 0x00 */ char* type_name;
+    /* 0x04 */ Color_RGB8 color;
+} unk_D_80071D88; // size = 0x8
+extern unk_D_80071D88 D_80071D88[];
+
 typedef struct unk_D_800AE4E8_004_1_000_010_000 {
    /* 0x00 */ u8 unk_00;
    /* 0x01 */ u8 unk_01[2];
--- a/src/2D340.h
+++ b/src/2D340.h
@@ -22,8 +22,7 @@ typedef struct unk_func_88200FA0_030_038 {
 typedef struct unk_func_88201DA0_034 {
    /* 0x0000 */ s32 unk_000;
    /* 0x0004 */ char unk004[0x4];
-    /* 0x0008 */ unk_func_88201DA0_034_008 unk_008;
-    /* 0x000C */ char unk00C[0xC7C];
+    /* 0x0008 */ u16 unk_008[0x640];
 } unk_func_88201DA0_034; // size = 0xC88

 typedef struct unk_func_88201DA0_038 {
--- a/src/2E110.c
+++ b/src/2E110.c
@@ -22,9 +22,9 @@ char** func_8002D5AC(s32 file_number) {
    return (char**)func_8000484C(D_800AF740, file_number);
 }

-void func_8002D5D4(u32 arg0, char* arg1) {
+void func_8002D5D4(u32 arg0, u32 arg1) {
    if ((arg0 >= 0x14) && (arg0 < 0x2A)) {
-        D_800AF744[arg0] = arg1;
+        D_800AF744[arg0] = (char*)arg1;
    }
 }

@@ -53,18 +53,18 @@ void func_8002D628(char* arg0, u32 arg1, s8* arg2) {
        switch (var_s2) {
            case 0:
                temp_v0 = *arg2++;
-                if (temp_v0 == 0) {
+                if (temp_v0 == '\x00') {
                    goto end;
                }

-                if (temp_v0 == 0x23) {
+                if (temp_v0 == '#') {
                    temp_v0 = *arg2++;

                    temp_v0 -= '0';
                    temp_v0 = (*arg2++ + (temp_v0 * 10)) - '0';
                    if ((temp_v0 > 0) && (temp_v0 < 10)) {
-                        sprintf(&sp58, "%d", D_800AF744[temp_v0]);
-                        var_s4 = &sp58;
+                        sprintf(sp58, "%d", D_800AF744[temp_v0]);
+                        var_s4 = sp58;
                        var_s2 = 1;
                        continue;
                    }
@@ -85,7 +85,7 @@ void func_8002D628(char* arg0, u32 arg1, s8* arg2) {

            case 1:
                temp_v0 = *var_s4++;
-                if (temp_v0 == 0) {
+                if (temp_v0 == '\x00') {
                    var_s2 = 0;
                } else {
                    *arg0++ = temp_v0;
@@ -96,9 +96,8 @@ void func_8002D628(char* arg0, u32 arg1, s8* arg2) {
        }
    }

-    sp54 = var_s4;
 end:
-    *arg0++ = 0;
+    *arg0++ = '\x00';
 }

 char* func_8002D7C0(char* arg0, s32 arg1, char** arg2, u32 file_number) {
--- a/src/2E110.h
+++ b/src/2E110.h
@@ -5,7 +5,7 @@

 void func_8002D510(void);
 char** func_8002D5AC(s32 file_number);
-void func_8002D5D4(u32 arg0, char* arg1);
+void func_8002D5D4(u32 arg0, u32 arg1);
 void func_8002D600(u32 arg0, char* arg1);
 void func_8002D628(char* arg0, u32 arg1, s8* arg2);
 char* func_8002D7C0(char* arg0, s32 arg1, char** arg2, u32 file_number);
--- a/src/fragments/26/fragment26.c
+++ b/src/fragments/26/fragment26.c
@@ -2293,24 +2293,21 @@ s32 func_8850897C(unk_func_885088F4* arg0) {
    return 0;
 }

-#ifdef NON_MATCHING
 s32 func_88508AA8(unk_func_885088F4* arg0, s32 arg1, s32 arg2) {
    static Color_RGBA8 D_8850CF8C = { 0x38, 0x38, 0x68, 0xFF };

-    s32 color;
+    u32 color = RGBA5551(D_8850CF8C.r, D_8850CF8C.g, D_8850CF8C.b, 1);

    gDPPipeSync(gDisplayListHead++);
    gDPSetCycleType(gDisplayListHead++, G_CYC_FILL);
    gDPSetRenderMode(gDisplayListHead++, G_RM_NOOP, G_RM_NOOP2);
-    color = ((D_8850CF8C.r << 8) & 0xF800) | ((D_8850CF8C.g << 3) & 0x7C0) | ((D_8850CF8C.b >> 2) & 0x3E) | 1;
    gDPSetFillColor(gDisplayListHead++, (color << 0x10) | color);

    gDPFillRectangle(gDisplayListHead++, CLAMP_MAX(arg1, 0), CLAMP_MAX(arg2, 0), CLAMP_MAX(arg1 + 0x27F, 0),
                     CLAMP_MAX((arg0->unk_00.unk_14.unk_02 + arg2) - 0x16, 0));

-    gDPFillRectangle(gDisplayListHead++, CLAMP_MAX((arg0->unk_34 + arg1) - 1, 0),
-                     CLAMP_MAX((arg0->unk_00.unk_14.unk_02 + arg2) - 6, 0), CLAMP_MAX(arg1, 0),
-                     CLAMP_MAX((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15, 0));
+    gDPFillRectangle(gDisplayListHead++, CLAMP_MAX(arg1, 0), CLAMP_MAX((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15, 0),
+                     CLAMP_MAX((arg0->unk_34 + arg1) - 1, 0), CLAMP_MAX((arg0->unk_00.unk_14.unk_02 + arg2) - 6, 0));

    gDPFillRectangle(gDisplayListHead++, CLAMP_MAX((arg1 - arg0->unk_38) + 0x280, 0),
                     CLAMP_MAX((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15, 0), CLAMP_MAX(arg1 + 0x27F, 0),
@@ -2327,76 +2324,38 @@ s32 func_88508AA8(unk_func_885088F4* arg0, s32 arg1, s32 arg2) {
    gDPLoadTextureBlock(gDisplayListHead++, D_4007948, G_IM_FMT_IA, G_IM_SIZ_8b, 8, 5, 0, G_TX_NOMIRROR | G_TX_WRAP,
                        G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);

-    gSPTextureRectangle(
-        gDisplayListHead++, CLAMP_MAX(arg1 << 2, 0), CLAMP_MAX((((arg0->unk_00.unk_14.unk_02 + arg2) - 5) << 2), 0),
-        CLAMP_MAX(((arg0->unk_34 + arg1) << 2), 0), CLAMP_MAX(((arg0->unk_00.unk_14.unk_02 + arg2) << 2), 0),
-        G_TX_RENDERTILE, ((arg1 << 2) < 0) ? CLAMP_MIN(((s16)arg1 << 0xA) >> 7, 0) : 0,
-        -((((arg0->unk_00.unk_14.unk_02 + arg2) - 5) & 0x20000000)
-              ? CLAMP_MIN((((s16)((arg0->unk_00.unk_14.unk_02 + arg2) - 5) << 0xA) >> 7), 0)
-              : 0),
-        0x0400, 0x0400);
+    gSPScisTextureRectangle(gDisplayListHead++, arg1 << 2, ((arg0->unk_00.unk_14.unk_02 + arg2) - 5) << 2,
+                            (arg0->unk_34 + arg1) << 2, (arg0->unk_00.unk_14.unk_02 + arg2) << 2, G_TX_RENDERTILE, 0, 0,
+                            0x400, 0x400);

-    gSPTextureRectangle(gDisplayListHead++, CLAMP_MAX(((arg1 - arg0->unk_38) + 0x280) << 2, 0),
-                        CLAMP_MAX(((arg0->unk_00.unk_14.unk_02 + arg2) - 5) << 2, 0), CLAMP_MAX((arg1 + 0x280) << 2, 0),
-                        CLAMP_MAX((arg0->unk_00.unk_14.unk_02 + arg2) << 2, 0), G_TX_RENDERTILE,
-                        ((((arg1 - arg0->unk_38) + 0x280) << 2) < 0)
-                            ? CLAMP_MIN(((s16)((arg1 - arg0->unk_38) + 0x280) << 0xA) >> 7, 0)
-                            : 0,
-                        -((((arg0->unk_00.unk_14.unk_02 + arg2) - 5) & 0x20000000)
-                              ? CLAMP_MIN(((s16)((arg0->unk_00.unk_14.unk_02 + arg2) - 5) << 0xA) >> 7, 0)
-                              : 0),
-                        0x0400, 0x0400);
+    gSPScisTextureRectangle(gDisplayListHead++, ((arg1 - arg0->unk_38) + 0x280) << 2,
+                            ((arg0->unk_00.unk_14.unk_02 + arg2) - 5) << 2, (arg1 + 0x280) << 2,
+                            (arg0->unk_00.unk_14.unk_02 + arg2) << 2, G_TX_RENDERTILE, 0, 0, 0x400, 0x400);

-    gSPTextureRectangle(
-        gDisplayListHead++, CLAMP_MAX((arg0->unk_34 + arg1 + 0x10) << 2, 0),
-        CLAMP_MAX(((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) << 2, 0),
-        CLAMP_MAX(((arg1 - arg0->unk_38) + 0x270) << 2, 0),
-        CLAMP_MAX(((arg0->unk_00.unk_14.unk_02 + arg2) - 0x10) << 2, 0), G_TX_RENDERTILE,
-        (((arg0->unk_34 + arg1 + 0x10) << 2) < 0) ? CLAMP_MIN(((s16)(arg0->unk_34 + arg1 + 0x10) << 0xA) >> 7, 0) : 0,
-        -((((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) & 0x20000000)
-              ? CLAMP_MIN(((s16)((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) << 0xA) >> 7, 0)
-              : 0),
-        0x0400, 0x0400);
+    gSPScisTextureRectangle(gDisplayListHead++, (arg0->unk_34 + arg1 + 0x10) << 2,
+                            ((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) << 2, ((arg1 - arg0->unk_38) + 0x270) << 2,
+                            ((arg0->unk_00.unk_14.unk_02 + arg2) - 0x10) << 2, G_TX_RENDERTILE, 0, 0, 0x400, 0x400);

    gDPPipeSync(gDisplayListHead++);
    gDPSetRenderMode(gDisplayListHead++, G_RM_XLU_SURF, G_RM_XLU_SURF2);
-    gDPSetCombineLERP(gDisplayListHead++, TEXEL0, COMBINED, PRIMITIVE, 0, 0, 0, 0, 0, TEXEL0, 0, PRIMITIVE, SHADE, 0, 0,
-                      0, 0);
+    gDPSetCombineMode(gDisplayListHead++, G_CC_MODULATEIDECALA_PRIM, G_CC_MODULATEIDECALA_PRIM);

    gDPLoadTextureBlock(gDisplayListHead++, D_4007978, G_IM_FMT_IA, G_IM_SIZ_8b, 16, 21, 0, G_TX_NOMIRROR | G_TX_WRAP,
                        G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);

-    gSPTextureRectangle(gDisplayListHead++, CLAMP_MAX((arg0->unk_34 + arg1) << 2, 0),
-                        CLAMP_MAX(((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) << 2, 0),
-                        CLAMP_MAX(((arg1 - arg0->unk_38) + 0x270) << 2, 0),
-                        CLAMP_MAX((arg0->unk_00.unk_14.unk_02 + arg2) << 2, 0), G_TX_RENDERTILE,
-                        (((arg0->unk_34 + arg1) << 2) < 0) ? CLAMP_MIN(((s16)(arg0->unk_34 + arg1) << 0xA) >> 7, 0) : 0,
-                        -(((s16)((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) & 0x20000000)
-                              ? CLAMP_MIN(((s16)((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) << 0xA) >> 7, 0)
-                              : 0),
-                        0x0400, 0x0400);
+    gSPScisTextureRectangle(gDisplayListHead++, (arg0->unk_34 + arg1) << 2,
+                            ((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) << 2, ((arg1 - arg0->unk_38) + 0x270) << 2,
+                            (arg0->unk_00.unk_14.unk_02 + arg2) << 2, G_TX_RENDERTILE, 0, 0, 0x400, 0x400);

    gDPLoadTextureBlock(gDisplayListHead++, D_4007978, G_IM_FMT_IA, G_IM_SIZ_8b, 16, 21, 0, G_TX_MIRROR | G_TX_WRAP,
                        G_TX_NOMIRROR | G_TX_WRAP, 4, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);

-    gSPTextureRectangle(gDisplayListHead++, CLAMP_MAX((s16)(((arg1 - arg0->unk_38) + 0x270) << 2), 0),
-                        CLAMP_MAX((s16)(((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) << 2), 0),
-                        CLAMP_MAX((s16)(((arg1 - arg0->unk_38) + 0x280) << 2), 0),
-                        CLAMP_MAX((s16)((arg0->unk_00.unk_14.unk_02 + arg2) << 2), 0), G_TX_RENDERTILE,
-                        0x200 - ((s16)(((arg1 - arg0->unk_38) + 0x270) << 2) < 0
-                                     ? CLAMP_MIN(((s16)(((arg1 - arg0->unk_38) + 0x270) << 2) << 0xA) >> 7, 0)
-                                     : 0),
-                        -(((s16)((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) & 0x20000000)
-                              ? CLAMP_MIN(((s16)((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) << 0xA) >> 7, 0)
-                              : 0),
-                        0x0400, 0x0400);
+    gSPScisTextureRectangle(gDisplayListHead++, ((arg1 - arg0->unk_38) + 0x270) << 2,
+                            ((arg0->unk_00.unk_14.unk_02 + arg2) - 0x15) << 2, ((arg1 - arg0->unk_38) + 0x280) << 2,
+                            (arg0->unk_00.unk_14.unk_02 + arg2) << 2, G_TX_RENDERTILE, 0x200, 0, 0x400, 0x400);

    return 0;
 }
-#else
-static Color_RGBA8 D_8850CF8C = { 0x38, 0x38, 0x68, 0xFF };
-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/26/fragment26/func_88508AA8.s")
-#endif

 void func_88509A2C(unk_func_88509A2C* arg0, s32 arg1, s32 arg2, s32 arg3, char* arg4) {
    func_885007CC(&arg0->unk_00, sizeof(unk_func_88509A2C));
--- a/src/fragments/40/fragment40.c
+++ b/src/fragments/40/fragment40.c
@@ -481,22 +481,10 @@ void func_831010E0(unk_D_83101F00* arg0, s16 arg1) {
    }
 }

-#ifdef NON_MATCHING
 void func_831011D4(s16 arg0, s16 arg1, s16 arg2, s16 arg3, s16 arg4, s16 arg5, s16 arg6, s16 arg7) {
-    gSPTextureRectangle(gDisplayListHead++, CLAMP_MIN(0, (s16)(arg0 << 2)), CLAMP_MIN(0, (s16)(arg1 << 2)),
-                        CLAMP_MIN(0, (s16)(((arg0 + arg2) - 1) << 2)), CLAMP_MIN(0, (s16)(((arg1 + arg3) - 1) << 2)),
-                        G_TX_RENDERTILE,
-                        arg4 - ((arg0 << 2) < 0 ? arg6 < 0 ? CLAMP_MIN(0, ((arg0 << 2) * arg6) >> 7)
-                                                           : CLAMP_MAX(0, ((arg0 << 2) * arg6) >> 7)
-                                                : 0),
-                        arg5 - ((arg1 << 0x2) < 0 ? arg7 < 0 ? CLAMP_MIN(0, ((arg1 << 2) * arg7) >> 7)
-                                                             : CLAMP_MAX(0, ((arg1 << 2) * arg7) >> 7)
-                                                  : 0),
-                        arg6, arg7);
+    gSPScisTextureRectangle(gDisplayListHead++, arg0 << 2, arg1 << 2, ((arg0 + arg2) - 1) << 2,
+                            ((arg1 + arg3) - 1) << 2, 0, arg4, arg5, arg6, arg7);
 }
-#else
-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/40/fragment40/func_831011D4.s")
-#endif

 void func_831013FC(void) {
    f32 v = 1.8f;
--- a/src/fragments/41/fragment41.h
+++ b/src/fragments/41/fragment41.h
@@ -0,0 +1,446 @@
+#ifndef _FRAGMENT41_H_
+#define _FRAGMENT41_H_
+
+#include "global.h"
+#include "src/1AB70.h"
+#include "src/29BA0.h"
+
+typedef struct unk_func_82F00838_sp30_00C {
+    /* 0x00 */ u8 unk_00;
+    /* 0x01 */ char unk01[0xD];
+    /* 0x0E */ u16 unk_0E;
+    /* 0x10 */ char unk10[0x14];
+    /* 0x24 */ u8 unk_24;
+    /* 0x25 */ char unk25[0xB];
+    /* 0x30 */ char unk_30[11];
+    /* 0x3B */ char unk_3B[11];
+    /* 0x46 */ char unk46[0xA];
+    /* 0x50 */ s32 force_align;
+} unk_func_82F00838_sp30_00C; // size = 0x54
+
+typedef struct unk_D_82F144D0_0CA8 {
+    /* 0x000 */ s16 unk_000;
+    /* 0x004 */ struct unk_D_82F144D0_0CA8* unk_004;
+    /* 0x008 */ struct unk_D_82F144D0_0CA8* unk_008;
+    /* 0x00C */ unk_func_82F00838_sp30_00C unk_00C[20];
+} unk_D_82F144D0_0CA8; // size = 0x69C
+
+typedef struct unk_D_82F144D0 {
+    /* 0x0000 */ s16 unk_0000;
+    /* 0x0002 */ s16 unk_0002;
+    /* 0x0004 */ s16 unk_0004;
+    /* 0x0006 */ s16 unk_0006;
+    /* 0x0008 */ s16 unk_0008;
+    /* 0x000A */ s16 unk_000A;
+    /* 0x000C */ s16 unk_000C;
+    /* 0x000E */ s16 unk_000E;
+    /* 0x0010 */ s16 unk_0010;
+    /* 0x0012 */ s16 unk_0012;
+    /* 0x0014 */ s16 unk_0014;
+    /* 0x0016 */ s16 unk_0016;
+    /* 0x0018 */ s16 unk_0018;
+    /* 0x001A */ s16 unk_001A;
+    /* 0x001C */ s16 unk_001C;
+    /* 0x001E */ s16 unk_001E;
+    /* 0x0020 */ s16 unk_0020;
+    /* 0x0022 */ char unk0022[0x6];
+    /* 0x0028 */ u16 unk_0028[0x640];
+    /* 0x0CA8 */ unk_D_82F144D0_0CA8 unk_0CA8[13];
+    /* 0x6294 */ char unk6294[0x4];
+} unk_D_82F144D0; // size = 0x6298
+
+typedef struct unk_func_82F00838_sp30 {
+    /* 0x00 */ s16 unk_00;
+    /* 0x02 */ s16 unk_02;
+    /* 0x04 */ s16 unk_04;
+    /* 0x06 */ s16 unk_06;
+    /* 0x08 */ s16 unk_08;
+    /* 0x0C */ unk_func_82F00838_sp30_00C* unk_0C;
+} unk_func_82F00838_sp30; // size = 0x10
+
+typedef struct unk_D_82F14450 {
+    /* 0x00 */ u8 unk_00;
+    /* 0x01 */ u8 unk_01;
+    /* 0x02 */ u8 unk_02;
+    /* 0x03 */ u8 unk_03;
+    /* 0x04 */ u8 unk_04;
+    /* 0x05 */ u8 unk_05;
+    /* 0x06 */ u16 unk_06;
+    /* 0x08 */ char unk_08[1];
+    /* 0x09 */ char unk09[0xD];
+} unk_D_82F14450; // size = 0x16
+
+typedef struct unk_D_82F13B78 {
+    /* 0x00 */ s16 unk_00;
+    /* 0x02 */ s16 unk_02;
+    /* 0x04 */ char* unk_04;
+} unk_D_82F13B78; // size = 0x8
+
+typedef struct unk_D_82F20A10 {
+    /* 0x00 */ s16 unk_00;
+    /* 0x02 */ s16 unk_02;
+    /* 0x04 */ s16 unk_04;
+    /* 0x06 */ s16 unk_06;
+    /* 0x08 */ s16 unk_08;
+    /* 0x0A */ s16 unk_0A;
+    /* 0x0C */ s16 unk_0C;
+    /* 0x0E */ s16 unk_0E;
+    /* 0x10 */ s16 unk_10;
+    /* 0x14 */ unk_func_80026268_arg0* unk_14;
+    /* 0x18 */ unk_D_82F144D0* unk_18;
+    /* 0x1C */ s32 unk_1C;
+    /* 0x20 */ unk_D_86002F58_004_000_010* unk_20;
+    /* 0x24 */ unk_func_8001B1FC* unk_24;
+} unk_D_82F20A10; // size >= 0x28
+
+typedef struct unk_D_82F20A40_00E {
+    /* 0x00 */ s16 unk_00;
+    /* 0x02 */ s16 unk_02;
+    /* 0x04 */ s16 unk_04;
+    /* 0x06 */ s16 unk_06;
+} unk_D_82F20A40_00E; // size = 0x8
+
+typedef struct unk_D_82F20A40 {
+    /* 0x00 */ s16 unk_00;
+    /* 0x02 */ s16 unk_02;
+    /* 0x04 */ s16 unk_04;
+    /* 0x06 */ unk_D_82F20A40_00E unk_06;
+    /* 0x0E */ unk_D_82F20A40_00E unk_0E[3];
+    /* 0x26 */ unk_D_82F20A40_00E unk_26;
+    /* 0x2E */ unk_D_82F20A40_00E unk_2E;
+    /* 0x36 */ unk_D_82F20A40_00E unk_36;
+    /* 0x40 */ unk_D_82F20A40_00E* unk_40;
+    /* 0x44 */ unk_D_82F20A40_00E* unk_44;
+} unk_D_82F20A40; // size = 0x48
+
+typedef struct unk_D_82F20A88 {
+    /* 0x000 */ s16 unk_000;
+    /* 0x002 */ s16 unk_002;
+    /* 0x004 */ s16 unk_004;
+    /* 0x006 */ s16 unk_006;
+    /* 0x008 */ s16 unk_008;
+    /* 0x00A */ s16 unk_00A;
+    /* 0x00C */ s16 unk_00C;
+    /* 0x00E */ s16 unk_00E;
+    /* 0x010 */ s16 unk_010;
+    /* 0x012 */ s16 unk_012;
+    /* 0x014 */ s16 unk_014;
+    /* 0x018 */ f32 unk_018;
+    /* 0x01C */ f32 unk_01C;
+    /* 0x020 */ f32 unk_020;
+    /* 0x024 */ u8* unk_024;
+    /* 0x028 */ unk_D_86002F58_004_000 unk_028;
+} unk_D_82F20A88; // size = 0x190
+
+typedef struct unk_D_82F210E0 {
+    /* 0x00 */ s16 unk_00;
+    /* 0x02 */ s16 unk_02;
+    /* 0x04 */ u16 unk_04;
+    /* 0x06 */ s16 unk_06;
+    /* 0x08 */ s16 unk_08;
+    /* 0x0A */ s16 unk_0A;
+    /* 0x0C */ s16 unk_0C;
+    /* 0x0E */ s16 unk_0E;
+    /* 0x10 */ s16 unk_10;
+    /* 0x12 */ s16 unk_12;
+    /* 0x14 */ unk_D_82F20A40_00E unk_14[2];
+    /* 0x24 */ unk_D_82F20A40_00E unk_24;
+    /* 0x2C */ unk_D_82F20A40_00E unk_2C;
+    /* 0x34 */ unk_D_82F20A40_00E unk_34;
+} unk_D_82F210E0; // size = 0x3C
+
+typedef struct unk_D_82F21160 {
+    /* 0x00 */ s16 unk_00;
+    /* 0x02 */ s16 unk_02;
+    /* 0x04 */ s16 unk_04;
+    /* 0x06 */ s16 unk_06;
+    /* 0x08 */ s16 unk_08;
+    /* 0x0A */ s16 unk_0A;
+    /* 0x0C */ s16 unk_0C;
+    /* 0x0E */ s16 unk_0E;
+    /* 0x10 */ s16 unk_10;
+    /* 0x12 */ s16 unk_12;
+    /* 0x14 */ f32 unk_14;
+    /* 0x18 */ f32 unk_18;
+    /* 0x1C */ f32 unk_1C;
+} unk_D_82F21160; // size = 0x20
+
+typedef struct unk_D_82F21140 {
+    /* 0x00 */ s16 unk_00;
+    /* 0x02 */ s16 unk_02;
+    /* 0x04 */ s16 unk_04;
+    /* 0x06 */ s16 unk_06;
+    /* 0x08 */ s16 unk_08;
+    /* 0x0A */ s16 unk_0A;
+    /* 0x0C */ u16 unk_0C;
+    /* 0x0E */ s16 unk_0E;
+    /* 0x10 */ f32 unk_10;
+    /* 0x14 */ u16 unk_14;
+    /* 0x16 */ u16 unk_16;
+    /* 0x18 */ s16 unk_18;
+} unk_D_82F21140; // size = 0x1C
+
+typedef struct unk_D_82F211A0_010 {
+    /* 0x00 */ s16 unk_00;
+    /* 0x02 */ s16 unk_02;
+    /* 0x04 */ s16 unk_04;
+} unk_D_82F211A0_010; // size = 0x6
+
+typedef struct unk_D_82F211A0 {
+    /* 0x00 */ s16 unk_00;
+    /* 0x02 */ s16 unk_02;
+    /* 0x00 */ s16 unk_04;
+    /* 0x06 */ s16 unk_06;
+    /* 0x08 */ s16 unk_08;
+    /* 0x0A */ s16 unk_0A;
+    /* 0x0C */ s16 unk_0C;
+    /* 0x0E */ s16 unk_0E;
+    /* 0x10 */ unk_D_82F211A0_010 unk_10[10];
+} unk_D_82F211A0; // size = 0x4C
+
+typedef struct unk_D_82F21238 {
+    /* 0x00 */ s16 unk_00;
+    /* 0x02 */ s16 unk_02;
+    /* 0x04 */ s16 unk_04;
+    /* 0x06 */ s16 unk_06;
+    /* 0x08 */ s16 unk_08;
+    /* 0x0A */ s16 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 */ s16 unk_1C;
+    /* 0x1E */ s16 unk_1E;
+    /* 0x20 */ s32 unk_20;
+    /* 0x24 */ unk_func_80026268_arg0* unk_24;
+    /* 0x28 */ unk_D_86002F58_004_000_010* unk_28;
+    /* 0x2C */ unk_func_8001B1FC* unk_2C;
+    /* 0x30 */ unk_D_82F20A40_00E unk_30;
+} unk_D_82F21238; // size = 0x38
+
+extern s32 D_82F14424;
+extern unk_D_82F14450 D_82F14450[4];
+
+extern char** D_82F13B70;
+extern char** D_82F13B74;
+
+char* func_82F00020(s32 arg0);
+char* func_82F00058(s32 arg0);
+char* func_82F00090(s32 arg0);
+void func_82F000C8(s16 arg0);
+void func_82F00138(void);
+void func_82F00164(void);
+void func_82F00284(void);
+void func_82F002BC(s16 arg0, s16 arg1, s8* arg2, s32 arg3);
+void func_82F0036C(void);
+void func_82F00378(unk_D_82F13B78* arg0, s32 arg1);
+s32 func_82F003F8(unk_D_82F13B78* arg0);
+void func_82F00424(void);
+s32 func_82F00524(void);
+void func_82F00568(void);
+void func_82F00704(void);
+void func_82F00734(void);
+void func_82F00838(void);
+void func_82F00960(void);
+void func_82F00968(void);
+void func_82F00A58(void);
+void func_82F00AC8(s32 arg0);
+void func_82F00C14(s16 arg0);
+void func_82F00C50(void);
+void func_82F00CE0(void);
+void func_82F00D3C(void);
+void func_82F00E88(void);
+void func_82F00F3C(void);
+void func_82F00FD8(void);
+s32 func_82F0109C(void);
+void func_82F01180(void);
+s32 func_82F01234(s32 arg0, s32 arg1);
+
+s16 func_82F01390(unk_D_82F144D0* arg0, s16 arg1);
+u16* func_82F014E4(u8* arg0, s16 arg1, s16 arg2);
+void func_82F01530(s32 arg0, s16 arg1);
+s32 func_82F018F8(void);
+void func_82F01920(unk_D_82F144D0* arg0);
+void func_82F01A70(unk_D_82F144D0* arg0);
+void func_82F01FE4(unk_D_82F144D0* arg0);
+void func_82F020B4(unk_D_82F144D0* arg0);
+void func_82F02180(unk_D_82F144D0* arg0);
+void func_82F022DC(s16 arg0, s16 arg1, s16 arg2, s16 arg3);
+void func_82F02544(s16 arg0, s16 arg1, s16 arg2);
+void func_82F028AC(s16 arg0, s16 arg1, s16 arg2, s16 arg3, Color_RGB8* arg4, s16 arg5);
+void func_82F029FC(s16 arg0, s16 arg1, s16 arg2);
+void func_82F02B5C(s16 arg0, s16 arg1, s16 arg2);
+void func_82F02CE8(s16 arg0, s16 arg1, s16 arg2, s16 arg3);
+void func_82F02EAC(s16 arg0, s16 arg1, s16 arg2);
+void func_82F02FEC(s16 arg0, s16 arg1, s16 arg2, s16 arg3, u8 arg4, u8 arg5, u8 arg6, u8 arg7);
+void func_82F037EC(s16, s16, s16, s16, u8, u8, u8, u8);
+void func_82F04010(s16 arg0, s16 arg1, u8* arg2, s16 arg3);
+void func_82F040D0(unk_D_82F144D0* arg0, s16 arg1, s16 arg2, s32 arg3);
+void func_82F043A4(s16 arg0, s16 arg1, s16 arg2);
+void func_82F04604(unk_D_82F144D0* arg0);
+void func_82F04FD4(void);
+void func_82F0504C(void);
+void func_82F05110(void);
+u16* func_82F05198(s32);
+void func_82F051B8(void);
+s32 func_82F0525C(s32 arg0, unk_func_82F00838_sp30* arg1);
+
+void func_82F05210(s16, unk_func_80026268_arg0*);
+void func_82F052F0(unk_D_82F144D0* arg0, u8* arg1, s16 arg2, s16 arg3);
+void func_82F053F8(unk_D_82F20A10* arg0);
+void func_82F05560(unk_D_82F20A10* arg0);
+void func_82F056D0(unk_D_82F20A10* arg0);
+void func_82F05828(s16 arg0, s16 arg1, s16 arg2, s16 arg3, u8 arg4, u8 arg5, u8 arg6);
+void func_82F05920(s16 arg0, s16 arg1, s16 arg2, s16 arg3, u8 arg4, u8 arg5, u8 arg6);
+void func_82F05C50(s16 arg0, s16 arg1, s32 arg2);
+void func_82F05D74(s16 arg0, s16 arg1, s16 arg2);
+s32 func_82F05F20(s32 arg0);
+void func_82F05F40(unk_D_82F20A10* arg0);
+void func_82F06D50(void);
+void func_82F06D88(void);
+void func_82F06E04(void);
+s32 func_82F06E38(void);
+
+s32 func_82F06E50(s32 arg0, GraphNode* arg1);
+s16 func_82F06F9C(unk_D_82F14450* arg0);
+void func_82F07004(s16 arg0);
+void func_82F07214(unk_D_82F20A88* arg0, s16 arg1);
+void func_82F07440(unk_D_82F20A88* arg0);
+void func_82F07498(unk_D_82F20A88* arg0);
+void func_82F0761C(unk_D_82F20A88* arg0);
+void func_82F0763C(unk_D_82F20A88* arg0);
+void func_82F07728(unk_D_82F20A88* arg0);
+void func_82F07784(unk_D_82F20A88* arg0);
+void func_82F077E0(void);
+void func_82F07958(void);
+s32 func_82F07A54(s16 arg0);
+s32 func_82F07A74(void);
+void func_82F07A80(unk_D_82F20A40* arg0, s32 arg1);
+void func_82F07DEC(unk_D_82F20A40* arg0);
+void func_82F08084(unk_D_82F20A40* arg0);
+void func_82F081FC(unk_D_82F20A40* arg0);
+void func_82F0822C(unk_D_82F20A40* arg0);
+void func_82F083B0(unk_D_82F20A40* arg0, s16 arg1, s16 arg2);
+void func_82F084EC(unk_D_82F20A40* arg0);
+void func_82F0856C(unk_D_82F20A40* arg0);
+void func_82F0866C(unk_D_82F20A40* arg0);
+void func_82F087F8(unk_D_82F20A40_00E* arg0, s16 arg1, s16 arg2);
+void func_82F088F8(unk_D_82F20A40* arg0);
+void func_82F08968(unk_D_82F20A40* arg0);
+void func_82F08B7C(unk_D_82F20A40* arg0);
+void func_82F08EB4(unk_D_82F20A40* arg0);
+void func_82F0917C(unk_D_82F20A40* arg0);
+void func_82F09284(unk_D_82F20A40* arg0);
+void func_82F094B4(unk_D_82F20A40* arg0);
+void func_82F097D8(s16 arg0, s16 arg1);
+void func_82F09B70(s16 arg0);
+void func_82F09C6C(void);
+void func_82F09D2C(void);
+void func_82F09E30(void);
+
+s32 func_82F09EB0(unk_func_82F00838_sp30* arg0);
+s32 func_82F09F44(unk_D_82F210E0* arg0);
+void func_82F0A0A8(s32 arg0);
+void func_82F0A23C(unk_D_82F210E0* arg0);
+void func_82F0A5F8(unk_D_82F210E0* arg0);
+void func_82F0A804(unk_D_82F210E0* arg0);
+void func_82F0A850(unk_D_82F210E0* arg0);
+void func_82F0A950(unk_D_82F210E0* arg0);
+void func_82F0AA50(unk_D_82F210E0* arg0);
+void func_82F0AB68(unk_D_82F210E0* arg0);
+void func_82F0ACC4(unk_D_82F210E0* arg0);
+void func_82F0B2A4(s16 arg0, s16 arg1, s16 arg2);
+void func_82F0B3E0(unk_D_82F210E0* arg0);
+void func_82F0B7B4(unk_D_82F210E0* arg0);
+void func_82F0BBE8(unk_D_82F210E0* arg0);
+void func_82F0BD38(unk_D_82F210E0* arg0);
+void func_82F0BE7C(s16 arg0, s16 arg1, s16 arg2, s16 arg3);
+void func_82F0BEF8(unk_D_82F210E0* arg0);
+s32 func_82F0C16C(void);
+s32 func_82F0C178(void);
+s32 func_82F0C184(void);
+void func_82F0C190(void);
+void func_82F0C254(void);
+void func_82F0C320(void);
+
+void func_82F0C410(s16 arg0, s16 arg1, s16 arg2, s16 arg3, s16 arg4, s16 arg5, s16 arg6, s16 arg7, s32 arg8);
+void func_82F0C630(void);
+void func_82F0C658(s32 arg0, s16 arg1);
+void func_82F0C784(unk_D_82F211A0* arg0);
+void func_82F0C7FC(unk_D_82F211A0* arg0);
+void func_82F0C8EC(unk_D_82F211A0* arg0);
+void func_82F0C958(unk_D_82F211A0* arg0);
+void func_82F0CA7C(unk_D_82F211A0* arg0);
+void func_82F0CB90(void);
+void func_82F0CC3C(void);
+void func_82F0D084(void);
+void func_82F0D090(unk_D_82F21238* arg0, s32 arg1);
+void func_82F0D160(s16 arg0);
+void func_82F0D27C(unk_D_82F21238* arg0);
+void func_82F0D2F4(unk_D_82F21238* arg0);
+s32 func_82F0D3F4(s32 arg0);
+void func_82F0D428(unk_D_82F21238* arg0);
+void func_82F0D51C(unk_D_82F21238* arg0);
+s32 func_82F0D64C(s16 arg0, s8* arg1);
+void func_82F0D6D0(s16 arg0, unk_func_80026268_arg0* arg1);
+void func_82F0D76C(unk_D_82F21238* arg0);
+void func_82F0D834(unk_D_82F21238* arg0);
+void func_82F0DA60(unk_D_82F21238* arg0);
+void func_82F0DCF4(void);
+void func_82F0DD90(s16 arg0, s16 arg1, s16 arg2);
+void func_82F0E5C8(s16 arg0, s16 arg1, s16 arg2, s16 arg3);
+void func_82F0E97C(unk_D_82F21238* arg0);
+void func_82F0ECA4(void);
+void func_82F0ECAC(unk_D_82F20A40_00E* arg0, unk_func_80026268_arg0* arg1);
+void func_82F0EE58(void);
+void func_82F0EF68(void);
+void func_82F0EFC4(s32 arg0, s16 arg1);
+void func_82F0F260(unk_D_82F21160* arg0);
+void func_82F0F2AC(unk_D_82F21160* arg0);
+void func_82F0F374(unk_D_82F21160* arg0);
+void func_82F0F578(unk_D_82F21160* arg0);
+void func_82F0F600(unk_D_82F21160* arg0);
+void func_82F0F654(unk_D_82F21160* arg0);
+void func_82F0F714(unk_D_82F21160* arg0);
+void func_82F0F79C(unk_D_82F21160* arg0);
+void func_82F0F89C(void);
+void func_82F0F9E0(s16 arg0, s16 arg1, f32 arg2, s16 arg3);
+void func_82F0FCC0(void);
+s32 func_82F0FDCC(void);
+void func_82F0FDEC(s16 arg0);
+void func_82F10034(unk_D_82F21140* arg0);
+void func_82F10110(unk_D_82F21140* arg0);
+void func_82F101C8(unk_D_82F21140* arg0);
+void func_82F10348(unk_D_82F21140* arg0);
+void func_82F10400(unk_D_82F21140* arg0);
+void func_82F10454(unk_D_82F21140* arg0);
+void func_82F1050C(unk_D_82F21140* arg0);
+void func_82F10674(unk_D_82F21140* arg0);
+void func_82F10710(unk_D_82F21140* arg0);
+void func_82F10744(unk_D_82F21140* arg0);
+void func_82F10818(unk_D_82F21140* arg0);
+void func_82F1084C(unk_D_82F21140* arg0);
+void func_82F1091C(unk_D_82F21140* arg0);
+void func_82F10950(unk_D_82F21140* arg0);
+void func_82F10A24(unk_D_82F21140* arg0);
+void func_82F10BB4(s16 arg0, s16 arg1, f32 arg2);
+void func_82F10ED0(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5);
+void func_82F11264(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5);
+void func_82F115F8(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5);
+void func_82F1198C(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5);
+void func_82F11D68(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5, s16 arg6);
+void func_82F1228C(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5);
+void func_82F12614(void);
+void func_82F12DE4(s16 arg0, s16 arg1, f32 arg2, s16 arg3, s16 arg4, s16 arg5);
+void func_82F13278(void);
+void func_82F132D0(void);
+void func_82F13414(void);
+s32 func_82F13964(s16 arg0);
+void func_82F13B4C(s16 arg0);
+s16 func_82F13B64(void);
+
+#endif // _FRAGMENT41_H_
--- a/src/fragments/41/fragment41_287ED0.c
+++ b/src/fragments/41/fragment41_287ED0.c
@@ -1,64 +1,646 @@
-#include "global.h"
+#include "fragment41.h"
+#include "src/19840.h"
+#include "src/1C720.h"
+#include "src/1CF30.h"
+#include "src/20330.h"
+#include "src/20470.h"
+#include "src/225A0.h"
+#include "src/22630.h"
+#include "src/232C0.h"
+#include "src/2E110.h"
+#include "src/3FB0.h"
+#include "src/49790.h"
+#include "src/4BDC0.h"
+#include "src/6A40.h"
+#include "src/controller.h"
+#include "src/memory.h"
+#include "src/stage_loader.h"

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00020.s")
+typedef struct unk_D_82F14438 {
+    /* 0x00 */ s16 unk_00;
+    /* 0x02 */ s16 unk_02;
+    /* 0x04 */ s16 unk_04;
+    /* 0x06 */ s16 unk_06;
+    /* 0x08 */ s16 unk_08;
+    /* 0x0A */ s16 unk_0A;
+    /* 0x0C */ u16 unk_0C;
+    /* 0x10 */ s8* unk_10;
+} unk_D_82F14438; // size = 0x14

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00058.s")
+typedef struct unk_D_82F144B0 {
+    /* 0x00 */ s16 unk_00;
+    /* 0x02 */ s16 unk_02;
+    /* 0x04 */ s16 unk_04;
+    /* 0x06 */ s16 unk_06;
+    /* 0x08 */ s16 unk_08;
+} unk_D_82F144B0; // size = 0xA

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00090.s")
+static unk_D_800AC870* D_82F14420;
+s32 D_82F14424;
+static s32 D_82F14428;
+static s16 D_82F1442C;
+static unk_D_82F13B78* D_82F14430;
+static s32 pad_D_82F14434;
+static unk_D_82F14438 D_82F14438;
+static unk_D_82F14438* D_82F1444C;
+unk_D_82F14450 D_82F14450[4];
+static s16 D_82F144A8;
+static s16 D_82F144AA;
+static s32 pad_D_82F144AC;
+static unk_D_82F144B0 D_82F144B0;
+static s32 D_82F144BC;
+static s32 D_82F144C0;
+static char** D_82F144C4;
+static char** D_82F144C8;
+static char** D_82F144CC;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F000C8.s")
+char** D_82F13B70 = NULL;
+char** D_82F13B74 = NULL;
+static unk_D_82F13B78 D_82F13B78[2] = {
+    { 0x0140, 0x0168, NULL },
+    { 0x0000, 0x0000, NULL },
+};
+static u16 D_82F13B88 = 0;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00138.s")
+char* func_82F00020(s32 arg0) {
+    return func_8002D7C0(NULL, 0, D_82F144C4, arg0 - 1);
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00164.s")
+char* func_82F00058(s32 arg0) {
+    return func_8002D7C0(NULL, 0, D_82F144C8, arg0 - 1);
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00284.s")
+char* func_82F00090(s32 arg0) {
+    return func_8002D7C0(NULL, 0, D_82F144CC, func_800219FC(arg0));
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F002BC.s")
+void func_82F000C8(s16 arg0) {
+    unk_D_82F144B0* ptr = &D_82F144B0;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F0036C.s")
+    switch (arg0) {
+        case 0:
+            ptr->unk_02 = 0;
+            ptr->unk_04 = 0;
+            ptr->unk_06 = 0x280;
+            ptr->unk_08 = 0x1E0;
+            break;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00378.s")
+        case 1:
+            ptr->unk_02 = 0;
+            ptr->unk_04 = 0x154;
+            ptr->unk_06 = 0x280;
+            ptr->unk_08 = 0x8C;
+            break;
+    }
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F003F8.s")
+void func_82F00138(void) {
+    D_82F144B0.unk_00 = -1;
+    func_82F000C8(0);
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00424.s")
+void func_82F00164(void) {
+    unk_D_82F144B0* ptr = &D_82F144B0;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00524.s")
+    if ((ptr->unk_00 != 0) && (func_82F0FDCC() != 0)) {
+        if (ptr->unk_00 > 0) {
+            ptr->unk_00--;
+        }

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00568.s")
+        gSPDisplayList(gDisplayListHead++, D_8006F4C0);
+        gDPSetFillColor(gDisplayListHead++, 0x00010001);
+        gDPFillRectangle(gDisplayListHead++, ptr->unk_02, ptr->unk_04, (ptr->unk_02 + ptr->unk_06) - 1,
+                         (ptr->unk_04 + ptr->unk_08) - 1);
+    }
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00704.s")
+void func_82F00284(void) {
+    D_82F1444C = &D_82F14438;
+    D_82F14438.unk_00 = 0;
+    D_82F14438.unk_02 = 0;
+    D_82F14438.unk_08 = 0;
+    D_82F14438.unk_0A = 2;
+    D_82F14438.unk_04 = 0;
+    D_82F14438.unk_06 = 0;
+    D_82F14438.unk_0C = 0;
+    D_82F14438.unk_10 = NULL;
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00734.s")
+void func_82F002BC(s16 arg0, s16 arg1, s8* arg2, s32 arg3) {
+    s8* ptr;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00838.s")
+    D_82F1444C->unk_00 = 0;
+    D_82F1444C->unk_02 = 0;
+
+    ptr = arg2;
+    if (ptr != NULL) {
+        while (*ptr != '\x00') {
+            D_82F1444C->unk_02++;
+            ptr++;
+        }
+    }
+
+    D_82F1444C->unk_08 = 0;
+    D_82F1444C->unk_0A = 2;
+    D_82F1444C->unk_04 = arg0;
+    D_82F1444C->unk_06 = arg1;
+    D_82F1444C->unk_0C = 0;
+
+    if (arg3 != 0) {
+        D_82F1444C->unk_0C |= 1;
+    }
+
+    D_82F1444C->unk_10 = arg2;
+}
+
+void func_82F0036C(void) {
+    D_82F14430 = NULL;
+}
+
+void func_82F00378(unk_D_82F13B78* arg0, s32 arg1) {
+    if (arg0 != D_82F14430) {
+        D_82F1442C = 0;
+    }
+
+    D_82F14430 = arg0;
+
+    if (NULL != arg0) {
+        unk_D_82F13B78* ptr = &arg0[D_82F1442C];
+
+        func_82F002BC(ptr->unk_00, ptr->unk_02, ptr->unk_04, arg1);
+        D_82F1442C++;
+    }
+}
+
+s32 func_82F003F8(unk_D_82F13B78* arg0) {
+    unk_D_82F13B78* ptr = &arg0[D_82F1442C];
+    s32 var_v1 = 0;
+
+    if (ptr->unk_04 == NULL) {
+        var_v1 = 1;
+    }
+    return var_v1;
+}
+
+void func_82F00424(void) {
+    u8 tmp;
+
+    if ((D_82F1444C->unk_10 != 0) && (D_82F1444C->unk_00 >= 0)) {
+        if (gPlayer1Controller->buttonPressed & 0x8000) {
+            D_82F1444C->unk_08 = 0;
+            D_82F1444C->unk_0A = 1;
+        } else {
+            D_82F1444C->unk_08 -= 1;
+        }
+
+        if (D_82F1444C->unk_08 <= 0) {
+            func_80048B90(0x01200001);
+            D_82F1444C->unk_08 = D_82F1444C->unk_0A;
+
+            D_82F1444C->unk_00++;
+
+            tmp = D_82F1444C->unk_10[D_82F1444C->unk_00 - 1];
+            if (tmp >= 0x80) {
+                D_82F1444C->unk_00++;
+            }
+
+            if (D_82F1444C->unk_00 >= D_82F1444C->unk_02) {
+                D_82F1444C->unk_00 = -1;
+            }
+        }
+    }
+}
+
+s32 func_82F00524(void) {
+    s32 var_v1 = 0;
+
+    if (D_82F1444C->unk_10 != NULL) {
+        if (D_82F1444C->unk_00 == -1) {
+            var_v1 = 2;
+        } else if (D_82F1444C->unk_00 >= 0) {
+            var_v1 = 1;
+        }
+    }
+
+    return var_v1;
+}
+
+void func_82F00568(void) {
+    s32 i;
+    s32 temp_t0;
+    s8 sp38[0x100];
+
+    if (D_82F1444C->unk_10 != NULL) {
+        func_8001F3F4();
+        func_8001EBE0(0x10, 0);
+
+        if (D_82F1444C->unk_0C & 1) {
+            s32 a = D_82F13B88;
+            u8 arg = a & 0xF;
+
+            arg = (arg * 0xFF) / 15;
+            if (a & 0x10) {
+                arg = 0xFF - arg;
+            }
+            func_8001F324(0xFF, 0xFF, 0xFF, arg);
+        } else {
+            func_8001F324(0xFF, 0xFF, 0xFF, 0xFF);
+        }
+
+        func_8001F3B4(0x1E);
+        temp_t0 = func_8001F5B0(0, 0, D_82F1444C->unk_10) / 2;
+        if (D_82F1444C->unk_00 == -1) {
+            func_8001F1E8(D_82F1444C->unk_04 - temp_t0, D_82F1444C->unk_06, D_82F1444C->unk_10);
+        } else {
+            s8* p_sp38 = sp38;
+            s8* other = D_82F1444C->unk_10;
+
+            for (i = 0; i < D_82F1444C->unk_00; i++) {
+                *p_sp38++ = *other++;
+            }
+
+            *p_sp38 = '\x00';
+            func_8001F1E8(D_82F1444C->unk_04 - temp_t0, D_82F1444C->unk_06, &sp38);
+        }
+        func_8001F444();
+        D_82F13B88++;
+    }
+}
+
+void func_82F00704(void) {
+    Cont_StartReadInputs();
+    Cont_ReadInputs();
+    func_8001F730();
+}
+
+void func_82F00734(void) {
+    UNUSED s32 pad;
+    unk_D_82F14450* ptr;
+    unk_D_800AC910_040 sp40;
+    u8 temp_s2 = Cont_GetControllerBits();
+    s32 i;
+
+    main_pool_push_state('info');
+
+    for (i = 0, ptr = &D_82F14450[0]; i < 4; i++, ptr++) {
+        func_80025040(i, &sp40);
+        func_80023AF8(i);
+        func_80021B5C(ptr->unk_08, sp40.unk_02);
+        ptr->unk_06 = sp40.unk_00;
+        ptr->unk_01 = func_80024F68(i);
+        ptr->unk_00 = func_80024F00(i);
+        ptr->unk_03 = func_80025370(i);
+        ptr->unk_04 = func_8002539C(i);
+        ptr->unk_05 = (temp_s2 & (1 << i)) != 0;
+        ptr->unk_02 = func_80024F8C(i);
+    }
+
+    main_pool_pop_state('info');
+}
+
+void func_82F00838(void) {
+    s32 i;
+    unk_func_82F00838_sp30_00C sp50;
+    unk_func_82F00838_sp30 sp30[2];
+
+    for (i = 0; i < 2; i++) {
+        func_82F0525C(i, &sp30[i]);
+    }
+
+    sp50 = sp30[0].unk_0C[sp30[0].unk_06];
+    sp30[0].unk_0C[sp30[0].unk_06] = sp30[1].unk_0C[sp30[1].unk_06];
+    sp30[1].unk_0C[sp30[1].unk_06] = sp50;
+
+    func_82F051B8();
+}

 void func_82F00960(void) {
 }

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00968.s")
+void func_82F00968(void) {
+    func_8001BB20();
+    func_8002D510();
+    D_82F13B70 = func_8002D5AC(0x21);
+    D_82F13B74 = func_8002D5AC(6);
+    D_82F144C4 = func_8002D5AC(0x24);
+    D_82F144C8 = func_8002D5AC(0x25);
+    D_82F144CC = func_8002D5AC(0x26);
+    D_82F13B78[0].unk_04 = func_8002D7C0(NULL, 0, D_82F13B70, 0);
+    D_82F14428 = 0;
+    func_82F0036C();
+    D_82F14424 = 0;
+    D_82F144A8 = 0;
+    D_82F144BC = 0;
+    func_82F00138();
+    func_82F00284();
+    func_82F13278();
+    func_82F00734();
+    func_82F09C6C();
+    func_82F04FD4();
+    func_82F0C190();
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00A58.s")
+void func_82F00A58(void) {
+    func_800079C4();
+    func_82F00164();
+    if (func_82F0FDCC() != 0) {
+        func_82F13414();
+    }
+    func_82F00568();
+    func_82F09E30();
+    func_82F05110();
+    func_82F0C320();
+    func_82F00960();
+    func_80007778();
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00AC8.s")
+void func_82F00AC8(s32 arg0) {
+    D_82F14428 = arg0;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00C14.s")
+    switch (D_82F14428) {
+        case 1:
+            func_82F0036C();
+            func_82F00378(D_82F13B78, 0);
+            break;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00C50.s")
+        case 2:
+            func_82F07958();
+            func_82F002BC(0, 0, 0, 0);
+            break;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00CE0.s")
+        case 4:
+            if (D_82F144A8 == 1) {
+                if (D_82F144BC != 0) {
+                    main_pool_pop_state('pmex');
+                }
+                main_pool_push_state('pmex');
+                D_82F144BC = 1;
+            }
+            func_80023D60(func_82F07A54(D_82F144A8));
+            func_82F01530(D_82F144A8, func_82F07A54(D_82F144A8));
+            break;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00D3C.s")
+        case 5:
+            func_82F0A0A8(0);
+            break;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00E88.s")
+        case 6:
+            func_82F0A0A8(1);
+            break;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00F3C.s")
+        case 7:
+            func_82F000C8(0);
+            func_80006CB4(0xF);
+            func_8004B9C4(0xF);
+            break;
+    }
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F00FD8.s")
+void func_82F00C14(s16 arg0) {
+    D_82F144AA = arg0;
+    func_82F00AC8(3);
+    func_82F0FDEC(D_82F144AA);
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F0109C.s")
+void func_82F00C50(void) {
+    if (BTN_IS_PRESSED(gPlayer1Controller, BTN_A)) {
+        if (func_82F003F8(D_82F13B78) == 0) {
+            func_82F00378(D_82F13B78, 0);
+        } else {
+            func_82F00AC8(2);
+        }
+        func_80048B90(2);
+        func_80048B90(4);
+    } else if (BTN_IS_PRESSED(gPlayer1Controller, BTN_B)) {
+        func_82F00AC8(7);
+        func_80048B90(3);
+    }
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F01180.s")
+void func_82F00CE0(void) {
+    func_82F000C8(1);
+    if (func_82F07A74() == 0) {
+        if (func_82F07A54(1) == -1) {
+            func_82F00AC8(7);
+        } else {
+            func_82F00C14(1);
+        }
+    }
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_287ED0/func_82F01234.s")
+void func_82F00D3C(void) {
+    func_82F000C8(0);
+
+    switch (D_82F144AA) {
+        case 1:
+            if (func_82F13964(1) != 0) {
+                func_82F00AC8(4);
+            }
+            break;
+
+        case 19:
+            if (func_82F13964(2) != 0) {
+                func_82F00AC8(4);
+            }
+            break;
+
+        case 4:
+        case 8:
+        case 11:
+            if (func_82F13964(3) != 0) {
+                func_82F00AC8(2);
+            }
+            break;
+
+        case 20:
+            if (func_82F13964(6) != 0) {
+                func_82F00AC8(5);
+            }
+            break;
+
+        case 21:
+            if (func_82F13964(8) != 0) {
+                func_82F00838();
+                func_82F00C14(0xC);
+            }
+            break;
+
+        case 12:
+            if (func_82F13964(0xC) != 0) {
+                if (D_82F144B0.unk_00 == -1) {
+                    D_82F144B0.unk_00 = 5;
+                }
+            } else {
+                D_82F144B0.unk_00 = -1;
+            }
+
+            if (func_82F13964(0xA) != 0) {
+                func_82F00AC8(6);
+            }
+            break;
+    }
+}
+
+void func_82F00E88(void) {
+    unk_func_82F00838_sp30 sp20;
+
+    if (func_82F018F8() == 0) {
+        func_82F0525C(D_82F144A8, &sp20);
+
+        if (sp20.unk_00 != 0) {
+            if (D_82F144A8 == 0) {
+                func_82F00C14(0x13);
+            } else {
+                func_82F00C14(0x14);
+            }
+            D_82F144A8 ^= 1;
+        } else {
+            if (D_82F144A8 == 0) {
+                func_82F002BC(0, 0, NULL, 0);
+                func_82F00C14(4);
+                return;
+            }
+            func_82F00C14(8);
+            D_82F144A8 = 0;
+        }
+    }
+}
+
+void func_82F00F3C(void) {
+    func_82F000C8(1);
+
+    if (func_82F0C16C() == 2) {
+        if (D_82F144B0.unk_00 == -1) {
+            D_82F144B0.unk_00 = 3;
+        }
+    } else {
+        D_82F144B0.unk_00 = -1;
+    }
+
+    if (func_82F0C16C() == 0) {
+        if (func_82F0C178() != 0) {
+            func_82F00C14(0x15);
+        } else {
+            func_82F00C14(0xB);
+        }
+    }
+}
+
+void func_82F00FD8(void) {
+    func_82F000C8(1);
+
+    if (func_82F0C16C() == 2) {
+        if (D_82F144B0.unk_00 == -1) {
+            D_82F144B0.unk_00 = 3;
+        }
+    } else {
+        D_82F144B0.unk_00 = -1;
+    }
+
+    if (func_82F0C16C() == 7) {
+        D_82F144C0 = 0;
+    } else {
+        D_82F144C0 = 1;
+    }
+
+    if (func_82F0C16C() == 0) {
+        if (func_82F0C184() != 0) {
+            func_82F00AC8(2);
+        } else {
+            func_82F00AC8(7);
+        }
+    }
+}
+
+s32 func_82F0109C(void) {
+    s32 sp1C = 1;
+
+    switch (D_82F14428) {
+        case 0:
+            if (func_80007604() == 0) {
+                func_82F00AC8(1);
+            }
+            break;
+
+        case 1:
+            func_82F00C50();
+            break;
+
+        case 2:
+            func_82F00CE0();
+            break;
+
+        case 3:
+            func_82F00D3C();
+            break;
+
+        case 4:
+            func_82F00E88();
+            break;
+
+        case 5:
+            func_82F00F3C();
+            break;
+
+        case 6:
+            func_82F00FD8();
+            break;
+
+        case 7:
+            if (func_80007604() == 1) {
+                sp1C = 0;
+            }
+            break;
+    }
+    return sp1C;
+}
+
+void func_82F01180(void) {
+    func_80006C6C(0x10);
+    func_8004B1CC(0x10);
+    func_8001F738(gPlayer1Controller);
+
+    D_82F144C0 = 1;
+
+    do {
+        if (D_82F144C0 != 0) {
+            func_82F00704();
+        }
+        func_82F00424();
+        func_82F09D2C();
+        func_82F0504C();
+        func_82F0C254();
+        func_82F132D0();
+        func_82F00A58();
+        D_82F14424++;
+    } while (func_82F0109C() != 0);
+}
+
+s32 func_82F01234(s32 arg0, s32 arg1) {
+    unk_func_80007444* sp24;
+
+    main_pool_push_state('PMEX');
+
+    func_80005E40(0x14000, 0);
+    sp24 = func_80007444(1, 0, 2, 0, 2, 1);
+    D_82F14420 = func_8001E94C(0x1E, 0);
+
+    ASSET_LOAD(D_1000000, common_menu1_ui, 0);
+    ASSET_LOAD(D_3000000, trade_select_ui, 0);
+
+    FRAGMENT_LOAD(fragment31);
+
+    func_8001987C();
+    func_8001B058();
+    func_82F00968();
+    func_80007678(sp24);
+    func_82F01180();
+    func_800077B4(2);
+    func_800076C0();
+    func_8001E9CC();
+    func_80005EAC();
+
+    main_pool_pop_state('PMEX');
+
+    return 0;
+}
--- a/src/fragments/41/fragment41_289240.c
+++ b/src/fragments/41/fragment41_289240.c
--- a/src/fragments/41/fragment41_28D1A0.c
+++ b/src/fragments/41/fragment41_28D1A0.c
@@ -1,29 +1,461 @@
-#include "global.h"
+#include "fragment41.h"
+#include "src/19840.h"
+#include "src/1CF30.h"
+#include "src/20470.h"
+#include "src/225A0.h"
+#include "src/22630.h"
+#include "src/2E110.h"
+#include "src/49790.h"
+#include "src/memory.h"

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F052F0.s")
+static unk_D_82F20A10 D_82F20A10;
+static s16 D_82F20A38;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F053F8.s")
+void func_82F052F0(unk_D_82F144D0* arg0, u8* arg1, s16 arg2, s16 arg3) {
+    unk_D_82F20A10* ptr = &D_82F20A10;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F05560.s")
+    main_pool_push_state('BBRD');

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F056D0.s")
+    ptr->unk_00 = 1;
+    ptr->unk_02 = -1;
+    ptr->unk_04 = arg2;
+    ptr->unk_06 = arg3;
+    ptr->unk_0C = 0;
+    ptr->unk_0E = 0;
+    ptr->unk_08 = arg2;
+    ptr->unk_0A = arg3;
+    ptr->unk_10 = 6;
+    ptr->unk_14 = arg1;
+    ptr->unk_18 = arg0;
+    ptr->unk_1C = NULL;
+    ptr->unk_20 = func_80019760(1);
+    ptr->unk_24 = func_8001B1FC(ptr->unk_20, 0xE4, 0xA0, 0, 0, 0xE0, 0xA0, D_3014468);
+    ptr->unk_24->unk_00 &= ~2;
+    func_8001B2D8(ptr->unk_24, ptr->unk_14, 0x108D);
+    func_80048B90(4);
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F05828.s")
+void func_82F053F8(unk_D_82F20A10* arg0) {
+    arg0->unk_10--;
+    arg0->unk_04 = 0x38 - (((0x38 - arg0->unk_08) * arg0->unk_10) / 6);
+    arg0->unk_06 = 0x70 - (((0x70 - arg0->unk_0A) * arg0->unk_10) / 6);
+    arg0->unk_0C = 0x210 - ((arg0->unk_10 * 0x210) / 6);
+    arg0->unk_0E = 0x148 - ((arg0->unk_10 * 0x148) / 6);
+    if (arg0->unk_10 <= 0) {
+        arg0->unk_00 = 2;
+        arg0->unk_02 = 4;
+        D_82F20A38 = 0;
+    }
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F05920.s")
+void func_82F05560(unk_D_82F20A10* arg0) {
+    static Controller** D_82F13C10[] = {
+        &gPlayer1Controller,
+        &gPlayer1Controller,
+        &gPlayer1Controller,
+        &gPlayer1Controller,
+    };

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F05C50.s")
+    s16 tmp;
+    s32 var_t0;
+    Controller* temp_a3;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F05D74.s")
+    arg0->unk_1C = func_8001B9D4(arg0->unk_24);
+    temp_a3 = *D_82F13C10[arg0->unk_18->unk_000E];
+    var_t0 = 0;
+    tmp = D_82F20A38;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F05F20.s")
+    if (temp_a3->buttonPressed & 0x200) {
+        D_82F20A38--;
+        if (D_82F20A38 < 0) {
+            D_82F20A38 = 0;
+        }
+    }

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F05F40.s")
+    if (temp_a3->buttonPressed & 0x100) {
+        D_82F20A38++;
+        if (D_82F20A38 >= 2) {
+            D_82F20A38 = 1;
+        }
+    }

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F06D50.s")
+    if (D_82F20A38 != tmp) {
+        func_80048B90(1);
+        var_t0 = 0;
+    }

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F06D88.s")
+    if (temp_a3->buttonPressed & 0x8000) {
+        var_t0 = 1;
+    } else if (temp_a3->buttonPressed & 0x4000) {
+        var_t0 = 1;
+        D_82F20A38 = 1;
+    }

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F06E04.s")
+    if (var_t0 != 0) {
+        arg0->unk_00 = 3;
+        arg0->unk_02 = -1;
+        arg0->unk_10 = 6;
+        arg0->unk_1C = 0;
+        if (D_82F20A38 == 0) {
+            arg0->unk_18->unk_0020 = 1;
+            func_80048B90(2);
+        } else {
+            arg0->unk_18->unk_0020 = 0;
+            func_80048B90(3);
+        }
+    }
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_28D1A0/func_82F06E38.s")
+void func_82F056D0(unk_D_82F20A10* arg0) {
+    arg0->unk_10--;
+    arg0->unk_04 = arg0->unk_08 - (((arg0->unk_08 - 0x38) * arg0->unk_10) / 6);
+    arg0->unk_06 = arg0->unk_0A - (((arg0->unk_0A - 0x70) * arg0->unk_10) / 6);
+    arg0->unk_0C = (arg0->unk_10 * 0x210) / 6;
+    arg0->unk_0E = (arg0->unk_10 * 0x148) / 6;
+
+    if (arg0->unk_10 <= 0) {
+        arg0->unk_00 = 0;
+        main_pool_pop_state('BBRD');
+    }
+}
+
+void func_82F05828(s16 arg0, s16 arg1, s16 arg2, s16 arg3, u8 arg4, u8 arg5, u8 arg6) {
+    s32 color = RGBA5551(arg4, arg5, arg6, 1);
+
+    gDPPipeSync(gDisplayListHead++);
+    gDPSetFillColor(gDisplayListHead++, (color << 0x10) | color);
+    gDPFillRectangle(gDisplayListHead++, arg0, arg1, (arg0 + arg2) - 1, (arg1 + arg3) - 1);
+}
+
+void func_82F05920(s16 arg0, s16 arg1, s16 arg2, s16 arg3, u8 arg4, u8 arg5, u8 arg6) {
+    gSPDisplayList(gDisplayListHead++, D_8006F518);
+    gDPSetRenderMode(gDisplayListHead++, G_RM_AA_OPA_SURF, G_RM_AA_OPA_SURF2);
+    gDPSetEnvColor(gDisplayListHead++, arg4, arg5, arg6, 255);
+
+    func_8001CADC(arg0, arg1, 8, 8, D_30387B0, 8, 0);
+    func_8001CADC((arg0 + arg2) - 8, arg1, 8, 8, D_30387F0, 8, 0);
+    func_8001C330(arg0 + 8, arg1, arg2 - 0x10, 8, 0, 0, 0, 0x400, 0);
+    func_8001CADC(arg0, (arg1 + arg3) - 8, 8, 8, D_3038830, 8, 0);
+    func_8001C330(arg0, arg1 + 8, 8, arg3 - 0x10, 0, 0, 0x400, 0, 0);
+    func_8001CADC((arg0 + arg2) - 8, (arg1 + arg3) - 8, 8, 8, D_3038870, 8, 0);
+    func_8001C330(arg0 + 8, (arg1 + arg3) - 8, arg2 - 0x10, 8, 0, 0, 0, 0x400, 0);
+    func_8001C330((arg0 + arg2) - 8, arg1 + 8, 8, arg3 - 0x10, 0, 0, 0x400, 0, 0);
+
+    gSPDisplayList(gDisplayListHead++, D_8006F4C0);
+
+    func_82F05828(arg0 + 8, arg1 + 8, arg2 - 0x10, arg3 - 0x10, arg4, arg5, arg6);
+
+    gSPDisplayList(gDisplayListHead++, D_8006F630);
+}
+
+void func_82F05C50(s16 arg0, s16 arg1, s32 arg2) {
+    s32 temp_v0_3;
+    s16 var_a3;
+    s16 i;
+
+    if (arg2 != 0) {
+        gDPPipeSync(gDisplayListHead++);
+        gDPSetBlendColor(gDisplayListHead++, 0, 0, 0, 128);
+
+        for (i = 0; i < 0xA0; i += 8) {
+            temp_v0_3 = 0xA0 - i;
+            if (temp_v0_3 < 8) {
+                var_a3 = temp_v0_3;
+            } else {
+                var_a3 = 8;
+            }
+            func_8001C6AC(arg0, arg1 + i, 0xE0, var_a3, (i * 0x1C8) + arg2, 0xE4, 0x200000);
+        }
+    }
+}
+
+void func_82F05D74(s16 arg0, s16 arg1, s16 arg2) {
+    static u8* D_82F13C20[] = {
+        D_302F6E0, D_302F740, D_302F7A0, D_302F800, D_302F860, D_302F8C0, D_302F928, D_302F988, D_302F9E8, D_302FA48,
+    };
+
+    s32 i;
+    s32 var_s0;
+    s16 var_s4;
+
+    arg2 %= 100;
+    var_s0 = 0xA;
+    var_s4 = 0;
+
+    for (i = 0; i < 2; i++) {
+        s32 temp_lo = arg2 / var_s0;
+
+        if ((temp_lo != 0) || (var_s4 != 0) || (i == 1)) {
+            func_8001CADC(arg0, arg1, 8, 0xC, D_82F13C20[temp_lo], 8, 0);
+            var_s4 = 1;
+        }
+
+        arg0 += 9;
+        arg2 %= var_s0;
+        var_s0 /= 10;
+    }
+}
+
+s32 func_82F05F20(s32 arg0) {
+    s32 var_v1 = 0;
+
+    if ((arg0 <= 0) || (arg0 >= 0xA6)) {
+        var_v1 = 1;
+    }
+    return var_v1;
+}
+
+void func_82F05F40(unk_D_82F20A10* arg0) {
+    static Color_RGBA8 D_82F13C48 = { 0xFF, 0xFF, 0xFF, 0xFF };
+    static Color_RGB8 D_82F13C4C = { 0x82, 0x1E, 0x1E };
+    static Color_RGB8 D_82F13C50 = { 0x96, 0x64, 0x1E };
+    static s16 D_82F13C54[] = { 0x122, 0x136, 0x1C, 8 };
+    static s16 D_82F13C5C[] = { 0xD3, 0xED, 0x107, 0xED };
+    static s16 D_82F13C64[] = { 0x15E, 0x1BA };
+    static u8* D_82F13C68[] = {
+        D_303E330, D_303FC30, D_3040590, D_3040270, D_303F910, D_303F5F0, D_3040590, D_303FF50,
+        D_3040BD0, D_303E650, D_303E970, D_303EFB0, D_303F2D0, D_30408B0, D_303EC90, D_3040EF0,
+    };
+
+    s32 i;
+    Color_RGB8* var_v0;
+    s16 temp_s0;
+    s16 temp_s1_2;
+    s32 temp_s1_3;
+    unk_func_80026268_arg0* sp11C;
+    unk_D_80072B00* ptr;
+    UNUSED s32 pad;
+    char sp94[128];
+    char* sp8C[2];
+    s32 temp_v0_5;
+    s32 var_t0;
+    s32 sp80;
+
+    sp8C[0] = func_8002D7C0(NULL, 0, D_82F13B70, 0x12);
+    sp8C[1] = func_8002D7C0(NULL, 0, D_82F13B70, 0x13);
+    sp11C = arg0->unk_14;
+    func_82F022DC(arg0->unk_04, arg0->unk_06, arg0->unk_0C, arg0->unk_0E);
+
+    if ((arg0->unk_0C == 0x210) && (arg0->unk_0E == 0x148)) {
+        if (arg0->unk_18->unk_0010 == 0) {
+            var_v0 = &D_82F13C4C;
+        } else {
+            var_v0 = &D_82F13C50;
+        }
+
+        if (arg0->unk_02 != 0) {
+            func_82F05920(arg0->unk_04, arg0->unk_06, 0x210, 0x24, var_v0->r, var_v0->g, var_v0->b);
+            func_82F05920(arg0->unk_04 + 0xE0, arg0->unk_06 + 0x24, 0x130, 0x1C, 0x3C, 0x3C, 0x82);
+            func_82F05920(arg0->unk_04 + 0xE0, arg0->unk_06 + 0x40, 0x130, 0x84, 0x3C, 0x3C, 0x82);
+            func_82F05920(arg0->unk_04, arg0->unk_06 + 0xC4, 0x210, 0x60, 0x3C, 0x3C, 0x82);
+        }
+
+        func_82F05920(arg0->unk_04, arg0->unk_06 + 0x124, 0x210, 0x24, 0x28, 0x28, 0x64);
+        func_80020B88(arg0->unk_04 + 0x140, arg0->unk_06 + 0x5A, 0x94, sp11C->unk_02, sp11C->unk_26);
+
+        gSPDisplayList(gDisplayListHead++, D_8006F4E0);
+
+        func_8001C6AC(arg0->unk_04 + 0xF8, arg0->unk_06 + 0xD0, 0x1C, 0x1A, D_302DE68, 0x1C, 0x200000);
+        func_8001C6AC(arg0->unk_04 + 0xE2, arg0->unk_06 + 0xEA, 0x1C, 0x1A, D_302E9C8, 0x1C, 0x200000);
+        func_8001C6AC(arg0->unk_04 + 0x110, arg0->unk_06 + 0xEA, 0x1C, 0x1A, D_302EF78, 0x1C, 0x200000);
+        func_8001C6AC(arg0->unk_04 + 0xF8, arg0->unk_06 + 0x104, 0x1C, 0x1A, D_302E418, 0x1C, 0x200000);
+
+        for (i = 0; i < 4; i++) {
+            if (sp11C->unk_09[i] == 0) {
+                break;
+            }
+
+            if (func_82F05F20(sp11C->unk_09[i]) == 0) {
+                func_8001C6AC(D_82F13C54[i] + arg0->unk_04, D_82F13C5C[i] + arg0->unk_06, 0x14, 0x14,
+                              D_82F13C68[D_80072338[sp11C->unk_09[i] - 1].unk_01], 0x14, 0x200000);
+            }
+        }
+
+        func_82F05C50(arg0->unk_04, arg0->unk_06 + 0x24, arg0->unk_1C);
+
+        gSPDisplayList(gDisplayListHead++, D_8006F518);
+
+        for (i = 0; i < 4; i++) {
+            if (sp11C->unk_09[i] == 0) {
+                break;
+            }
+
+            if (func_82F05F20(sp11C->unk_09[i]) == 0) {
+                ptr = &D_80072B00[sp11C->unk_09[i] - 1];
+
+                var_t0 = ptr->unk_05 / 5;
+                if (var_t0 >= 7) {
+                    var_t0 = 7;
+                }
+
+                sp80 = ((sp11C->unk_20[i] >> 6) * var_t0) + ptr->unk_05;
+                func_8001CADC(D_82F13C54[i] + arg0->unk_04 + 0xB6, D_82F13C5C[i] + arg0->unk_06 + 6, 8, 0xC, D_302F528,
+                              8, 0);
+                func_82F05D74(D_82F13C54[i] + arg0->unk_04 + 0xA4, D_82F13C5C[i] + arg0->unk_06 + 6,
+                              sp11C->unk_20[i] & 0x3F);
+                func_82F05D74(D_82F13C54[i] + arg0->unk_04 + 0xC0, D_82F13C5C[i] + arg0->unk_06 + 6, sp80);
+            }
+        }
+
+        func_8001F3F4();
+        func_8001EBE0(0x10, 0);
+        func_8001F1E8(arg0->unk_04 + 0x10, arg0->unk_06 + 6, sp11C->unk_30);
+        func_8001EBE0(0x10, 0);
+        func_8001F1E8(arg0->unk_04 + 0xA0, arg0->unk_06 + 6, "%s%d", func_8002D7C0(NULL, 0, D_82F13B74, 0x15),
+                      sp11C->unk_24);
+        func_8001EBE0(8, 0);
+        func_8001F1E8(arg0->unk_04 + 0x12E, arg0->unk_06 + 8, "%s%03d", func_8002D7C0(NULL, 0, D_82F13B74, 0x16),
+                      sp11C->unk_00.unk_00);
+        func_8001EBE0(8, 0);
+        func_8001F1E8(arg0->unk_04 + 0x19C, arg0->unk_06 + 8, func_82F00020(sp11C->unk_00.unk_00));
+
+        temp_s0 = func_800219FC(sp11C->unk_06);
+        temp_s1_2 = func_800219FC(sp11C->unk_07);
+
+        func_8001EBE0(8, 0);
+        func_8001F1E8(arg0->unk_04 + 0xE4, arg0->unk_06 + 0x28, func_8002D7C0(NULL, 0, D_82F13B70, 0xC));
+        func_8001F324(0xFF, 0xFF, 0xFF, 0xFF);
+        func_8001F1E8(arg0->unk_04 + 0x120, arg0->unk_06 + 0x28, "1/");
+        func_8001F324(D_80071D88[temp_s0].color.r, D_80071D88[temp_s0].color.g, D_80071D88[temp_s0].color.b, 0xFF);
+        func_8001F1E8(arg0->unk_04 + 0x13E, arg0->unk_06 + 0x28, "%s", func_82F00090(sp11C->unk_06));
+
+        if (sp11C->unk_06 != sp11C->unk_07) {
+            func_8001F324(0xFF, 0xFF, 0xFF, 0xFF);
+            func_8001F1E8(arg0->unk_04 + 0x19E, arg0->unk_06 + 0x28, "2/");
+            func_8001F324(D_80071D88[temp_s1_2].color.r, D_80071D88[temp_s1_2].color.g, D_80071D88[temp_s1_2].color.b,
+                          0xFF);
+            func_8001F1E8(arg0->unk_04 + 0x1BC, arg0->unk_06 + 0x28, "%s", func_82F00090(sp11C->unk_07));
+        }
+
+        func_8001F324(0xFF, 0xFF, 0xFF, 0xFF);
+        func_8001EBE0(8, 0);
+        func_8001F1E8(arg0->unk_04 + 0x144, arg0->unk_06 + 0x44, func_8002D7C0(NULL, 0, D_82F13B74, 8));
+        func_8001EBE0(8, 0);
+        sprintf(sp94, "%d", sp11C->unk_26);
+        func_8001F1E8((arg0->unk_04 - func_8001F5B0(0, 0, sp94)) + 0x1D0, arg0->unk_06 + 0x44, sp94);
+        temp_s1_3 = 0x1D0 - func_8001F5B0(0, 0, "999");
+        sprintf(sp94, "/");
+        temp_v0_5 = func_8001F5B0(0, 0, sp94);
+        func_8001F1E8((arg0->unk_04 + temp_s1_3) - temp_v0_5, arg0->unk_06 + 0x44, sp94);
+        temp_s1_3 -= temp_v0_5;
+        sprintf(sp94, "%d", sp11C->unk_02);
+        func_8001F1E8((arg0->unk_04 + temp_s1_3) - func_8001F5B0(0, 0, sp94), arg0->unk_06 + 0x44, sp94);
+        func_8001EBE0(8, 0);
+        func_8001F1E8(arg0->unk_04 + 0x144, arg0->unk_06 + 0x6A, func_8002D7C0(NULL, 0, D_82F13B70, 0xD));
+        func_8001F1E8(arg0->unk_04 + 0x144, arg0->unk_06 + 0x80, func_8002D7C0(NULL, 0, D_82F13B70, 0xE));
+        func_8001F1E8(arg0->unk_04 + 0x144, arg0->unk_06 + 0x96, func_8002D7C0(NULL, 0, D_82F13B70, 0xF));
+        func_8001F1E8(arg0->unk_04 + 0x144, arg0->unk_06 + 0xAC, func_8002D7C0(NULL, 0, D_82F13B70, 0x10));
+        func_8001EBE0(8, 0);
+
+        sprintf(sp94, "%d", sp11C->unk_28);
+        func_8001F1E8((arg0->unk_04 - func_8001F5B0(0, 0, sp94)) + 0x1D0, arg0->unk_06 + 0x6A, sp94);
+        sprintf(sp94, "%d", sp11C->unk_2A);
+        func_8001F1E8((arg0->unk_04 - func_8001F5B0(0, 0, sp94)) + 0x1D0, arg0->unk_06 + 0x80, sp94);
+        sprintf(sp94, "%d", sp11C->unk_2C);
+        func_8001F1E8((arg0->unk_04 - func_8001F5B0(0, 0, sp94)) + 0x1D0, arg0->unk_06 + 0x96, sp94);
+        sprintf(sp94, "%d", sp11C->unk_2E);
+        func_8001F1E8((arg0->unk_04 - func_8001F5B0(0, 0, sp94)) + 0x1D0, arg0->unk_06 + 0xAC, sp94);
+        func_8001EBE0(8, 0);
+
+        {
+            char* sp74;
+            Color_RGB8* sp70;
+            Color_RGBA8 sp6C;
+            s32 j;
+
+            for (i = 0; i < 4; i++) {
+                sp6C = D_82F13C48;
+
+                if (sp11C->unk_09[i] == 0) {
+                    break;
+                }
+
+                if (func_82F05F20(sp11C->unk_09[i]) == 0) {
+                    sp70 = &D_80071D88[D_80072338[sp11C->unk_09[i] - 1].unk_01].color;
+                    sp74 = func_82F00058(sp11C->unk_09[i]);
+                } else {
+                    // "？？？？？？？"
+                    static const char D_29C080[] = { 0xA1, 0xA9, 0xA1, 0xA9, 0xA1, 0xA9, 0xA1,
+                                                     0xA9, 0xA1, 0xA9, 0xA1, 0xA9, 0xA1, 0xA9 };
+                    sp70 = &sp6C;
+                    sp74 = D_29C080;
+                }
+                func_8001F324(sp70->r, sp70->g, sp70->b, 0xFF);
+                func_8001F1E8(D_82F13C54[i] + arg0->unk_04 + 0x18, D_82F13C5C[i] + arg0->unk_06, sp74);
+            }
+
+            func_8001EBE0(0x10, 0);
+            func_8001F324(0xFF, 0xFF, 0xFF, 0xFF);
+            func_8001F1E8(arg0->unk_04 + 0x10, arg0->unk_06 + 0x12A, func_8002D7C0(NULL, 0, D_82F13B70, 0x11));
+
+            for (i = 0; i < 2; i++) {
+                func_8001F1E8(arg0->unk_04 + D_82F13C64[i], arg0->unk_06 + 0x12A, sp8C[i]);
+            }
+
+            func_8001F444();
+
+            gSPDisplayList(gDisplayListHead++, D_8006F518);
+
+            {
+                s16 sp60[2];
+
+                for (j = 0; j < 2; j++) {
+                    sp60[j] = func_8001F5B0(0, 0, sp8C[j]);
+                }
+
+                func_82F02CE8((D_82F13C64[D_82F20A38] + arg0->unk_04) - 8, arg0->unk_06 + 0x128,
+                              sp60[D_82F20A38] + 0x10, 0x1E);
+            }
+        }
+
+        gSPDisplayList(gDisplayListHead++, D_8006F630);
+
+        if (arg0->unk_02 > 0) {
+            arg0->unk_02--;
+        }
+    }
+}
+
+void func_82F06D50(void) {
+    D_82F20A10.unk_00 = 0;
+    D_82F20A10.unk_04 = 0;
+    D_82F20A10.unk_06 = 0;
+    D_82F20A10.unk_0C = 0;
+    D_82F20A10.unk_0E = 0;
+    D_82F20A10.unk_10 = 0;
+    D_82F20A10.unk_14 = NULL;
+    D_82F20A10.unk_18 = NULL;
+    D_82F20A10.unk_1C = 0;
+    D_82F20A10.unk_20 = NULL;
+    D_82F20A10.unk_24 = NULL;
+}
+
+void func_82F06D88(void) {
+    unk_D_82F20A10* ptr = &D_82F20A10;
+
+    if (ptr->unk_00) {
+        switch (ptr->unk_00) {
+            case 1:
+                func_82F053F8(&D_82F20A10);
+                break;
+
+            case 2:
+                func_82F05560(&D_82F20A10);
+                break;
+
+            case 3:
+                func_82F056D0(&D_82F20A10);
+                break;
+        }
+    }
+}
+
+void func_82F06E04(void) {
+    if (D_82F20A10.unk_00 != 0) {
+        func_82F05F40(&D_82F20A10);
+    }
+}
+
+s32 func_82F06E38(void) {
+    return D_82F20A10.unk_00;
+}
--- a/src/fragments/41/fragment41_28ED00.c
+++ b/src/fragments/41/fragment41_28ED00.c
--- a/src/fragments/41/fragment41_291D60.c
+++ b/src/fragments/41/fragment41_291D60.c
@@ -1,49 +1,813 @@
-#include "global.h"
+#include "fragment41.h"
+#include "src/1CF30.h"
+#include "src/20470.h"
+#include "src/232C0.h"
+#include "src/2E110.h"
+#include "src/49790.h"

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F09EB0.s")
+static unk_D_82F210E0 D_82F210E0;
+static unk_func_82F00838_sp30_00C* D_82F21120[2];
+static s16 D_82F21128;
+static s32 D_82F2112C;
+static s32 D_82F21130;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F09F44.s")
+s32 func_82F09EB0(unk_func_82F00838_sp30* arg0) {
+    unk_func_80022C28_ret* sp24;
+    s32 var_v1;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0A0A8.s")
+    if (arg0->unk_04 == 0) {
+        sp24 = func_80022C28(0x20, arg0->unk_02, 0, 1);
+    } else {
+        sp24 = func_80022C28(0x21, arg0->unk_02, arg0->unk_04 - 1, 1);
+    }

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0A23C.s")
+    func_80022F24(&arg0->unk_0C->unk_00, arg0->unk_08, sp24);
+    func_80022D8C(sp24);

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0A5F8.s")
+    var_v1 = func_80024270(arg0->unk_02);
+    if (var_v1 != 0) {
+        var_v1 = func_8002431C(arg0->unk_02);
+    }
+    return var_v1;
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0A804.s")
+s32 func_82F09F44(unk_D_82F210E0* arg0) {
+    s32 i;
+    unk_func_82F00838_sp30* ptr;
+    unk_func_82F00838_sp30 sp30[2];
+    s32 sp2C = 0;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0A850.s")
+    for (i = 0; i < 2; i++) {
+        func_82F0525C(i, &sp30[i]);
+    }

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0A950.s")
+    if (arg0->unk_06 < 0) {
+        arg0->unk_06 = 0;
+        for (i = 0, ptr = &sp30[0]; i < 2; i++, ptr++) {
+            func_8002447C(ptr->unk_02);
+        }
+    }

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0AA50.s")
+    if (arg0->unk_08 < 2) {
+        for (i = 0, ptr = &sp30[0]; i < 2; i++, ptr++) {
+            if (i < arg0->unk_08) {
+                continue;
+            }

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0AB68.s")
+            if (func_80023658(ptr->unk_02) != 0) {
+                arg0->unk_08++;
+            } else {
+                break;
+            }
+        }
+    }

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0ACC4.s")
+    if (arg0->unk_08 < 2) {
+        return 0;
+    }

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0B2A4.s")
+    for (i = 0, ptr = &sp30[0]; i < 2; i++, ptr++) {
+        if (i < arg0->unk_0A) {
+            continue;
+        }

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0B3E0.s")
+        if (func_82F09EB0(ptr) != 0) {
+            arg0->unk_0A += 1;
+            func_800244F4(ptr->unk_02);
+        } else {
+            break;
+        }
+    }

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0B7B4.s")
+    if (arg0->unk_0A == 2) {
+        sp2C = 1;
+    }
+    return sp2C;
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0BBE8.s")
+void func_82F0A0A8(s32 arg0) {
+    UNUSED s32 pad;
+    unk_D_82F210E0* ptr = &D_82F210E0;
+    s32 i;
+    unk_func_82F00838_sp30 sp2C;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0BD38.s")
+    ptr->unk_00 = 1;
+    ptr->unk_02 = 0xA;
+    ptr->unk_04 = 0;
+    ptr->unk_06 = -1;
+    ptr->unk_08 = 0;
+    ptr->unk_0A = 0;
+    ptr->unk_0C = 0;
+    ptr->unk_0E = 0;
+    ptr->unk_10 = -1;
+    ptr->unk_12 = -1;
+    if (arg0 != 0) {
+        ptr->unk_04 |= 1;
+    }

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0BE7C.s")
+    for (i = 0; i < 2; i++) {
+        func_82F0525C(i, &sp2C);
+        D_82F21120[i] = &sp2C.unk_0C[sp2C.unk_06];
+    }

+    D_82F21128 = 0;
+    D_82F2112C = 0;
+    D_82F21130 = 0;
+
+    for (i = 0; i < 2; i++) {
+        ptr->unk_14[i].unk_00 = ptr->unk_14[i].unk_02 = 0;
+        ptr->unk_14[i].unk_04 = 0xC8;
+        ptr->unk_14[i].unk_06 = 0;
+    }
+
+    ptr->unk_24.unk_00 = 0;
+    ptr->unk_24.unk_04 = 0xE8;
+    ptr->unk_24.unk_06 = 0;
+    ptr->unk_2C.unk_00 = 0;
+    ptr->unk_2C.unk_04 = 0x210;
+    ptr->unk_2C.unk_06 = 0;
+    ptr->unk_34.unk_00 = 0;
+    ptr->unk_34.unk_04 = 0xE8;
+    ptr->unk_34.unk_06 = 0;
+    ptr->unk_24.unk_02 = 0;
+    ptr->unk_2C.unk_02 = 0;
+    ptr->unk_34.unk_02 = 0;
+
+    if (arg0 != 0) {
+        func_80048B90(0x1E);
+    } else {
+        func_80048B90(4);
+    }
+}
+
+void func_82F0A23C(unk_D_82F210E0* arg0) {
+    s32 i;
+    unk_D_82F20A40_00E* ptr;
+
+    arg0->unk_02--;
+
+    for (i = 0; i < 2; i++) {
+        arg0->unk_14[i].unk_00 = ((i * 0x118) - ((arg0->unk_02 * 0) / 10)) + 0x50;
+        arg0->unk_14[i].unk_02 = 0x60 - ((arg0->unk_02 * -0x54) / 10);
+        arg0->unk_14[i].unk_04 = 0xC8 - ((arg0->unk_02 * 0) / 10);
+        arg0->unk_14[i].unk_06 = 0xA8 - ((arg0->unk_02 * 0xA8) / 10);
+    }
+
+    ptr = &arg0->unk_24;
+    if (!(arg0->unk_04 & 1)) {
+        ptr->unk_00 = 0xCC - ((arg0->unk_02 * 0) / 10);
+        ptr->unk_02 = 0x11C - ((arg0->unk_02 * -0x38) / 10);
+        ptr->unk_04 = 0xE8 - ((arg0->unk_02 * 0) / 10);
+        ptr->unk_06 = 0x70 - ((arg0->unk_02 * 0x70) / 10);
+    }
+
+    ptr = &arg0->unk_2C;
+    if (arg0->unk_04 & 1) {
+        ptr->unk_00 = 0x38 - ((arg0->unk_02 * 0) / 10);
+        ptr->unk_02 = 0x190 - ((arg0->unk_02 * -0x14) / 10);
+        ptr->unk_04 = 0x210 - ((arg0->unk_02 * 0) / 10);
+        ptr->unk_06 = 0x28 - ((arg0->unk_02 * 0x28) / 10);
+    }
+
+    if (arg0->unk_02 <= 0) {
+        if (arg0->unk_04 & 1) {
+            arg0->unk_00 = 3;
+            arg0->unk_02 = 0x14;
+            arg0->unk_04 |= 4;
+        } else {
+            arg0->unk_00 = 2;
+            arg0->unk_02 = 0;
+            arg0->unk_04 |= 6;
+        }
+    }
+}
+
+void func_82F0A5F8(unk_D_82F210E0* arg0) {
+    s32 var_t0 = 0;
+    s32 var_a2;
+    s16 tmp;
+
+    if (arg0->unk_04 & 1) {
+        var_a2 = 3;
+    } else {
+        var_a2 = 2;
+    }
+
+    tmp = D_82F21128;
+    if (BTN_IS_PRESSED(gPlayer1Controller, BTN_DUP) && (D_82F21128 > 0)) {
+        D_82F21128--;
+    }
+
+    if (BTN_IS_PRESSED(gPlayer1Controller, BTN_DDOWN) && (D_82F21128 < (var_a2 - 1))) {
+        D_82F21128++;
+    }
+
+    if (D_82F21128 != tmp) {
+        var_t0 = 0;
+        func_80048B90(1);
+    }
+
+    if (BTN_IS_PRESSED(gPlayer1Controller, BTN_A)) {
+        var_t0 = 1;
+    } else if (BTN_IS_PRESSED(gPlayer1Controller, BTN_B) && !(arg0->unk_04 & 1)) {
+        var_t0 = 1;
+        D_82F21128 = 1;
+    }
+
+    if (var_t0 != 0) {
+        if (arg0->unk_04 & 1) {
+            switch (D_82F21128) {
+                case 0:
+                    arg0->unk_00 = 5;
+                    arg0->unk_02 = 0xA;
+                    D_82F21130 = 0;
+                    func_80048B90(0x1D);
+                    break;
+
+                case 1:
+                    arg0->unk_00 = 5;
+                    arg0->unk_02 = 0xA;
+                    D_82F21130 = 1;
+                    func_80048B90(0x22);
+                    break;
+
+                default:
+                    arg0->unk_00 = 8;
+                    arg0->unk_02 = 0xA;
+                    arg0->unk_04 &= ~4;
+                    D_82F21130 = 0;
+                    func_80048B90(3);
+                    break;
+            }
+        } else {
+            arg0->unk_00 = 8;
+            arg0->unk_02 = 0xA;
+            arg0->unk_04 &= ~6;
+            if (D_82F21128 == 0) {
+                D_82F2112C = 1;
+                func_80048B90(2);
+            } else {
+                D_82F2112C = 0;
+                func_80048B90(3);
+            }
+        }
+        arg0->unk_12 = -1;
+    }
+}
+
+void func_82F0A804(unk_D_82F210E0* arg0) {
+    arg0->unk_02--;
+    if (BTN_IS_PRESSED(gPlayer1Controller, BTN_A)) {
+        arg0->unk_02 = 0;
+    }
+
+    if (arg0->unk_02 <= 0) {
+        arg0->unk_00 = 4;
+        arg0->unk_02 = 0xA;
+    }
+}
+
+void func_82F0A850(unk_D_82F210E0* arg0) {
+    arg0->unk_02--;
+    arg0->unk_24.unk_00 = 0xA2 - (arg0->unk_02 * 0) / 10;
+    arg0->unk_24.unk_02 = 0x116 - ((arg0->unk_02 * -0x2E) / 10);
+    arg0->unk_24.unk_04 = 0x13C - (arg0->unk_02 * 0) / 10;
+    arg0->unk_24.unk_06 = 0x70 - ((arg0->unk_02 * 0x70) / 10);
+    if (arg0->unk_02 <= 0) {
+        arg0->unk_00 = 2;
+        arg0->unk_02 = 0;
+    }
+}
+
+void func_82F0A950(unk_D_82F210E0* arg0) {
+    arg0->unk_02--;
+    arg0->unk_24.unk_00 = 0xA2 - (arg0->unk_02 * 0) / 10;
+    arg0->unk_24.unk_02 = 0x144 - ((arg0->unk_02 * 0x2E) / 10);
+    arg0->unk_24.unk_04 = 0x13C - (arg0->unk_02 * 0) / 10;
+    arg0->unk_24.unk_06 = -((arg0->unk_02 * -0x70) / 10);
+    if (arg0->unk_02 <= 0) {
+        arg0->unk_00 = 6;
+        arg0->unk_02 = 0xA;
+    }
+}
+
+void func_82F0AA50(unk_D_82F210E0* arg0) {
+    arg0->unk_02--;
+    arg0->unk_34.unk_00 = 0xCC - (arg0->unk_02 * 0) / 10;
+    arg0->unk_34.unk_02 = 0x134 - ((arg0->unk_02 * -0x1C) / 10);
+    arg0->unk_34.unk_04 = 0xE8 - (arg0->unk_02 * 0) / 10;
+    arg0->unk_34.unk_06 = 0x38 - ((arg0->unk_02 * 0x38) / 10);
+    if (arg0->unk_02 <= 0) {
+        arg0->unk_00 = 7;
+        arg0->unk_02 = 5;
+        arg0->unk_06 = -1;
+        arg0->unk_08 = 0;
+        arg0->unk_0A = 0;
+        arg0->unk_0C = 0;
+        arg0->unk_0E = 0;
+        arg0->unk_10 = -1;
+    }
+}
+
+void func_82F0AB68(unk_D_82F210E0* arg0) {
+    s32 temp_v0;
+    unk_func_82F00838_sp30 sp24;
+
+    arg0->unk_02--;
+    if (arg0->unk_02 <= 0) {
+        arg0->unk_02 = 0;
+        if (arg0->unk_0C == 1) {
+            func_82F0525C(arg0->unk_0A, &sp24);
+            temp_v0 = func_80023E34(sp24.unk_02);
+            if (temp_v0 == 1) {
+                arg0->unk_10 = 1;
+            }
+
+            if (temp_v0 == 3) {
+                arg0->unk_10 = 3;
+            }
+
+            if (temp_v0 == 2) {
+                arg0->unk_0C = 2;
+                arg0->unk_0E = 3;
+                arg0->unk_10 = 0;
+            }
+        }
+
+        if (arg0->unk_0C == 2) {
+            arg0->unk_0E -= 1;
+            if (arg0->unk_0E <= 0) {
+                arg0->unk_0C = 0;
+                arg0->unk_0E = 0;
+            }
+        }
+
+        if (arg0->unk_0C == 0) {
+            if (func_82F09F44(arg0) != 0) {
+                arg0->unk_00 = 8;
+                arg0->unk_02 = 0xA;
+                arg0->unk_04 &= ~4;
+                arg0->unk_10 = -1;
+                func_80048B90(9);
+            } else {
+                arg0->unk_06 += 1;
+                arg0->unk_0C = 1;
+                arg0->unk_10 = 2;
+                func_82F0525C(arg0->unk_0A, &sp24);
+                temp_v0 = func_80023E34(sp24.unk_02);
+                if (temp_v0 == 1) {
+                    arg0->unk_10 = 1;
+                }
+
+                if (temp_v0 == 3) {
+                    arg0->unk_10 = 3;
+                }
+            }
+        }
+    }
+}
+
+void func_82F0ACC4(unk_D_82F210E0* arg0) {
+    unk_D_82F20A40_00E* temp_v1;
+    s32 i;
+
+    arg0->unk_02--;
+
+    for (i = 0; i < 2; i++) {
+        arg0->unk_14[i].unk_00 = ((i * 0x118) - ((arg0->unk_02 * 0) / 10)) + 0x50;
+        arg0->unk_14[i].unk_02 = 0xB4 - ((arg0->unk_02 * 0x54) / 10);
+        arg0->unk_14[i].unk_04 = 0xC8 - ((arg0->unk_02 * 0) / 10);
+        arg0->unk_14[i].unk_06 = -((arg0->unk_02 * -0xA8) / 10);
+    }
+
+    temp_v1 = &arg0->unk_24;
+    if (arg0->unk_04 & 1) {
+        if ((temp_v1->unk_04 != 0x13C) || (temp_v1->unk_06 != 0)) {
+            temp_v1->unk_00 = 0xA2 - ((arg0->unk_02 * 0) / 10);
+            temp_v1->unk_02 = 0x144 - ((arg0->unk_02 * 0x2E) / 10);
+            temp_v1->unk_04 = 0x13C - ((arg0->unk_02 * 0) / 10);
+            temp_v1->unk_06 = -((arg0->unk_02 * -0x70) / 10);
+        }
+    } else if ((temp_v1->unk_04 != 0xE8) || (temp_v1->unk_06 != 0)) {
+        temp_v1->unk_00 = 0xCC - ((arg0->unk_02 * 0) / 10);
+        temp_v1->unk_02 = 0x154 - ((arg0->unk_02 * 0x38) / 10);
+        temp_v1->unk_04 = 0xE8 - ((arg0->unk_02 * 0) / 10);
+        temp_v1->unk_06 = -((arg0->unk_02 * -0x70) / 10);
+    }
+
+    temp_v1 = &arg0->unk_2C;
+    if ((arg0->unk_2C.unk_04 != 0x210) || (arg0->unk_2C.unk_06 != 0)) {
+        temp_v1->unk_00 = 0x38 - ((arg0->unk_02 * 0) / 10);
+        temp_v1->unk_02 = 0x1A4 - ((arg0->unk_02 * 0x14) / 10);
+        temp_v1->unk_04 = 0x210 - ((arg0->unk_02 * 0) / 10);
+        temp_v1->unk_06 = -((arg0->unk_02 * -0x28) / 10);
+    }
+
+    temp_v1 = &arg0->unk_34;
+    if ((arg0->unk_34.unk_04 != 0xE8) || (arg0->unk_34.unk_06 != 0)) {
+        temp_v1->unk_00 = 0xCC - ((arg0->unk_02 * 0) / 10);
+        temp_v1->unk_02 = 0x150 - ((arg0->unk_02 * 0x1C) / 10);
+        temp_v1->unk_04 = 0xE8 - ((arg0->unk_02 * 0) / 10);
+        temp_v1->unk_06 = -((arg0->unk_02 * -0x38) / 10);
+    }
+
+    if (arg0->unk_02 <= 0) {
+        arg0->unk_00 = 0;
+        arg0->unk_02 = 0;
+        arg0->unk_04 = 0;
+    }
+}
+
+void func_82F0B2A4(s16 arg0, s16 arg1, s16 arg2) {
+    UNUSED s32 pad;
+    u16* img = func_82F05198(arg0);
+
+    gDPLoadTextureBlock(gDisplayListHead++, img, G_IM_FMT_RGBA, G_IM_SIZ_16b, 40, 40, 0, G_TX_NOMIRROR | G_TX_CLAMP,
+                        G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
+
+    func_8001C330(arg1, arg2, 0x3C, 0x3C, 0, 0, 0x2AB, 0x2AB, 0);
+}
+
+void func_82F0B3E0(unk_D_82F210E0* arg0) {
+    unk_D_82F20A40_00E* var_s0;
+    s32 sp74[2];
+    unk_func_82F00838_sp30_00C* temp_s3;
+    s32 i;
+
+    if (arg0->unk_12 > 0) {
+        arg0->unk_12--;
+    }
+
+    for (i = 0; i < 2; i++) {
+        var_s0 = &arg0->unk_14[i];
+        if ((var_s0->unk_04 != 0xC8) || (var_s0->unk_06 != 0)) {
+            func_82F022DC(var_s0->unk_00, var_s0->unk_02, var_s0->unk_04, var_s0->unk_06);
+        }
+    }
+
+    for (i = 0; i < 2; i++) {
+        if ((arg0->unk_14[i].unk_04 == 0xC8) && (arg0->unk_14[i].unk_06 == 0xA8)) {
+            sp74[i] = 1;
+        } else {
+            sp74[i] = 0;
+        }
+    }
+
+    gSPDisplayList(gDisplayListHead++, D_8006F498);
+
+    for (i = 0; i < 2; i++) {
+        var_s0 = &arg0->unk_14[i];
+        if (sp74[i] != 0) {
+            func_8001C604(var_s0->unk_00, var_s0->unk_02, var_s0->unk_04, var_s0->unk_06, 0x32, 0x32, 0x96, 0xFF);
+        }
+    }
+
+    gSPDisplayList(gDisplayListHead++, D_8006F630);
+    gSPDisplayList(gDisplayListHead++, D_8006F518);
+
+    for (i = 0; i < 2; i++) {
+        if (sp74[i] != 0) {
+            func_82F0B2A4(i, arg0->unk_14[i].unk_00 + 0x46, arg0->unk_14[i].unk_02 + 0xA);
+        }
+    }
+
+    gSPDisplayList(gDisplayListHead++, D_8006F630);
+
+    func_8001F3F4();
+    func_8001F324(0xFF, 0xFF, 0xFF, 0xFF);
+
+    for (i = 0; i < 2; i++) {
+        if (sp74[i] != 0) {
+            temp_s3 = D_82F21120[i];
+            var_s0 = &arg0->unk_14[i];
+            func_8001EBE0(4, 0);
+            func_8001F1E8(var_s0->unk_00 + 0xA, var_s0->unk_02 + 0x4A, "No.");
+            func_8001EBE0(4, 0);
+            func_8001F1E8(var_s0->unk_00 + 0x26, var_s0->unk_02 + 0x4A, "%03d", temp_s3->unk_00);
+            func_8001EBE0(8, 0);
+            func_8001F1E8(var_s0->unk_00 + 0x62, var_s0->unk_02 + 0x46, func_82F00020(temp_s3->unk_00));
+            func_8001EBE0(8, 0);
+            func_8001F1E8(var_s0->unk_00 + 0x10, var_s0->unk_02 + 0x5E, func_8002D7C0(NULL, 0, D_82F13B70, 0x14));
+            func_8001F1E8(var_s0->unk_00 + 0x46, var_s0->unk_02 + 0x5E, "/%s", temp_s3->unk_30);
+            func_8001F1E8(var_s0->unk_00 + 0x10, var_s0->unk_02 + 0x74, func_8002D7C0(NULL, 0, D_82F13B70, 0x15));
+            func_8001F1E8(var_s0->unk_00 + 0x46, var_s0->unk_02 + 0x74, "/%s", temp_s3->unk_3B);
+            func_8001F1E8(var_s0->unk_00 + 0x10, var_s0->unk_02 + 0x8A, "ID%05d", temp_s3->unk_0E);
+        }
+    }
+
+    func_8001F444();
+}
+
+void func_82F0B7B4(unk_D_82F210E0* arg0) {
+    s32 i;
+    unk_D_82F20A40_00E* var_s4 = &arg0->unk_24;
+    Color_RGB8* var_v0;
+    s16 temp_ft3;
+    s16 arg2;
+    Color_RGB8 sp64 = { 0x1E, 0x1E, 0x82 };
+    Color_RGB8 sp60 = { 0x64, 0x1E, 0x1E };
+
+    if (arg0->unk_04 & 1) {
+        if ((var_s4->unk_04 == 0x13C) && (var_s4->unk_06 == 0)) {
+            return;
+        }
+    } else if ((var_s4->unk_04 == 0xE8) && (var_s4->unk_06 == 0)) {
+        return;
+    }
+
+    if (arg0->unk_04 & 1) {
+        var_v0 = &sp60;
+    } else {
+        var_v0 = &sp64;
+    }
+
+    if ((var_s4->unk_04 >= 0xE) && (var_s4->unk_06 >= 0xE)) {
+        func_8002053C(var_s4->unk_00, var_s4->unk_02, var_s4->unk_04, var_s4->unk_06, var_v0, var_v0);
+    }
+
+    if (arg0->unk_04 & 1) {
+        if ((var_s4->unk_04 != 0x13C) || (var_s4->unk_06 != 0x70)) {
+            return;
+        }
+    } else if ((var_s4->unk_04 != 0xE8) || (var_s4->unk_06 != 0x70)) {
+        return;
+    }
+
+    {
+        static s16 D_82F13F78 = 0;
+
+        temp_ft3 = SINS(D_82F13F78) * 3.0f;
+
+        if (arg0->unk_04 & 1) {
+            func_800207FC(var_s4->unk_00 + temp_ft3 + 0x10, var_s4->unk_02 + (D_82F21128 * 0x1C) + 0x14);
+        } else {
+            func_800207FC(var_s4->unk_00 + temp_ft3 + 0x18, var_s4->unk_02 + (D_82F21128 * 0x1C) + 0x32);
+        }
+
+        func_8001F3F4();
+        func_8001EBE0(0x10, 0);
+        func_8001F324(0xFF, 0xFF, 0xFF, 0xFF);
+
+        if (arg0->unk_04 & 1) {
+            char* sp54[3];
+            for (i = 0; i < 3; i++) {
+                sp54[0] = func_8002D7C0(NULL, 0, D_82F13B70, 0x1A);
+                sp54[1] = func_8002D7C0(NULL, 0, D_82F13B70, 0x1B);
+                sp54[2] = func_8002D7C0(NULL, 0, D_82F13B70, 0x1C);
+                func_8001F1E8(var_s4->unk_00 + 0x38, var_s4->unk_02 + i * 0x1C + 0x10, sp54[i]);
+            }
+        } else {
+            char* temp_v0 = func_8002D7C0(NULL, 0, D_82F13B70, 0x16);
+            char* sp48[2];
+
+            arg2 = func_8001F5B0(0, 0, temp_v0);
+            func_8001F1E8((var_s4->unk_00 + (var_s4->unk_04 / 2)) - (arg2 / 2), var_s4->unk_02 + 0x10, temp_v0);
+
+            for (i = 0; i < 2; i++) {
+                sp48[0] = func_8002D7C0(NULL, 0, D_82F13B70, 0x17);
+                sp48[1] = func_8002D7C0(NULL, 0, D_82F13B70, 0x18);
+                if (i != D_82F21128) {
+                    func_8001F324(0xFF, 0xFF, 0xFF, 0xFF);
+                } else {
+                    func_8001F324(0xFF, 0xFF, 0, 0xFF);
+                }
+                arg2 = func_8001F5B0(0, 0, sp48[i]);
+                func_8001F1E8((var_s4->unk_00 + (var_s4->unk_04 / 2)) - (arg2 / 2), var_s4->unk_02 + i * 0x1C + 0x2C,
+                              sp48[i]);
+            }
+        }
+
+        func_8001F444();
+        D_82F13F78 += 0x1000;
+    }
+}
+
+void func_82F0BBE8(unk_D_82F210E0* arg0) {
+    s32 sp34;
+    unk_D_82F20A40_00E* temp_s0 = &arg0->unk_2C;
+
+    if ((arg0->unk_2C.unk_04 != 0x210) || (arg0->unk_2C.unk_06 != 0)) {
+        func_82F037EC(temp_s0->unk_00, temp_s0->unk_02, temp_s0->unk_04, temp_s0->unk_06, 0x1E, 0x1E, 0x82, 0xFF);
+        if ((temp_s0->unk_04 == 0x210) && (temp_s0->unk_06 == 0x28)) {
+            func_8001F3F4();
+            func_8001EBE0(0x10, 0);
+            func_8001F324(0xFF, 0xFF, 0xFF, 0xFF);
+            sp34 = func_8001F5B0(0, 0, func_8002D7C0(NULL, 0, D_82F13B70, 0x1D)) / 2;
+            func_8001F1E8((temp_s0->unk_00 + (temp_s0->unk_04 / 2)) - sp34, temp_s0->unk_02 + 8,
+                          func_8002D7C0(NULL, 0, D_82F13B70, 0x1D));
+            func_8001F444();
+        }
+    }
+}
+
+void func_82F0BD38(unk_D_82F210E0* arg0) {
+    unk_D_82F20A40_00E* temp_s0 = &arg0->unk_34;
+    char* sp40;
+    UNUSED s32 pad;
+    Color_RGB8 sp38 = { 0x64, 0x1E, 0x1E };
+
+    if ((arg0->unk_34.unk_04 != 0xE8) || (arg0->unk_34.unk_06 != 0)) {
+        if ((temp_s0->unk_04 >= 0xE) && (temp_s0->unk_06 >= 0xE)) {
+            func_8002053C(temp_s0->unk_00, temp_s0->unk_02, temp_s0->unk_04, temp_s0->unk_06, &sp38, &sp38);
+        }
+
+        if ((temp_s0->unk_04 == 0xE8) && (temp_s0->unk_06 == 0x38)) {
+            func_8001F3F4();
+            func_8001EBE0(0x10, 0);
+            func_8001F324(0xFF, 0xFF, 0xFF, 0xFF);
+            sp40 = func_8002D7C0(NULL, 0, D_82F13B70, 0x1E);
+            func_8001F1E8((temp_s0->unk_00 + (temp_s0->unk_04 / 2)) - (func_8001F5B0(0, 0, sp40) / 2),
+                          temp_s0->unk_02 + 0x10, sp40);
+            func_8001F444();
+        }
+    }
+}
+
+void func_82F0BE7C(s16 arg0, s16 arg1, s16 arg2, s16 arg3) {
+    Color_RGB8 sp24 = { 0x58, 0x08, 0x00 };
+    Color_RGB8 sp20 = { 0x58, 0x08, 0x00 };
+
+    func_8002053C(arg0, arg1, arg2, arg3, &sp24, &sp20);
+}
+
+#ifdef NON_MATCHING
+void func_82F0BEF8(unk_D_82F210E0* arg0) {
+    static s16 D_82F13F88 = 0;
+
+    s32 pad[2];
+    char sp38[64];
+    s32 pad2[2];
+    unk_func_82F00838_sp30 sp20;
+
+    if (arg0->unk_08 < 2) {
+        func_82F0525C(arg0->unk_08, &sp20);
+    } else {
+        func_82F0525C(arg0->unk_0A, &sp20);
+    }
+
+    if (arg0->unk_10 == -1) {
+        return;
+    }
+
+    func_82F0BE7C(0x6E, 0x72, 0x1A4, 0x114);
+    func_8001F3F4();
+    func_8001EBE0(0x10, 0);
+    func_8001F324(0xFF, 0xFF, 0xFF, 0xFF);
+
+    switch (arg0->unk_10) {
+        case 0:
+            func_8001F470();
+            func_8001F36C(0xFF, 0xF1, 0x78, 0xFF);
+            func_8001F1E8(0xEC, 0xA8, func_8002D7C0(NULL, 0, D_82F13B70, 0x1F));
+            func_8001F4C4();
+            break;
+
+        case 2:
+            func_8001F470();
+            func_8001F324(0xFF, 0xFF, 0xFF, 0xFF);
+            func_8001F36C(0xFF, 0xF1, 0x78, 0xFF);
+            // func_8002D600(1, (((((((((tmp) & 0xFFFFFFFFFFFFFFFF) & 0xFFFFFFFFFFFFFFFF) & 0xFFFFFFFFFFFFFFFF) &
+            // 0xFFFFFFFFFFFFFFFF) & 0xFFFFFFFFFFFFFFFF) & 0xFFFFFFFFFFFFFFFF) & 0xFFFFFFFFFFFFFFFF) &
+            // 0xFFFFFFFFFFFFFFFF) & 0xFFFFFFFFFFFFFFFF);
+            func_8002D600(1, sp20.unk_02 + 1);
+            func_8001F1E8(0xB0, 0x90, func_8002D7C0(sp38, sizeof(sp38), D_82F13B70, 0x20));
+            func_8001F4C4();
+            break;
+
+        case 3:
+            func_8001F470();
+            func_8001F36C(0xFF, 0xF1, 0x78, 0xFF);
+            func_8001F1E8(0x80, 0x90, func_8002D7C0(NULL, 0, D_82F13B70, 0x21));
+            func_8001F4C4();
+            break;
+    }
+
+    if (arg0->unk_10 != 0) {
+        func_8001F470();
+        func_8001F36C(0xFF, 0xF1, 0x78, 0xFF);
+        func_8001F324(0xFF, 0xFF, 0xFF, 0xFF);
+        func_8001F3B4(0x24);
+        func_8001F1E8(0x80, 0xF0, func_8002D7C0(NULL, 0, D_82F13B70, 0x22));
+    }
+
+    func_8001F444();
+    D_82F13F88 += 0x800;
+}
+#else
+static s16 D_82F13F88 = 0;
 #pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0BEF8.s")
+#endif

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0C16C.s")
+s32 func_82F0C16C(void) {
+    return D_82F210E0.unk_00;
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0C178.s")
+s32 func_82F0C178(void) {
+    return D_82F2112C;
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0C184.s")
+s32 func_82F0C184(void) {
+    return D_82F21130;
+}

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0C190.s")
+void func_82F0C190(void) {
+    unk_D_82F210E0* ptr = &D_82F210E0;
+    s32 i;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0C254.s")
+    ptr->unk_00 = 0;
+    ptr->unk_02 = 0;
+    ptr->unk_04 = 0;

-#pragma GLOBAL_ASM("asm/us/nonmatchings/fragments/41/fragment41_291D60/func_82F0C320.s")
+    for (i = 0; i < 2; i++) {
+        D_82F210E0.unk_14[i].unk_00 = D_82F210E0.unk_14[i].unk_02 = 0;
+        D_82F210E0.unk_14[i].unk_04 = 0xC8;
+        D_82F210E0.unk_14[i].unk_06 = 0;
+    }
+
+    ptr->unk_24.unk_00 = 0;
+    ptr->unk_24.unk_04 = 0xE8;
+    ptr->unk_24.unk_06 = 0;
+    ptr->unk_2C.unk_00 = 0;
+    ptr->unk_2C.unk_04 = 0x210;
+    ptr->unk_2C.unk_06 = 0;
+    ptr->unk_34.unk_00 = 0;
+    ptr->unk_34.unk_04 = 0xE8;
+    ptr->unk_34.unk_06 = 0;
+
+    ptr->unk_24.unk_02 = 0;
+    ptr->unk_2C.unk_02 = ptr->unk_34.unk_02 = 0;
+
+    for (i = 0; i < 2; i++) {
+        D_82F21120[i] = NULL;
+    }
+}
+
+void func_82F0C254(void) {
+    unk_D_82F210E0* ptr = &D_82F210E0;
+
+    if (ptr->unk_00 == 0) {
+        return;
+    }
+
+    switch (ptr->unk_00) {
+        case 1:
+            func_82F0A23C(&D_82F210E0);
+            break;
+
+        case 2:
+            func_82F0A5F8(&D_82F210E0);
+            break;
+
+        case 3:
+            func_82F0A804(&D_82F210E0);
+            break;
+
+        case 4:
+            func_82F0A850(&D_82F210E0);
+            break;
+
+        case 5:
+            func_82F0A950(&D_82F210E0);
+            break;
+
+        case 6:
+            func_82F0AA50(&D_82F210E0);
+            break;
+
+        case 7:
+            func_82F0AB68(&D_82F210E0);
+            break;
+
+        case 8:
+            func_82F0ACC4(&D_82F210E0);
+            break;
+    }
+}
+
+void func_82F0C320(void) {
+    static s16 D_82F13F8C[] = { 0x32, 0x14A };
+
+    unk_D_82F210E0* ptr = &D_82F210E0;
+    s32 i;
+
+    if (ptr->unk_00 != 0) {
+        if (ptr->unk_12 != 0) {
+            func_82F0B3E0(&D_82F210E0);
+        }
+
+        func_82F0B7B4(&D_82F210E0);
+        func_82F0BBE8(&D_82F210E0);
+        func_82F0BD38(&D_82F210E0);
+
+        if (ptr->unk_04 & 2) {
+            func_82F097D8(0x120, 0x8C);
+        }
+
+        if (ptr->unk_04 & 4) {
+            for (i = 0; i < 2; i++) {
+                func_82F043A4(i, D_82F13F8C[i], 0x2A);
+            }
+        }
+        func_82F0BEF8(&D_82F210E0);
+    }
+}
--- a/src/fragments/41/fragment41_2942C0.c
+++ b/src/fragments/41/fragment41_2942C0.c
--- a/src/fragments/43/fragment43_2A1B50.c
+++ b/src/fragments/43/fragment43_2A1B50.c
@@ -389,7 +389,7 @@ void func_8340144C(u16* arg0, s32 arg1, s32 arg2, s32 arg3, s32 arg4, s32 arg5)
    s32 i;

    for (i = 0; i < arg4; i += tmp) {
-        temp_v0 = CLAMP_MAX(tmp, arg4 - i);
+        temp_v0 = CLAMP_MIN(arg4 - i, tmp);

        gDPLoadTextureTile(gDisplayListHead++, &arg0[i * arg3], G_IM_FMT_RGBA, G_IM_SIZ_16b, arg3, 0, 0, 0, arg3,
                           temp_v0 - 1, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK,
@@ -438,7 +438,7 @@ void func_834018C0(u16* arg0, s32 arg1, s32 arg2, s32 arg3, s32 arg4, s32 arg5,
    gDPSetRenderMode(gDisplayListHead++, G_RM_OPA_SURF, G_RM_OPA_SURF2);

    for (i = 0; i < arg4; i += arg5) {
-        temp_v0 = CLAMP_MAX(arg5, arg4 - i);
+        temp_v0 = CLAMP_MIN(arg4 - i, arg5);

        gDPLoadTextureTile(gDisplayListHead++, &arg0[i * arg3], G_IM_FMT_RGBA, G_IM_SIZ_16b, arg3, 0, 0, 0, arg3 - 1,
                           temp_v0 - 1, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK,
--- a/src/fragments/44/fragment44.c
+++ b/src/fragments/44/fragment44.c
@@ -255,7 +255,7 @@ void func_83500758(s32 arg0, s32 arg1) {
    s32 tmp3 = 64;

    for (i = 0; i < new_var; i += tmp) {
-        temp_v0 = CLAMP_MAX(tmp, new_var - i);
+        temp_v0 = CLAMP_MIN(new_var - i, tmp);

        gDPLoadTextureTile(gDisplayListHead++, D_04001000 + ((i << 6) << 1), G_IM_FMT_RGBA, G_IM_SIZ_16b, 64, 64, tmp2,
                           tmp2, 64, temp_v0 - 1, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP,
@@ -687,7 +687,7 @@ void func_835024FC(void) {

    idx = 0;
    for (i = 0; i < end; i += 0x40, idx++) {
-        temp_v0_11 = CLAMP_MAX(0x40, end - i);
+        temp_v0_11 = CLAMP_MIN(end - i, 0x40);

        if (D_83504088 & (1 << idx)) {
            r = (((D_83503EA0.r - D_83503E98.r) * idx) / 8) + D_83503E98.r;
@@ -839,7 +839,7 @@ void func_835028D0(s32 arg0, s32 arg1, s32 arg2) {
    gSPDisplayList(gDisplayListHead++, D_8006F518);

    for (i = 0; i < end; i += var_s2) {
-        s32 temp_v0_11 = CLAMP_MAX(var_s2, end - i);
+        s32 temp_v0_11 = CLAMP_MIN(end - i, var_s2);

        gDPLoadTextureTile(gDisplayListHead++, &spF0[i * var_ra], G_IM_FMT_IA, G_IM_SIZ_8b, var_ra, 0, 0, 0, var_ra,
                           temp_v0_11 - 1, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK,
@@ -856,7 +856,7 @@ void func_835028D0(s32 arg0, s32 arg1, s32 arg2) {
        var_ra = 0x64;
        end = 0x37;
        for (i = 0; i < end; i += var_s2) {
-            s32 temp_v0_11 = CLAMP_MAX(var_s2, end - i);
+            s32 temp_v0_11 = CLAMP_MIN(end - i, var_s2);

            gDPLoadTextureTile(gDisplayListHead++, &spEC[i * var_ra], G_IM_FMT_IA, G_IM_SIZ_8b, var_ra, 0, 0, 0, var_ra,
                               temp_v0_11 - 1, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK,
@@ -875,7 +875,7 @@ void func_835028D0(s32 arg0, s32 arg1, s32 arg2) {
        var_s2 = 0x14;
        end = 0x3C;
        for (i = 0; i < end; i += var_s2) {
-            s32 temp_v0_11 = CLAMP_MAX(var_s2, end - i);
+            s32 temp_v0_11 = CLAMP_MIN(end - i, var_s2);

            gDPLoadTextureTile(gDisplayListHead++, &spE8[i * var_ra], G_IM_FMT_RGBA, G_IM_SIZ_16b, var_ra, 0, 0, 0,
                               var_ra, temp_v0_11 - 1, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP,
@@ -912,7 +912,7 @@ void func_83502F78(int arg0, int arg1, s32 arg2, f32 arg3) {
    gSPDisplayList(gDisplayListHead++, D_8006F518);

    for (i = 0; i < spF8; i += iter) {
-        s32 temp_v0_2 = CLAMP_MAX(iter, spF8 - i);
+        s32 temp_v0_2 = CLAMP_MIN(spF8 - i, iter);
        s32 temp_fv1_2 = ROUND_MAX((temp_v0_2 * arg3) + 0.4f);
        s32 temp_fa0 = ROUND_MAX((i * arg3) + 0.4f);

--- a/src/fragments/45/fragment45.c
+++ b/src/fragments/45/fragment45.c
@@ -350,7 +350,7 @@ void func_83600E20(s32 arg0, s32 arg1, s16 arg2) {
    gSPDisplayList(gDisplayListHead++, D_8006F518);

    for (i = 0; i < spC0; i += end) {
-        temp_v0_2 = CLAMP_MAX(end, spC0 - i);
+        temp_v0_2 = CLAMP_MIN(spC0 - i, end);

        gDPLoadTextureBlock(gDisplayListHead++, &D_4004D48[i * spC0], G_IM_FMT_RGBA, G_IM_SIZ_16b, spC0, temp_v0_2, 0,
                            G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK,
@@ -388,7 +388,7 @@ void func_83601314(s32 arg0, s32 arg1, s16 arg2) {
    gSPDisplayList(gDisplayListHead++, D_8006F518);

    for (i = 0; i < spC0; i += end) {
-        temp_v0_2 = CLAMP_MAX(end, spC0 - i);
+        temp_v0_2 = CLAMP_MIN(spC0 - i, end);

        gDPLoadTextureBlock(gDisplayListHead++, &D_4005F48[i * spC0], G_IM_FMT_RGBA, G_IM_SIZ_16b, spC0, temp_v0_2, 0,
                            G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK,
@@ -566,7 +566,7 @@ void func_83601F28(int arg0, int arg1, s32 arg2, f32 arg3) {
    gSPDisplayList(gDisplayListHead++, D_8006F518);

    for (i = 0; i < spF8; i += iter) {
-        s32 temp_v0_2 = CLAMP_MAX(iter, spF8 - i);
+        s32 temp_v0_2 = CLAMP_MIN(spF8 - i, iter);
        s32 temp_fv1_2 = ROUND_MAX((temp_v0_2 * arg3) + 0.4f);
        s32 temp_fa0 = ROUND_MAX((i * arg3) + 0.4f);

@@ -615,7 +615,7 @@ void func_83602458(void) {

    idx = 0;
    for (i = 0; i < end; i += 0x40, idx++) {
-        s32 temp_v0_2 = CLAMP_MAX(0x40, end - i);
+        s32 temp_v0_2 = CLAMP_MIN(end - i, 0x40);

        if (D_836033C0 & (1 << idx)) {
            r = (((D_836032AC.r - D_836032A4.r) * idx) / 8) + D_836032A4.r;
--- a/yamls/us/rom.yaml
+++ b/yamls/us/rom.yaml
@@ -1634,14 +1634,26 @@
    - [0x28ED00, c,      fragments/41/fragment41_28ED00]
    - [0x291D60, c,      fragments/41/fragment41_291D60]
    - [0x2942C0, c,      fragments/41/fragment41_2942C0]
-    - [0x29BA20, data,   fragments/41/fragment41_data]
-    - [0x29BF80, rodata, fragments/41/fragment41_rodata_29BF80]
-    - [0x29C010, rodata, fragments/41/fragment41_rodata_29C010]
-    - [0x29C040, rodata, fragments/41/fragment41_rodata_29C040]
-    - [0x29C140, rodata, fragments/41/fragment41_rodata_29C140]
-    - [0x29C180, rodata, fragments/41/fragment41_rodata_29C180]
+    - [0x29BA20, .data,   fragments/41/fragment41_287ED0]
+    - [0x29BA40, .data,   fragments/41/fragment41_289240]
+    - [0x29BAC0, .data,   fragments/41/fragment41_28D1A0]
+    - [0x29BB60, .data,   fragments/41/fragment41_28ED00]
+    - [0x29BE20, .data,   fragments/41/fragment41_291D60]
+    - [0x29BE40, .data,   fragments/41/fragment41_2942C0]
+    
+    - [0x29BF80, .rodata, fragments/41/fragment41_287ED0]
+    - [0x29C010, .rodata, fragments/41/fragment41_289240]
+    - [0x29C040, .rodata, fragments/41/fragment41_28D1A0]
+    - [0x29C090, .rodata, fragments/41/fragment41_28ED00]
+    - [0x29C140, .rodata, fragments/41/fragment41_291D60]
+    - [0x29C180, .rodata, fragments/41/fragment41_2942C0]

-    - {vram: 0x82F14420, type:  bss, name: fragments/41/fragment41_bss}
+    - {vram: 0x82F14420, type:  .bss, name: fragments/41/fragment41_287ED0}
+    - {vram: 0x82F144D0, type:  .bss, name: fragments/41/fragment41_289240}
+    - {vram: 0x82F20A10, type:  .bss, name: fragments/41/fragment41_28D1A0}
+    - {vram: 0x82F20A40, type:  .bss, name: fragments/41/fragment41_28ED00}
+    - {vram: 0x82F210E0, type:  .bss, name: fragments/41/fragment41_291D60}
+    - {vram: 0x82F21140, type:  .bss, name: fragments/41/fragment41_2942C0}

  - name: fragment41_relocs
    type: code