From 7f575b6416d5d2170e273bd24a4e94f802aa90f5 Mon Sep 17 00:00:00 2001
From: darxoon <darxoon@outlook.com>
Date: Sat, 27 Jan 2024 18:01:37 +0100
Subject: [PATCH 01/15] Add fault.h and document fault.c

---
 config/GMPE01_00/symbols.txt |  14 +-
 include/game/fault.h         |   9 ++
 src/game/fault.c             | 277 ++++++++++++++++-------------------
 src/game/init.c              |   3 +-
 4 files changed, 147 insertions(+), 156 deletions(-)
 create mode 100644 include/game/fault.h

diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt
index e75a822c..922ccfa3 100644
--- a/config/GMPE01_00/symbols.txt
+++ b/config/GMPE01_00/symbols.txt
@@ -537,12 +537,12 @@ omCurrentOvlGet = .text:0x8002FF44; // type:function size:0x8
 OSPanic = .text:0x8002FF4C; // type:function size:0x150
 HuFaultInitXfbDirectDraw = .text:0x8003009C; // type:function size:0x118
 HuFaultSetXfbAddress = .text:0x800301B4; // type:function size:0x34
-XFB_WriteBackCache = .text:0x800301E8; // type:function size:0x98
-XFB_CR = .text:0x80030280; // type:function size:0x50
-XFB_puts = .text:0x800302D0; // type:function size:0xF4
-XFB_putcS = .text:0x800303C4; // type:function size:0x150
-XFB_putcProgressive = .text:0x80030514; // type:function size:0x1F0
-XFB_putcInterlace = .text:0x80030704; // type:function size:0x1B4
+XFB_WriteBackCache = .text:0x800301E8; // type:function size:0x98 scope:local
+XFB_CR = .text:0x80030280; // type:function size:0x50 scope:local
+XFB_puts = .text:0x800302D0; // type:function size:0xF4 scope:local
+XFB_putcS = .text:0x800303C4; // type:function size:0x150 scope:local
+XFB_putcProgressive = .text:0x80030514; // type:function size:0x1F0 scope:local
+XFB_putcInterlace = .text:0x80030704; // type:function size:0x1B4 scope:local
 GWInit = .text:0x800308B8; // type:function size:0x14C
 GWGameStatReset = .text:0x80030A04; // type:function size:0x318
 GWMessDelayGet = .text:0x80030D1C; // type:function size:0x4C
@@ -5778,7 +5778,7 @@ lbl_801D3488 = .sdata:0x801D3488; // type:object size:0x4 data:string
 lbl_801D348C = .sdata:0x801D348C; // type:object size:0xC
 omSysPauseEnableFlag = .sdata:0x801D3498; // type:object size:0x1 data:byte
 omprevovl = .sdata:0x801D349C; // type:object size:0x4 data:4byte
-lbl_801D34A0 = .sdata:0x801D34A0; // type:object size:0x4 data:4byte
+titleMes$442 = .sdata:0x801D34A0; // type:object size:0x4 scope:local data:4byte
 lbl_801D34A4 = .sdata:0x801D34A4; // type:object size:0xC
 lbl_801D34B0 = .sdata:0x801D34B0; // type:object size:0x1
 lbl_801D34B1 = .sdata:0x801D34B1; // type:object size:0x7
diff --git a/include/game/fault.h b/include/game/fault.h
new file mode 100644
index 00000000..bd2777ac
--- /dev/null
+++ b/include/game/fault.h
@@ -0,0 +1,9 @@
+#ifndef _GAME_FAULT_H
+#define _GAME_FAULT_H
+
+#include "game/gamework_data.h"
+
+void HuFaultInitXfbDirectDraw(GXRenderModeObj *mode);
+void HuFaultSetXfbAddress(s16 index, void* value);
+
+#endif
diff --git a/src/game/fault.c b/src/game/fault.c
index 384cc45a..4f8a8b6c 100644
--- a/src/game/fault.c
+++ b/src/game/fault.c
@@ -1,4 +1,4 @@
-#include "game/gamework_data.h"
+#include "game/fault.h"
 #include "stdarg.h"
 #include "stdio.h"
 
@@ -9,11 +9,10 @@ typedef struct rgb_color {
 } RGBColor;
 
 typedef struct xfb_geometry {
-    void* unk0[4];
-    u16 unk4;
-    u16 unk5;
-    u16 unk6;
-    u16 unk7;
+    void* frame_buffers[4];
+    u16 width;
+    u16 height;
+    u16 mode;
 } XFBGeometry;
 
 static RGBColor XFB_Colors[5] = {
@@ -28,23 +27,23 @@ static RGBColor XFB_Colors[5] = {
 
 XFBGeometry XFB_Geometry;
 
-static s32 (*XFB_putc)(u8 arg0, s32 arg1, s32 arg2);
+static s32 (*XFB_putc)(u8 c, s32 x, s32 y);
 
 static RGBColor Draw_Color;
 
 static s32 x_start;
 static s32 y_start;
 
-const char* lbl_801D34A0 = "OSPanic encounterd:";
-
-s32 XFB_putcProgressive(u8 arg0, s32 arg1, s32 arg2);
-s32 XFB_putcInterlace(u8 arg0, s32 arg1, s32 arg2);
-s32 XFB_puts(s8* arg0, s32 arg1, s32 arg2);
-s32 XFB_putcS(u8 arg0, s32 arg1, s32 arg2);
-void XFB_WriteBackCache(void);
-void XFB_CR(s32 arg0, s32* arg1, s32* arg2);
+static s32 XFB_putcProgressive(u8 arg0, s32 arg1, s32 arg2);
+static s32 XFB_putcInterlace(u8 arg0, s32 arg1, s32 arg2);
+static s32 XFB_puts(s8* arg0, s32 arg1, s32 arg2);
+static s32 XFB_putcS(u8 arg0, s32 arg1, s32 arg2);
+static void XFB_WriteBackCache(void);
+static void XFB_CR(s32 arg0, s32* arg1, s32* arg2);
 
 void OSPanic(const char* file, int line, const char* msg, ...) {
+    static char* titleMes = "OSPanic encounterd:";
+    
     va_list sp78;
     s32 sp74;
     s32 sp70;
@@ -53,7 +52,7 @@ void OSPanic(const char* file, int line, const char* msg, ...) {
 
     sp74 = x_start = 0x10;
     sp70 = y_start = 0x20;
-    puts = XFB_puts((s8*)lbl_801D34A0, sp74, sp70);
+    puts = XFB_puts((s8*)titleMes, sp74, sp70);
     XFB_CR(puts + 1, &sp74, &sp70);
     sprintf(sp84, "%s:%d", file, line);
     puts = XFB_puts((s8*)sp84, sp74, sp70);
@@ -71,77 +70,74 @@ void HuFaultInitXfbDirectDraw(GXRenderModeObj *mode) {
     s32 i;
     
     for (i = 0; i < 4; i++) {
-        XFB_Geometry.unk0[i] = 0;
+        XFB_Geometry.frame_buffers[i] = 0;
     }
     
-    XFB_Geometry.unk4 = 0;
-    XFB_Geometry.unk5 = 0;
-    XFB_Geometry.unk6 = 0;
+    XFB_Geometry.width = 0;
+    XFB_Geometry.height = 0;
+    XFB_Geometry.mode = 0;
     
     XFB_putc = XFB_putcProgressive;
     Draw_Color = XFB_Colors[1];
     
     if (mode) {
-        XFB_Geometry.unk4 = ((u16)mode->fbWidth + 0xF) & 0xFFFFFFF0;
-        XFB_Geometry.unk5 = mode->xfbHeight;
-        XFB_Geometry.unk6 = mode->xFBmode;
+        XFB_Geometry.width = ((u16)mode->fbWidth + 0xF) & 0xFFFFFFF0;
+        XFB_Geometry.height = mode->xfbHeight;
+        XFB_Geometry.mode = mode->xFBmode;
         
-        if (XFB_Geometry.unk6 == 0) {
+        if (XFB_Geometry.mode == 0) {
             XFB_putc = XFB_putcInterlace;
-            return;
+        } else {
+            XFB_putc = XFB_putcProgressive;
         }
-        XFB_putc = XFB_putcProgressive;
     }
 }
 
 void HuFaultSetXfbAddress(s16 index, void* value) {
     if (index >= 0 && index < 4) {
-        XFB_Geometry.unk0[index] = value;
+        XFB_Geometry.frame_buffers[index] = value;
     }
 }
 
-void XFB_WriteBackCache(void) {
-    s32 var_r31;
-    void* temp_r30;
+static void XFB_WriteBackCache(void) {
+    s32 i;
+    void* frame_buffer;
     u32 temp_r29;
 
-    temp_r29 = XFB_Geometry.unk4 * 2 * XFB_Geometry.unk5;
+    temp_r29 = XFB_Geometry.width * 2 * XFB_Geometry.height;
     
     if (temp_r29 != 0) {
-        var_r31 = 0;
-        
-        while (var_r31 < 4) {
-            temp_r30 = XFB_Geometry.unk0[var_r31];
-            if (temp_r30) {
-                DCStoreRange(temp_r30, temp_r29);
+        for (i = 0; i < 4; i += 1) {
+            frame_buffer = XFB_Geometry.frame_buffers[i];
+            
+            if (frame_buffer) {
+                DCStoreRange(frame_buffer, temp_r29);
             }
-            var_r31 += 1;
         }
     }
 }
 
-
-void XFB_CR(s32 arg0, s32* arg1, s32* arg2) {
+static void XFB_CR(s32 arg0, s32* x_ptr, s32* y_ptr) {
     s32 temp_r30;
-    s32 var_r31;
-    s32 var_r29;
+    s32 y;
+    s32 x;
 
-    var_r29 = *arg1;
-    var_r31 = *arg2;
+    x = *x_ptr;
+    y = *y_ptr;
     
-    var_r29 = x_start;
-    var_r31 += 0x12;
+    x = x_start;
+    y += 0x12;
     
     temp_r30 = arg0 & 7;
     if (temp_r30 != 0) {
-        var_r31 += temp_r30 * 0x12;
+        y += temp_r30 * 0x12;
     }
 
-    *arg1 = var_r29;
-    *arg2 = var_r31;
+    *x_ptr = x;
+    *y_ptr = y;
 }
 
-s32 XFB_puts(s8* arg0, s32 arg1, s32 arg2) {
+static s32 XFB_puts(s8* message, s32 x, s32 y) {
     s32 i;
     s32 temp_r31;
     s8 current_char;
@@ -149,24 +145,24 @@ s32 XFB_puts(s8* arg0, s32 arg1, s32 arg2) {
     i = 0;
     
     do {
-        current_char = *arg0++;
+        current_char = *message++;
         
         if (current_char == '\n') {
-            XFB_CR(0, &arg1, &arg2);
+            XFB_CR(0, &x, &y);
             
             i += 1;
         } else {
-            temp_r31 = XFB_putcS(current_char, arg1, arg2);
+            temp_r31 = XFB_putcS(current_char, x, y);
             
             if (temp_r31 >= 0) {
                 if (temp_r31 != 0) {
                     temp_r31 -= 1;
 
-                    XFB_CR(temp_r31, &arg1, &arg2);
+                    XFB_CR(temp_r31, &x, &y);
                     
                     i += temp_r31 + 1;
                 }
-                arg1 += 0x10;
+                x += 0x10;
             } else {
                 break;
             }
@@ -176,7 +172,7 @@ s32 XFB_puts(s8* arg0, s32 arg1, s32 arg2) {
     return i;
 }
 
-s32 XFB_putcS(u8 arg0, s32 arg1, s32 arg2) {
+static s32 XFB_putcS(u8 c, s32 x, s32 y) {
     RGBColor sp8;
     s32 var_r26;
     s32 var_r25;
@@ -187,91 +183,76 @@ s32 XFB_putcS(u8 arg0, s32 arg1, s32 arg2) {
     var_r27 = 0;
     sp8 = Draw_Color;
     
-    if (arg1 + 0x11 >= XFB_Geometry.unk4) {
-        var_r26 = arg1;
-        var_r29 = arg2;
-        if (0 != 0) {
-            var_r29 += 0 * 0x12;
-        }
-        var_r26 = x_start;
-        var_r29 += 0x12;
-        var_r25 = 0;
-
-        if (var_r25 != 0) {
-            var_r29 += var_r25 * 0x12;
-        }
-
-        arg1 = var_r26;
-        arg2 = var_r29;
+    if (x + 0x11 >= XFB_Geometry.width) {
+        XFB_CR(0, &x, &y);
         var_r27++;
     }
     
-    Draw_Color = *XFB_Colors;
-    XFB_putc(arg0, arg1, arg2 - 2);
-    XFB_putc(arg0, arg1, arg2 + 2);
-    XFB_putc(arg0, arg1 - 1, arg2);
-    XFB_putc(arg0, arg1 + 1, arg2);
+    Draw_Color = XFB_Colors[0];
+    XFB_putc(c, x, y - 2);
+    XFB_putc(c, x, y + 2);
+    XFB_putc(c, x - 1, y);
+    XFB_putc(c, x + 1, y);
     
     Draw_Color = sp8;
-    XFB_putc(arg0, arg1, arg2);
+    XFB_putc(c, x, y);
     
     return var_r27;
 }
 
-s32 XFB_putcProgressive(u8 arg0, s32 arg1, s32 arg2) {
-    s32 var_r21;
+static s32 XFB_putcProgressive(u8 c, s32 x, s32 y) {
+    s32 result;
     s32 temp_r20;
-    u8 spA;
-    u8 sp9;
-    u8 sp8;
-    s32 var_r25;
-    s32 var_r24;
+    u8 red;
+    u8 blue;
+    u8 green;
+    s32 i;
+    s32 j;
     s32 var_r23;
     u8* var_r29;
-    s32 var_r28;
+    s32 k;
     s32 var_r27;
     s32 var_r26;
     u32 temp_r31;
     u32 var_r30;
     u32 var_r22;
-    u8* var_r31;
+    u8* frame_buffer;
     
-    var_r21 = 0;
+    result = 0;
     
-    if (arg0 == 0) {
+    if (c == 0) {
         return -1;
     }
     
-    if (arg1 + 0x10 >= XFB_Geometry.unk4) {
-        arg2 += 0x12;
-        arg1 = x_start;
-        var_r21 = 1;
+    if (x + 0x10 >= XFB_Geometry.width) {
+        y += 0x12;
+        x = x_start;
+        result = 1;
     }
     
-    if (arg2 + 0x10 >= XFB_Geometry.unk5) {
+    if (y + 0x10 >= XFB_Geometry.height) {
         return -1;
     }
     
-    spA = Draw_Color.r;
-    sp8 = Draw_Color.g;
-    sp9 = Draw_Color.b;
+    red = Draw_Color.r;
+    green = Draw_Color.g;
+    blue = Draw_Color.b;
     
-    temp_r20 = XFB_Geometry.unk4 * 2;
-    var_r23 = (arg1 & 0xFFFE) * 2 + arg2 * temp_r20;
-    var_r29 = Ascii8x8_1bpp + (arg0 * 8);
-    var_r25 = 8;
+    temp_r20 = XFB_Geometry.width * 2;
+    var_r23 = (x & 0xFFFE) * 2 + y * temp_r20;
+    var_r29 = Ascii8x8_1bpp + (c * 8);
     
-    while (var_r25 != 0) {
-        var_r24 = 2;
+    i = 8;
+    
+    while (i != 0) {
+        j = 2;
         
-        while (var_r24 != 0) {
-            var_r28 = 0;
-            
-            while (var_r28 < 4) {
-                var_r31 = XFB_Geometry.unk0[var_r28];
+        while (j != 0) {
+            for (k = 0; k < 4; k ++) {
+                frame_buffer = XFB_Geometry.frame_buffers[k];
                 
-                if (var_r31 != 0) {
-                    var_r31 += var_r23;
+                if (frame_buffer != 0) {
+                    frame_buffer += var_r23;
                     
                     var_r22 = *var_r29;
                     var_r30 = 0;
@@ -284,99 +265,101 @@ s32 XFB_putcProgressive(u8 arg0, s32 arg1, s32 arg2) {
                         var_r22 >>= 1;
                     }
                     var_r27 = 8;
-                    if ((s32) (arg1 & 1) != 0) {
+                    if ((s32) (x & 1) != 0) {
                         var_r30 *= 2;
                         var_r27 = 0xA;
                     }
                     
                     while (var_r27 != 0) {
                         if ((u32) (var_r30 & 3) != 0) {
-                            var_r31[1] = sp9;
-                            var_r31[3] = sp8;
+                            frame_buffer[1] = blue;
+                            frame_buffer[3] = green;
                             
                             if ((u32) (var_r30 & 1) != 0) {
-                                var_r31[0] = spA;
+                                frame_buffer[0] = red;
                             }
                             if ((u32) (var_r30 & 2) != 0) {
-                                var_r31[2] = spA;
+                                frame_buffer[2] = red;
                             }
                         }
                         var_r27 -= 1;
-                        var_r31 += 4;
+                        frame_buffer += 4;
                         var_r30 = var_r30 >> 2;
                     }
                 }
-                var_r28 += 1;
             }
-            var_r24 -= 1;
+            
+            j -= 1;
             var_r23 += temp_r20;
         }
-        var_r25 -= 1;
+        i -= 1;
         var_r29 += 1;
     }
-    return var_r21;
+    
+    return result;
 }
 
-s32 XFB_putcInterlace(u8 arg0, s32 arg1, s32 arg2) {
-    u8 var_r24;
-    u8 var_r22;
-    u8 var_r21;
+static s32 XFB_putcInterlace(u8 c, s32 x, s32 y) {
+    u8 red;
+    u8 blue;
+    u8 green;
     s32 temp_r23;
-    s32 var_r26;
+    s32 i;
     s32 var_r25;
     u8* var_r28;
-    s32 var_r27;
+    s32 j;
     s16 var_r29;
     s32 var_r30;
     u8* var_r31;
     
-    if (arg0 == 0) {
+    if (c == 0) {
         return -1;
     }
     
-    if (arg1 + 8 >= XFB_Geometry.unk4 || arg2 + 8 >= XFB_Geometry.unk5) {
+    if (x + 8 >= XFB_Geometry.width || y + 8 >= XFB_Geometry.height) {
         return -1;
     }
 
-    var_r24 = Draw_Color.r;
-    var_r21 = Draw_Color.g;
-    var_r22 = Draw_Color.b;
+    red = Draw_Color.r;
+    green = Draw_Color.g;
+    blue = Draw_Color.b;
     
-    temp_r23 = XFB_Geometry.unk4 * 2;
-    var_r25 = ((arg1 & 0xFFFE) * 2) + ((arg2 >> 1) * temp_r23);
-    var_r28 = Ascii8x8_1bpp + arg0 * 8;
-    var_r26 = 8;
+    temp_r23 = XFB_Geometry.width * 2;
+    var_r25 = ((x & 0xFFFE) * 2) + ((y >> 1) * temp_r23);
+    var_r28 = Ascii8x8_1bpp + c * 8;
     
-    while (var_r26) {
-        for (var_r27 = 0; var_r27 < 4; var_r27 += 2) {
-            var_r30 = var_r27;
+    i = 8;
+    
+    while (i != 0) {
+        for (j = 0; j < 4; j += 2) {
+            var_r30 = j;
             
-            if ((s32) (arg2 & 1) != 0) {
+            if ((s32) (y & 1) != 0) {
                 var_r30 += 1;
             }
             
-            var_r31 = XFB_Geometry.unk0[var_r30];
+            var_r31 = XFB_Geometry.frame_buffers[var_r30];
             
             if (var_r31) {
                 var_r31 = var_r31 + var_r25;
                 var_r29 = *var_r28;
                 var_r30 = 4;
                 
-                if (arg1 & 1) {
+                if (x & 1) {
                     var_r29 = (s16)var_r29 * 2;
                     var_r30 = 5;
                 }
 
                 while (var_r30) {
                     if (var_r29 & 3) {
-                        var_r31[1] = var_r22;
-                        var_r31[3] = var_r21;
+                        var_r31[1] = blue;
+                        var_r31[3] = green;
                         
                         if (var_r29 & 1) {
-                            var_r31[0] = var_r24;
+                            var_r31[0] = red;
                         }
                         if (var_r29 & 2) {
-                            var_r31[2] = var_r24;
+                            var_r31[2] = red;
                         }
                     }
                     
@@ -387,8 +370,8 @@ s32 XFB_putcInterlace(u8 arg0, s32 arg1, s32 arg2) {
             }
         }
         
-        var_r26 -= 1;
-        arg2 += 1;
+        i -= 1;
+        y += 1;
         var_r28 += 1;
         var_r25 += temp_r23;
     }
diff --git a/src/game/init.c b/src/game/init.c
index 465a5bef..06adbaad 100644
--- a/src/game/init.c
+++ b/src/game/init.c
@@ -1,4 +1,5 @@
 #include "game/init.h"
+#include "game/fault.h"
 #include "dolphin/os.h"
 #include "dolphin/gx.h"
 #include "dolphin/dvd.h"
@@ -14,8 +15,6 @@ extern void HuAudInit();
 extern void HuCardInit();
 extern void HuARInit();
 extern u32 frand();
-extern void HuFaultInitXfbDirectDraw(GXRenderModeObj *mode);
-extern void HuFaultSetXfbAddress(int fb, void *addr);
 
 static GXRenderModeObj rmodeobj;
 

From 3a50498a3ff8aecae3c02de32e1f987e70e69dd7 Mon Sep 17 00:00:00 2001
From: gamemasterplc <gamemasterplc@gmail.com>
Date: Sat, 27 Jan 2024 14:43:35 -0600
Subject: [PATCH 02/15] Label game/main.c

---
 config/GMPE01_00/symbols.txt | 38 ++++++++--------
 src/game/main.c              | 86 ++++++++++++++++++------------------
 2 files changed, 63 insertions(+), 61 deletions(-)

diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt
index 922ccfa3..f5df7bf8 100644
--- a/config/GMPE01_00/symbols.txt
+++ b/config/GMPE01_00/symbols.txt
@@ -6027,25 +6027,25 @@ dspSlaveLength = .sdata:0x801D39F0; // type:object size:0x2 data:2byte
 SendCount = .sdata:0x801D39F8; // type:object size:0x1 scope:local data:byte
 SystemInitF = .sbss:0x801D3A00; // type:object size:0x4 data:4byte
 HuDvdErrWait = .sbss:0x801D3A04; // type:object size:0x4 data:4byte
-lbl_801D3A08 = .sbss:0x801D3A08; // type:object size:0x4
-lbl_801D3A0C = .sbss:0x801D3A0C; // type:object size:0x4
-lbl_801D3A10 = .sbss:0x801D3A10; // type:object size:0x4
-lbl_801D3A14 = .sbss:0x801D3A14; // type:object size:0x4
-lbl_801D3A18 = .sbss:0x801D3A18; // type:object size:0x4
-lbl_801D3A1C = .sbss:0x801D3A1C; // type:object size:0x4
-lbl_801D3A20 = .sbss:0x801D3A20; // type:object size:0x4
-lbl_801D3A24 = .sbss:0x801D3A24; // type:object size:0x4
-lbl_801D3A28 = .sbss:0x801D3A28; // type:object size:0x4
-lbl_801D3A2C = .sbss:0x801D3A2C; // type:object size:0x4
-lbl_801D3A30 = .sbss:0x801D3A30; // type:object size:0x4
-lbl_801D3A34 = .sbss:0x801D3A34; // type:object size:0x4
-lbl_801D3A38 = .sbss:0x801D3A38; // type:object size:0x4
-lbl_801D3A3C = .sbss:0x801D3A3C; // type:object size:0x4
-lbl_801D3A40 = .sbss:0x801D3A40; // type:object size:0x4
-lbl_801D3A44 = .sbss:0x801D3A44; // type:object size:0x4
-lbl_801D3A48 = .sbss:0x801D3A48; // type:object size:0x4
-lbl_801D3A4C = .sbss:0x801D3A4C; // type:object size:0x4
-lbl_801D3A50 = .sbss:0x801D3A50; // type:object size:0x4
+fi_req = .sbss:0x801D3A08; // type:object size:0x4 scope:local
+rf_req = .sbss:0x801D3A0C; // type:object size:0x4 scope:local
+pe_req = .sbss:0x801D3A10; // type:object size:0x4 scope:local
+vi_req = .sbss:0x801D3A14; // type:object size:0x4 scope:local
+io_req = .sbss:0x801D3A18; // type:object size:0x4 scope:local
+dsp_req = .sbss:0x801D3A1C; // type:object size:0x4 scope:local
+cpu_wr_req = .sbss:0x801D3A20; // type:object size:0x4 scope:local
+cpu_rd_req = .sbss:0x801D3A24; // type:object size:0x4 scope:local
+tc_req = .sbss:0x801D3A28; // type:object size:0x4 scope:local
+cp_req = .sbss:0x801D3A2C; // type:object size:0x4 scope:local
+total_copy_clks = .sbss:0x801D3A30; // type:object size:0x4 scope:local
+clr_pixels_in = .sbss:0x801D3A34; // type:object size:0x4 scope:local
+bot_pixels_out = .sbss:0x801D3A38; // type:object size:0x4 scope:local
+bot_pixels_in = .sbss:0x801D3A3C; // type:object size:0x4 scope:local
+top_pixels_out = .sbss:0x801D3A40; // type:object size:0x4 scope:local
+top_pixels_in = .sbss:0x801D3A44; // type:object size:0x4 scope:local
+vstall = .sbss:0x801D3A48; // type:object size:0x4 scope:local
+vmiss = .sbss:0x801D3A4C; // type:object size:0x4 scope:local
+vcheck = .sbss:0x801D3A50; // type:object size:0x4 scope:local
 GlobalCounter = .sbss:0x801D3A54; // type:object size:0x4 data:4byte
 VCounter = .sbss:0x801D3A58; // type:object size:0x4 data:4byte
 RumbleBit = .sbss:0x801D3A5C; // type:object size:0x4 scope:local data:4byte
diff --git a/src/game/main.c b/src/game/main.c
index 1e0e3415..7fe5b41f 100644
--- a/src/game/main.c
+++ b/src/game/main.c
@@ -15,35 +15,34 @@
 
 extern FileListEntry _ovltbl[];
 u32 GlobalCounter;
-u32 lbl_801D3A50;
-u32 lbl_801D3A4C;
-u32 lbl_801D3A48;
-u32 lbl_801D3A44;
-u32 lbl_801D3A40;
-u32 lbl_801D3A3C;
-u32 lbl_801D3A38;
-u32 lbl_801D3A34;
-u32 lbl_801D3A30;
-u32 lbl_801D3A2C;
-u32 lbl_801D3A28;
-u32 lbl_801D3A24;
-u32 lbl_801D3A20;
-u32 lbl_801D3A1C;
-u32 lbl_801D3A18;
-u32 lbl_801D3A14;
-u32 lbl_801D3A10;
-u32 lbl_801D3A0C;
-u32 lbl_801D3A08;
+static u32 vcheck;
+static u32 vmiss;
+static u32 vstall;
+static u32 top_pixels_in;
+static u32 top_pixels_out;
+static u32 bot_pixels_in;
+static u32 bot_pixels_out;
+static u32 clr_pixels_in;
+static u32 total_copy_clks;
+static u32 cp_req;
+static u32 tc_req;
+static u32 cpu_rd_req;
+static u32 cpu_wr_req;
+static u32 dsp_req;
+static u32 io_req;
+static u32 vi_req;
+static u32 pe_req;
+static u32 rf_req;
+static u32 fi_req;
 s32 HuDvdErrWait;
 s32 SystemInitF;
 
-void main(void) {
-    u32 sp14;
-    u32 sp10;
-    s32 spC;
-    s32 sp8;
-    s16 var_r31;
-    s32 temp_r30;
+void main(void)
+{
+    u32 met0;
+    u32 met1;
+    s16 i;
+    s32 retrace;
 
     HuDvdErrWait = 0;
     SystemInitF = 0;
@@ -58,14 +57,14 @@ void main(void) {
     HuDataInit();
     HuPerfInit();
     HuPerfCreate("USR0", 0xFF, 0xFF, 0xFF, 0xFF);
-    HuPerfCreate("USR1", 0,    0xFF, 0xFF, 0xFF);
+    HuPerfCreate("USR1", 0, 0xFF, 0xFF, 0xFF);
     WipeInit(RenderMode);
     
-    for (var_r31 = 0; var_r31 < 4; var_r31++) {
-        GWPlayerCfg[var_r31].character = -1;
+    for (i = 0; i < 4; i++) {
+        GWPlayerCfg[i].character = -1;
     }
     
-    omMasterInit(0, _ovltbl, 0x63, 1);
+    omMasterInit(0, _ovltbl, OVL_COUNT, OVL_BOOT);
     VIWaitForRetrace();
     
     if (VIGetNextField() == 0) {
@@ -73,7 +72,7 @@ void main(void) {
         VIWaitForRetrace();
     }
     while (1) {
-        temp_r30 = VIGetRetraceCount();
+        retrace = VIGetRetraceCount();
         if (HuSoftResetButtonCheck() != 0 || HuDvdErrWait != 0) {
             continue;
         }
@@ -100,28 +99,31 @@ void main(void) {
         pfDrawFonts();
         HuPerfEnd(1);
         msmMusFdoutEnd();
-        HuSysDoneRender(temp_r30);
-        GXReadGPMetric(&sp14, &sp10);
-        GXReadVCacheMetric(&lbl_801D3A50, &lbl_801D3A4C, &lbl_801D3A48);
-        GXReadPixMetric(&lbl_801D3A44, &lbl_801D3A40, &lbl_801D3A3C, &lbl_801D3A38, &lbl_801D3A34, &lbl_801D3A30);
-        GXReadMemMetric(&lbl_801D3A2C, &lbl_801D3A28, &lbl_801D3A24, &lbl_801D3A20, &lbl_801D3A1C, &lbl_801D3A18, &lbl_801D3A14, &lbl_801D3A10, &lbl_801D3A0C, &lbl_801D3A08);
+        HuSysDoneRender(retrace);
+        GXReadGPMetric(&met0, &met1);
+        GXReadVCacheMetric(&vcheck, &vmiss, &vstall);
+        GXReadPixMetric(&top_pixels_in, &top_pixels_out, &bot_pixels_in, &bot_pixels_out, &clr_pixels_in, &total_copy_clks);
+        GXReadMemMetric(&cp_req, &tc_req, &cpu_rd_req, &cpu_wr_req, &dsp_req, &io_req, &vi_req, &pe_req, &rf_req, &fi_req);
         HuPerfEnd(2);
         GlobalCounter++;
     }
 }
 
-void HuSysVWaitSet(s16 arg0) {
-    minimumVcount = arg0;
-    minimumVcountf = arg0;
+void HuSysVWaitSet(s16 vcount)
+{
+    minimumVcount = vcount;
+    minimumVcountf = vcount;
 }
 
-s16 HuSysVWaitGet(void) {
+s16 HuSysVWaitGet(void)
+{
     return (s16) minimumVcount;
 }
 
 s32 rnd_seed = 0x0000D9ED;
 
-s32 rand8(void) {
+s32 rand8(void)
+{
     rnd_seed = (rnd_seed * 0x41C64E6D) + 0x3039;
-    return (u8)(((rnd_seed + 1) >> 0x10) & 0xFF);
+    return (u8)(((rnd_seed + 1) >> 16) & 0xFF);
 }

From 45c3ffb101a1a640d96e25c460e629b2ddb193ee Mon Sep 17 00:00:00 2001
From: gamemasterplc <gamemasterplc@gmail.com>
Date: Sat, 27 Jan 2024 16:52:46 -0600
Subject: [PATCH 03/15] Start work on minigame_seq.c

Need to figure out mgInfoTbl more for further progress
---
 config/GMPE01_00/symbols.txt | 108 ++++++------
 src/game/main.c              |   2 +-
 src/game/minigame_seq.c      | 311 +++++++++++++++++++++++++++++++++++
 3 files changed, 366 insertions(+), 55 deletions(-)
 create mode 100644 src/game/minigame_seq.c

diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt
index f5df7bf8..ac3a0cdd 100644
--- a/config/GMPE01_00/symbols.txt
+++ b/config/GMPE01_00/symbols.txt
@@ -4932,27 +4932,27 @@ lbl_8012F020 = .data:0x8012F020; // type:object size:0x94
 lbl_8012F0B4 = .data:0x8012F0B4; // type:object size:0x11 data:string
 lbl_8012F0C5 = .data:0x8012F0C5; // type:object size:0x3A
 lbl_8012F0FF = .data:0x8012F0FF; // type:object size:0x31
-seqInfo = .data:0x8012F130; // type:object size:0x1DC scope:local
+seqInfoTbl = .data:0x8012F130; // type:object size:0x1DC scope:local
 seqType2SprTbl = .data:0x8012F30C; // type:object size:0x18 scope:local
-seqTypeTbl = .data:0x8012F324; // type:object size:0x12 scope:local
+mgSeqTypeTbl = .data:0x8012F324; // type:object size:0x12 scope:local
 lbl_8012F336 = .data:0x8012F336; // type:object size:0x53 scope:local data:string
 lbl_8012F389 = .data:0x8012F389; // type:object size:0x9 scope:local data:string
 lbl_8012F392 = .data:0x8012F392; // type:object size:0x9 scope:local data:string
 seqFontAlphaTbl = .data:0x8012F39B; // type:object size:0x35 scope:local data:string
 seqFontKanaTbl = .data:0x8012F3D0; // type:object size:0x52 scope:local data:string
 seqFontNumTbl = .data:0x8012F422; // type:object size:0xB scope:local data:string
-lbl_8012F430 = .data:0x8012F430; // type:object size:0x14
-wordTbl = .data:0x8012F444; // type:object size:0x18 scope:local
+letterBufTbl = .data:0x8012F430; // type:object size:0x14 scope:local
+wordMgTbl = .data:0x8012F444; // type:object size:0x18 scope:local
 letterBattleOfs = .data:0x8012F45C; // type:object size:0x40 scope:local
 letter2vs2Ofs = .data:0x8012F49C; // type:object size:0x1C scope:local
 letterBowserOfs = .data:0x8012F4B8; // type:object size:0x38 scope:local
-lbl_8012F4F0 = .data:0x8012F4F0; // type:object size:0xA data:string
-charNameTbl = .data:0x8012F4FC; // type:object size:0x78 scope:local
-lbl_8012F574 = .data:0x8012F574; // type:object size:0xA data:string
-winStrTbl = .data:0x8012F580; // type:object size:0x18 scope:local
+charMKoopaNameE = .data:0x8012F4F0; // type:object size:0xA scope:local data:string
+winCharNameTbl = .data:0x8012F4FC; // type:object size:0x78 scope:local
+wordChampionE = .data:0x8012F574; // type:object size:0xA scope:local data:string
+winWordTbl = .data:0x8012F580; // type:object size:0x18 scope:local
 winPosOfs = .data:0x8012F598; // type:object size:0x50 scope:local
 practiceTbl = .data:0x8012F5E8; // type:object size:0xAC scope:local
-practiceData = .data:0x8012F694; // type:object size:0xC scope:local
+practicePosYTbl = .data:0x8012F694; // type:object size:0xC scope:local
 seqFXTbl = .data:0x8012F6A0; // type:object size:0xF0 scope:local
 lbl_8012F790 = .data:0x8012F790; // type:object size:0x15 data:string
 lbl_8012F7A5 = .data:0x8012F7A5; // type:object size:0x10 data:string
@@ -5136,7 +5136,7 @@ lbl_801311C4 = .data:0x801311C4; // type:object size:0x24
 VolumeTable = .data:0x801311E8; // type:object size:0x100 scope:local
 lbl_801312E8 = .data:0x801312E8; // type:object size:0x4D
 lbl_80131335 = .data:0x80131335; // type:object size:0x1B
-MGInfoTable = .data:0x80131350; // type:object size:0xE00 data:2byte
+mgInfoTbl = .data:0x80131350; // type:object size:0xE00 data:2byte
 lbl_80132150 = .data:0x80132150; // type:object size:0x40
 lbl_80132190 = .data:0x80132190; // type:object size:0xC data:string
 lbl_8013219C = .data:0x8013219C; // type:object size:0xC data:string
@@ -5521,7 +5521,7 @@ CZoomM = .bss:0x801901A0; // type:object size:0x40
 omDLLinfoTbl = .bss:0x801901E0; // type:object size:0x50
 sndFXBuf = .bss:0x80190230; // type:object size:0x200 scope:local
 charVoiceGroupStat = .bss:0x80190430; // type:object size:0x20 scope:local
-seqStat = .bss:0x80190450; // type:object size:0x400 scope:local data:4byte
+seqWorkData = .bss:0x80190450; // type:object size:0x400 scope:local data:4byte
 seqMaxTime = .bss:0x80190850; // type:object size:0x10 scope:local data:2byte
 esprite = .bss:0x80190860; // type:object size:0x600 data:2byte
 espanim = .bss:0x80190E60; // type:object size:0x1200 data:4byte
@@ -5783,49 +5783,49 @@ lbl_801D34A4 = .sdata:0x801D34A4; // type:object size:0xC
 lbl_801D34B0 = .sdata:0x801D34B0; // type:object size:0x1
 lbl_801D34B1 = .sdata:0x801D34B1; // type:object size:0x7
 mgSeqInitF = .sdata:0x801D34B8; // type:object size:0x4 data:4byte
-lbl_801D34BC = .sdata:0x801D34BC; // type:object size:0x7 data:string
-lbl_801D34C3 = .sdata:0x801D34C3; // type:object size:0x3 data:byte
-lbl_801D34C6 = .sdata:0x801D34C6; // type:object size:0x6
-lbl_801D34CC = .sdata:0x801D34CC; // type:object size:0x8
-lbl_801D34D4 = .sdata:0x801D34D4; // type:object size:0x6
-lbl_801D34DA = .sdata:0x801D34DA; // type:object size:0x8 data:string
-lbl_801D34E2 = .sdata:0x801D34E2; // type:object size:0x6 data:string
-lbl_801D34E8 = .sdata:0x801D34E8; // type:object size:0x4
-lbl_801D34EC = .sdata:0x801D34EC; // type:object size:0x6 data:string
-lbl_801D34F2 = .sdata:0x801D34F2; // type:object size:0x6
-lbl_801D34F8 = .sdata:0x801D34F8; // type:object size:0x6 data:string
-lbl_801D34FE = .sdata:0x801D34FE; // type:object size:0x5
-lbl_801D3503 = .sdata:0x801D3503; // type:object size:0x6 data:string
-lbl_801D3509 = .sdata:0x801D3509; // type:object size:0x5
-lbl_801D350E = .sdata:0x801D350E; // type:object size:0x6 data:string
-lbl_801D3514 = .sdata:0x801D3514; // type:object size:0x4
-lbl_801D3518 = .sdata:0x801D3518; // type:object size:0x6 data:string
-lbl_801D351E = .sdata:0x801D351E; // type:object size:0x6
-lbl_801D3524 = .sdata:0x801D3524; // type:object size:0x5 data:string
-lbl_801D3529 = .sdata:0x801D3529; // type:object size:0x7
-lbl_801D3530 = .sdata:0x801D3530; // type:object size:0x6 data:string
-lbl_801D3536 = .sdata:0x801D3536; // type:object size:0x7
-lbl_801D353D = .sdata:0x801D353D; // type:object size:0x8 data:string
-lbl_801D3545 = .sdata:0x801D3545; // type:object size:0x5
-lbl_801D354A = .sdata:0x801D354A; // type:object size:0x7 data:string
-lbl_801D3551 = .sdata:0x801D3551; // type:object size:0x6
-lbl_801D3557 = .sdata:0x801D3557; // type:object size:0x5 data:string
-lbl_801D355C = .sdata:0x801D355C; // type:object size:0x5
-lbl_801D3561 = .sdata:0x801D3561; // type:object size:0x8 data:string
-lbl_801D3569 = .sdata:0x801D3569; // type:object size:0x4
-lbl_801D356D = .sdata:0x801D356D; // type:object size:0x4 data:string
-lbl_801D3571 = .sdata:0x801D3571; // type:object size:0x5
-lbl_801D3576 = .sdata:0x801D3576; // type:object size:0x6 data:string
-lbl_801D357C = .sdata:0x801D357C; // type:object size:0x7
-lbl_801D3583 = .sdata:0x801D3583; // type:object size:0x6
-lbl_801D3589 = .sdata:0x801D3589; // type:object size:0x7 data:string
-lbl_801D3590 = .sdata:0x801D3590; // type:object size:0x3
-lbl_801D3593 = .sdata:0x801D3593; // type:object size:0x5 data:string
-lbl_801D3598 = .sdata:0x801D3598; // type:object size:0x6
-lbl_801D359E = .sdata:0x801D359E; // type:object size:0x5 data:string
-lbl_801D35A3 = .sdata:0x801D35A3; // type:object size:0x7
-lbl_801D35AA = .sdata:0x801D35AA; // type:object size:0x6
-lbl_801D35B0 = .sdata:0x801D35B0; // type:object size:0x6 data:string
+wordStartE = .sdata:0x801D34BC; // type:object size:0x7 scope:local data:string
+punctTbl = .sdata:0x801D34C3; // type:object size:0x3 scope:local data:byte
+wordStartJ = .sdata:0x801D34C6; // type:object size:0x6 scope:local
+wordFinishJ = .sdata:0x801D34CC; // type:object size:0x8 scope:local
+wordDrawJ = .sdata:0x801D34D4; // type:object size:0x6 scope:local
+wordFinishE = .sdata:0x801D34DA; // type:object size:0x8 scope:local data:string
+wordDrawE = .sdata:0x801D34E2; // type:object size:0x6 scope:local data:string
+charMarioNameJ = .sdata:0x801D34E8; // type:object size:0x4 scope:local
+charMarioNameE = .sdata:0x801D34EC; // type:object size:0x6 scope:local data:string
+charLuigiNameJ = .sdata:0x801D34F2; // type:object size:0x6 scope:local
+charLuigiNameE = .sdata:0x801D34F8; // type:object size:0x6 scope:local data:string
+charPeachNameJ = .sdata:0x801D34FE; // type:object size:0x5 scope:local
+charPeachNameE = .sdata:0x801D3503; // type:object size:0x6 scope:local data:string
+charYoshiNameJ = .sdata:0x801D3509; // type:object size:0x5 scope:local
+charYoshiNameE = .sdata:0x801D350E; // type:object size:0x6 scope:local data:string
+charWarioNameJ = .sdata:0x801D3514; // type:object size:0x4 scope:local
+charWarioNameE = .sdata:0x801D3518; // type:object size:0x6 scope:local data:string
+charDonkeyNameJ = .sdata:0x801D351E; // type:object size:0x6 scope:local
+charDonkeyNameE = .sdata:0x801D3524; // type:object size:0x5 scope:local data:string
+charDaisyNameJ = .sdata:0x801D3529; // type:object size:0x7 scope:local
+charDaisyNameE = .sdata:0x801D3530; // type:object size:0x6 scope:local data:string
+charWaluigiNameJ = .sdata:0x801D3536; // type:object size:0x7 scope:local
+charWaluigiNameE = .sdata:0x801D353D; // type:object size:0x8 scope:local data:string
+charKoopaNameJ = .sdata:0x801D3545; // type:object size:0x5 scope:local
+charKoopaNameE = .sdata:0x801D354A; // type:object size:0x7 scope:local data:string
+charKinopioNameJ = .sdata:0x801D3551; // type:object size:0x6 scope:local
+charKinopioNameE = .sdata:0x801D3557; // type:object size:0x5 scope:local data:string
+charHeihoNameJ = .sdata:0x801D355C; // type:object size:0x5 scope:local
+charHeihoNameE = .sdata:0x801D3561; // type:object size:0x8 scope:local data:string
+charTeresaNameJ = .sdata:0x801D3569; // type:object size:0x4 scope:local
+charTeresaNameE = .sdata:0x801D356D; // type:object size:0x4 scope:local data:string
+charNoko2NameJ = .sdata:0x801D3571; // type:object size:0x5 scope:local
+charNoko2NameE = .sdata:0x801D3576; // type:object size:0x6 scope:local data:string
+charMKoopaNameJ = .sdata:0x801D357C; // type:object size:0x7 scope:local
+charKuriboNameJ = .sdata:0x801D3583; // type:object size:0x6 scope:local
+charKuriboNameJ = .sdata:0x801D3589; // type:object size:0x7 scope:local data:string
+wordWinJ = .sdata:0x801D3590; // type:object size:0x3 scope:local
+wordWinE = .sdata:0x801D3593; // type:object size:0x5 scope:local data:string
+wordLoseJ = .sdata:0x801D3598; // type:object size:0x6 scope:local
+wordLoseE = .sdata:0x801D359E; // type:object size:0x5 scope:local data:string
+wordChampionJ = .sdata:0x801D35A3; // type:object size:0x7 scope:local
+wordPauseJ = .sdata:0x801D35AA; // type:object size:0x6 scope:local
+wordPauseE = .sdata:0x801D35B0; // type:object size:0x6 scope:local data:string
 pauseStrTbl = .sdata:0x801D35B8; // type:object size:0x8 scope:local
 lbl_801D35C0 = .sdata:0x801D35C0; // type:object size:0x8
 lbl_801D35C8 = .sdata:0x801D35C8; // type:object size:0x8
diff --git a/src/game/main.c b/src/game/main.c
index 7fe5b41f..a528b60e 100644
--- a/src/game/main.c
+++ b/src/game/main.c
@@ -115,7 +115,7 @@ void HuSysVWaitSet(s16 vcount)
     minimumVcountf = vcount;
 }
 
-s16 HuSysVWaitGet(void)
+s16 HuSysVWaitGet(s16 param)
 {
     return (s16) minimumVcount;
 }
diff --git a/src/game/minigame_seq.c b/src/game/minigame_seq.c
new file mode 100644
index 00000000..d3ecb1cd
--- /dev/null
+++ b/src/game/minigame_seq.c
@@ -0,0 +1,311 @@
+#include "game/armem.h"
+#include "game/sprite.h"
+#include "game/process.h"
+#include "game/gamework_data.h"
+#include "game/hsfman.h"
+
+#include "stdarg.h"
+
+extern s16 HuSysVWaitGet(s16 param);
+
+typedef struct seq_work SeqWork;
+
+typedef int (*SeqUpdateFunc)(SeqWork *work);
+typedef int (*SeqInitFunc)(SeqWork *work, va_list params);
+
+typedef struct seq_work {
+	SeqUpdateFunc update;
+	char *data;
+	float x;
+	float y;
+	float scale_x;
+	float scale_y;
+	float unk_18;
+	float work_float[2];
+	float unk_24;
+	s16 time;
+	s16 time_max;
+	s16 work_s16[4];
+	s16 param[2];
+	s16 type;
+	s16 sprite_grp[16];
+	s16 sprite[16];
+	u8 seq_no;
+	u8 stat;
+	u8 unk_7C;
+	u8 unk_7D;
+} SeqWork;
+
+typedef struct seq_info {
+	SeqInitFunc init;
+	SeqUpdateFunc update;
+	float x;
+	float y;
+	float scale_x;
+	float scale_y;
+	s32 time_max;
+} SeqInfo;
+
+static int SeqInitTimer(SeqWork *work, va_list params);
+static int SeqUpdateTimer(SeqWork *work);
+
+static int SeqInitType2(SeqWork *work, va_list params);
+static int SeqUpdateType2(SeqWork *work);
+
+static int SeqInitMGBasic(SeqWork *work, va_list params);
+static int SeqUpdateMGBasic(SeqWork *work);
+static int SeqInitMGCommon(SeqWork *work, va_list params);
+static int SeqUpdateMG1vs3(SeqWork *work);
+static int SeqUpdateMGBattle(SeqWork *work);
+static int SeqUpdateMGStory(SeqWork *work);
+static int SeqUpdateMG2vs2(SeqWork *work);
+static int SeqUpdateMGBowser(SeqWork *work);
+
+static int SeqInitWin(SeqWork *work, va_list params);
+static int SeqUpdateWin(SeqWork *work);
+static int SeqInitDraw(SeqWork *work, va_list params);
+static int SeqUpdateDraw(SeqWork *work);
+static int SeqInitRecord(SeqWork *work, va_list params);
+static int SeqUpdateRecord(SeqWork *work);
+
+static int SeqInitFlip(SeqWork *work, va_list params);
+static int SeqUpdateFlip(SeqWork *work);
+
+s32 mgSeqInitF = -1;
+
+static SeqInfo seqInfoTbl[] = {
+	{ NULL, NULL, 292.0f, 240.0f, 1.0f, 1.0f, 60 },
+	{ SeqInitTimer, SeqUpdateTimer, 292.0f, 64.0f, 1.0f, 1.0f, 60 },
+	{ SeqInitType2, SeqUpdateType2, 292.0f, 240.0f, 0.5f, 0.5f, 60 },
+	{ SeqInitMGBasic, SeqUpdateMGBasic, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
+	{ SeqInitMGCommon, SeqUpdateMG1vs3, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
+	{ SeqInitWin, SeqUpdateWin, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
+	{ SeqInitMGCommon, SeqUpdateMGBattle, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
+	{ SeqInitMGCommon, SeqUpdateMGStory, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
+	{ SeqInitMGBasic, SeqUpdateMGBasic, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
+	{ SeqInitMGCommon, SeqUpdateMG2vs2, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
+	{ SeqInitFlip, SeqUpdateFlip, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
+	{ SeqInitMGCommon, SeqUpdateMGBowser, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
+	{ SeqInitWin, SeqUpdateWin, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
+	{ SeqInitDraw, SeqUpdateDraw, 292.0f, 240.0f, 1.0f, 1.0f, 60 },
+	{ SeqInitRecord, SeqUpdateRecord, 292.0f, 240.0f, 1.0f, 1.0f, 180 },
+	{ NULL, NULL, 292.0f, 240.0f, 1.0f, 1.0f, 60 },
+	{ NULL, NULL, 292.0f, 240.0f, 1.0f, 1.0f, 60 },
+};
+
+static s32 seqType2SprTbl[6] = {
+	0, 0, 0, 0, 0, 0
+};
+
+static s16 mgSeqTypeTbl[9] = {
+	8,
+	4,
+	9,
+	11,
+	6,
+	10,
+	7,
+	11,
+	7
+};
+
+static char lbl_8012F336[] = {
+	0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
+	0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0,
+	0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8,
+	0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0,
+	0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8,
+	0xD9, 0xDA, 0xDB, 0xDC, 0xA6, 0xDD, 0xA7, 0xA8,
+	0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB6,
+	0xB7, 0xB8, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
+	0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xCA, 0xCB, 0xCC,
+	0xCD, 0xCE, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0x21,
+	0x3F, 0xB0, 0x00
+};
+
+static char lbl_8012F389[] = "x first\n";
+static char lbl_8012F392[] = "y first\n";
+
+static char seqFontAlphaTbl[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+static char seqFontKanaTbl[] = {
+	0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
+	0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0,
+	0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8,
+	0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0,
+	0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8,
+	0xD9, 0xDA, 0xDB, 0xDC, 0xA6, 0xDD, 0xA7, 0xA8,
+	0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB6,
+	0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE,
+	0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xCA, 0xCB,
+	0xCC, 0xCD, 0xCE, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE,
+	0xB0, 0x00
+};
+
+static char seqFontNumTbl[] = "0123456789";
+
+
+static s32 *letterBufTbl[5] = { };
+
+static char wordStartE[] = "START!";
+
+static char punctTbl[] = "!?";
+
+static char wordStartJ[] = {
+	0xBD, 0xC0, 0xB0, 0xC4, 0x21, 0x00
+};
+
+static char wordFinishJ[] = {
+	0xCC, 0xA8, 0xC6, 0xAF, 0xBC, 0xAD, 0x21, 0x00
+};
+
+static char wordDrawJ[] = {
+	0xCB, 0xB7, 0xDC, 0xB9, 0x21, 0x00
+};
+
+static char wordFinishE[] = "FINISH!";
+static char wordDrawE[] = "DRAW!";
+
+static char *wordMgTbl[6] = {
+	wordStartJ, wordFinishJ, wordDrawJ,
+	wordStartE, wordFinishE, wordDrawE,
+};
+
+static s16 seqMaxTime[8];
+static SeqWork seqWorkData[8];
+
+static s16 seqTimer;
+static u8 seqDoneF;
+u8 lbl_801D3D94;
+static s16 seqSpeed;
+static s16 seqPauseF;
+static s32 seqRecordVal;
+static s32 pauseWaitF;
+static s32 pauseExitF;
+static s32 pauseActiveF;
+static Process *pauseProcess;
+static s32 seqLanguage;
+
+void fn_80036BC8(void);
+
+
+void MGSeqInit(void)
+{
+	int i;
+	SeqWork *work;
+	work = &seqWorkData[0];
+	for(i=8; i!=0; i--, work++) {
+		work->seq_no = 0;
+		work->data = NULL;
+	}
+	seqPauseF = 0;
+	seqDoneF = 0;
+	lbl_801D3D94 = 0;
+	seqTimer = 30;
+	HuAR_DVDtoARAM(MAKE_DIR_NUM(DATADIR_GAMEMES));
+	HuAR_DVDtoARAM(MAKE_DIR_NUM(DATADIR_MGCONST));
+	while(HuARDMACheck());
+	fn_80036BC8();
+	mgSeqInitF = -1;
+	seqLanguage = GWLanguageGet();
+}
+
+void MGSeqMain(void)
+{
+	SeqInfo *info;
+	s32 i;
+	s32 j;
+	s32 alive_flag;
+	u8 stat;
+	SeqWork *work;
+	
+	seqSpeed = HuSysVWaitGet(seqSpeed);
+	if(Hu3DPauseF) {
+		return;
+	}
+	alive_flag = 0;
+	stat = 0;
+	work = &seqWorkData[0];
+	for(i=0; i<8; i++, work++) {
+		if(work->stat == 0) {
+			continue;
+		}
+		if(work->update) {
+			alive_flag = work->update(work);
+		} else {
+			info = &seqInfoTbl[work->seq_no];
+			if(work->seq_no != 0 && NULL != info->update) {
+				alive_flag = info->update(work);
+			}
+		}
+		if(!alive_flag) {
+			work->stat = 0;
+			if(!lbl_801D3D94) {
+				for(j=0; j<8; j++) {
+					if(seqWorkData[j].stat) {
+						break;
+					}
+				}
+			}
+			if(!work->data) {
+				HuMemDirectFree(work->data);
+				work->data = NULL;
+			}
+		}
+		stat |= work->stat;
+	}
+	if(!stat || stat & 0x4) {
+		if(seqTimer > 0) {
+			seqTimer -= seqSpeed;
+		}
+	}
+}
+
+static s16 CreateSeq(u8 seq_no, va_list params)
+{
+	SeqWork *work;
+	SeqInfo *info;
+	int i;
+	int temp;
+	work = seqWorkData;
+	info = &seqInfoTbl[seq_no];
+	for(i=0; i<8; i++, work++) {
+		if(work->stat == 0) {
+			break;
+		}
+	}
+	if(i >= 8) {
+		return -1;
+	}
+	work->stat |= 0x1;
+	if(work->data) {
+		HuMemDirectFree(work->data);
+	}
+	work->data = NULL;
+	work->seq_no = (s32)seq_no;
+	work->time = 0;
+	work->x = info->x;
+	work->y = info->y;
+	work->scale_x = info->scale_x;
+	work->scale_y = info->scale_y;
+	work->unk_18 = 0.0f;
+	work->unk_7D = 255;
+	work->time_max = info->time_max;
+	work->work_s16[0] = work->work_s16[1] = work->work_s16[2] = work->work_s16[3] = 0;
+	work->work_float[0] = work->work_float[1] = 0.0f;
+	work->param[0] = work->param[1] = 0;
+	for(temp=0; temp<16; temp++) {
+		work->sprite[temp] = work->sprite_grp[temp] = -1;
+	}
+	if(NULL != info->init) {
+		temp = info->init(work, params);
+		if(temp == 0) {
+			work->stat = 0;
+			return -1;
+		} 
+	}
+	{
+		seqTimer = 30;
+		return i;
+	}
+}

From f4d7c588c74ab0dbff7107e5b0b0e6bbdea52149 Mon Sep 17 00:00:00 2001
From: darxoon <darxoon@outlook.com>
Date: Sun, 28 Jan 2024 02:37:05 +0100
Subject: [PATCH 04/15] Add objsub.c and objsub.h

---
 configure.py                 |    2 +-
 include/game/objsub.h        |   30 +
 src/REL/m401Dll/m401Dll.h    |    2 +-
 src/REL/w03Dll/mg_item.c     |    2 +-
 src/REL/w03Dll/statue.c      |    2 +-
 src/game/board/basic_space.c |    2 +-
 src/game/board/player.c      |    4 +-
 src/game/board/space.c       |    3 +-
 src/game/board/warp.c        |    2 +-
 src/game/objsub.c            | 1284 ++++++++++++++++++++++++++++++++++
 10 files changed, 1322 insertions(+), 11 deletions(-)
 create mode 100644 include/game/objsub.h
 create mode 100644 src/game/objsub.c

diff --git a/configure.py b/configure.py
index 9b6c8c90..2e5e2462 100644
--- a/configure.py
+++ b/configure.py
@@ -355,7 +355,7 @@ config.libs = [
             Object(Matching, "game/THPSimple.c"),
             Object(Matching, "game/THPDraw.c"),
             Object(Matching, "game/thpmain.c"),
-            Object(NonMatching, "game/objsub.c"),
+            Object(Matching, "game/objsub.c"),
             Object(Matching, "game/flag.c"),
             Object(Matching, "game/saveload.c"),
             Object(NonMatching, "game/sreset.c"),
diff --git a/include/game/objsub.h b/include/game/objsub.h
new file mode 100644
index 00000000..efbbfbdd
--- /dev/null
+++ b/include/game/objsub.h
@@ -0,0 +1,30 @@
+#ifndef _GAME_OBJSUB_H
+#define _GAME_OBJSUB_H
+
+#include "dolphin.h"
+#include "game/process.h"
+
+typedef struct mg_info {
+    u16 ovl;
+    u8 type;
+    u8 flag;
+    u16 unk_4;
+    u16 unk_6;
+    u32 name_mess;
+    u32 data_dir;
+    u32 inst_pic;
+    u32 unk_14;
+    u32 unk_18;
+    u32 mg_pic;
+    u32 unk_20;
+    u32 unk_24;
+    u32 rules_mess;
+    u32 control_mess[2];
+    u32 advice_mess;
+} MgInfo;
+
+s16 omGetMGIndex(s16 overlay);
+void omGameSysInit(Process* process);
+void omVibrate(s16 player_cfg_index, s16 duration, s16 off, s16 on);
+
+#endif
diff --git a/src/REL/m401Dll/m401Dll.h b/src/REL/m401Dll/m401Dll.h
index 14e260da..76adade8 100644
--- a/src/REL/m401Dll/m401Dll.h
+++ b/src/REL/m401Dll/m401Dll.h
@@ -1,6 +1,7 @@
 #include "common.h"
 #include "REL/executor.h"
 #include <dolphin/mtx.h>
+#include "game/objsub.h"
 
 // global data //
 typedef struct unkStruct18FC10 {
@@ -94,7 +95,6 @@ extern void espBankSet(s16, s16);
 extern void espDrawNoSet(s16, s16);
 extern void WipeCreate(s16, s16, s16);
 extern u8 WipeStatGet(void);
-extern void omGameSysInit(omObjData*);
 extern f32 PSVECNormalize(Vec3f*, Vec3f*);
 
 // local data //
diff --git a/src/REL/w03Dll/mg_item.c b/src/REL/w03Dll/mg_item.c
index eb1ff2a9..3003f53a 100644
--- a/src/REL/w03Dll/mg_item.c
+++ b/src/REL/w03Dll/mg_item.c
@@ -6,6 +6,7 @@
 #include "REL/w03Dll.h"
 #include "game/board/space.h"
 #include "game/object.h"
+#include "game/objsub.h"
 #include "game/board/player.h"
 #include "math.h"
 #include "board_unsplit.h"
@@ -67,7 +68,6 @@ s32 BoardVecDAngleCalcRange(float *value, float min, float range);
 void BoardCameraQuakeSet(s32 duration, float strength);
 s16 MGSeqCreate(s32, ...);
 u8 MGSeqStatGet(s16);
-void omVibrate(s16, s16, s16, s16);
 f32 BoardPlayerRotYGet(s32);
 f32 BoardModelMotionTimeGet(s16);
 s32 BoardVecMinDistCheck(Vec *vec1, Vec *vec2, float min_dist);
diff --git a/src/REL/w03Dll/statue.c b/src/REL/w03Dll/statue.c
index 9b57ecf1..460c807e 100644
--- a/src/REL/w03Dll/statue.c
+++ b/src/REL/w03Dll/statue.c
@@ -10,6 +10,7 @@
 #include "board_unsplit.h"
 #include "game/hsfman.h"
 #include "game/board/main.h"
+#include "game/objsub.h"
 
 void fn_1_1358(void);
 void fn_1_152C(void);
@@ -29,7 +30,6 @@ s32 BoardPlayerMotBlendCheck(s32);
 f32 BoardPlayerRotYGet(s32);
 void BoardConfettiCreate(Point3d*, s16, f32);
 double atan2(double y, double x);
-void omVibrate(s16, s16, s16, s16);
 f32 BoardModelMotionTimeGet(s16);
 
 //DATA
diff --git a/src/game/board/basic_space.c b/src/game/board/basic_space.c
index c51bb88f..165df930 100644
--- a/src/game/board/basic_space.c
+++ b/src/game/board/basic_space.c
@@ -4,6 +4,7 @@
 #include "game/data.h"
 #include "game/flag.h"
 #include "game/object.h"
+#include "game/objsub.h"
 #include "game/gamework_data.h"
 #include "board_unsplit.h"
 #include "math.h"
@@ -35,7 +36,6 @@ static void CoinChgDisappear(omObjData*, coinChg*);
 
 extern void BoardTutorialHookExec(s16, s32);
 extern void BoardCameraViewSet(s32);
-extern void omVibrate(s16, s16, s16, s16);
 extern void BoardPlayerPosGet(s32, Vec*);
 extern void BoardModelPosGet(s16, Vec*);
 extern void BoardPlayerMotionEndWait(s32);
diff --git a/src/game/board/player.c b/src/game/board/player.c
index a2f5f0c3..121cb243 100644
--- a/src/game/board/player.c
+++ b/src/game/board/player.c
@@ -1,7 +1,5 @@
 #include "game/board/player.h"
-
-//// #include "game/objsub.h"
-extern void omVibrate(s16, s16, s16, s16);
+#include "game/objsub.h"
 //// #include "game/board/ui.h"
 extern void BoardStatusHammerShowSet(s32, s32);
 extern void BoardYourTurnExec(s32);
diff --git a/src/game/board/space.c b/src/game/board/space.c
index 5d1d899c..9e6d6ffd 100644
--- a/src/game/board/space.c
+++ b/src/game/board/space.c
@@ -6,12 +6,11 @@
 #include "game/hsfman.h"
 #include "game/data.h"
 #include "game/sprite.h"
+#include "game/objsub.h"
 
 #include "math.h"
 #include "string.h"
 
-extern void omVibrate(s16, s16, s16, s16);
-
 
 extern s16 BoardStarHostMdlGet(void);
 extern void BoardModelPosSetV(s16 model, Vec *pos);
diff --git a/src/game/board/warp.c b/src/game/board/warp.c
index 0aaec5ef..19f8253c 100644
--- a/src/game/board/warp.c
+++ b/src/game/board/warp.c
@@ -4,6 +4,7 @@
 #include "game/wipe.h"
 #include "game/gamework_data.h"
 #include "game/hsfex.h"
+#include "game/objsub.h"
 #include "board_unsplit.h"
 #include "math.h"
 
@@ -14,7 +15,6 @@ static void WarpFall(s32);
 static void WarpImpact(s32);
 
 
-extern void omVibrate(s16, s16, s16, s16);
 extern void BoardCharWheelInit(s32, s32);
 extern void BoardCharWheelSpeedSet(f32);
 extern void BoardCharWheelWait(void);
diff --git a/src/game/objsub.c b/src/game/objsub.c
new file mode 100644
index 00000000..b42cd6de
--- /dev/null
+++ b/src/game/objsub.c
@@ -0,0 +1,1284 @@
+#include "game/objsub.h"
+#include "game/gamework_data.h"
+#include "game/object.h"
+
+MgInfo mgInfoTbl[] = {
+    {
+        9, // ovl
+        0, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170001, // name_mess
+        0x200000, // data_dir
+        0x160000, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160000, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210000, // rules_mess
+        0x210001, // control_mess[0]
+        0, // control_mess[1]
+        0x210003, // advice_mess
+    },
+    {
+        10, // ovl
+        0, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170002, // name_mess
+        0x210000, // data_dir
+        0x160001, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160001, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210004, // rules_mess
+        0x210005, // control_mess[0]
+        0, // control_mess[1]
+        0x210007, // advice_mess
+    },
+    {
+        11, // ovl
+        0, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170003, // name_mess
+        0x220000, // data_dir
+        0x160002, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160002, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210008, // rules_mess
+        0x210009, // control_mess[0]
+        0, // control_mess[1]
+        0x21000B, // advice_mess
+    },
+    {
+        12, // ovl
+        4, // type
+        2, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170004, // name_mess
+        0x230000, // data_dir
+        0x160003, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160003, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x21000C, // rules_mess
+        0x21000D, // control_mess[0]
+        0, // control_mess[1]
+        0x21000F, // advice_mess
+    },
+    {
+        13, // ovl
+        0, // type
+        2, // flag
+        0, // unk_4
+        0, // unk_6
+        0x170005, // name_mess
+        0x240000, // data_dir
+        0x160004, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160004, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210010, // rules_mess
+        0x210011, // control_mess[0]
+        0, // control_mess[1]
+        0x210013, // advice_mess
+    },
+    {
+        14, // ovl
+        0, // type
+        2, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170006, // name_mess
+        0x250000, // data_dir
+        0x160005, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160005, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210014, // rules_mess
+        0x210015, // control_mess[0]
+        0, // control_mess[1]
+        0x210017, // advice_mess
+    },
+    {
+        15, // ovl
+        0, // type
+        3, // flag
+        256, // unk_4
+        0, // unk_6
+        0x170007, // name_mess
+        0x260000, // data_dir
+        0x160006, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160006, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210018, // rules_mess
+        0x210019, // control_mess[0]
+        0, // control_mess[1]
+        0x21001B, // advice_mess
+    },
+    {
+        16, // ovl
+        0, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170008, // name_mess
+        0x270000, // data_dir
+        0x160007, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160007, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x21001C, // rules_mess
+        0x21001D, // control_mess[0]
+        0, // control_mess[1]
+        0x21001F, // advice_mess
+    },
+    {
+        17, // ovl
+        0, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170009, // name_mess
+        0x280000, // data_dir
+        0x160008, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160008, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210020, // rules_mess
+        0x210021, // control_mess[0]
+        0, // control_mess[1]
+        0x210023, // advice_mess
+    },
+    {
+        18, // ovl
+        0, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x17000A, // name_mess
+        0x290000, // data_dir
+        0x160009, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160009, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210024, // rules_mess
+        0x210025, // control_mess[0]
+        0, // control_mess[1]
+        0x210027, // advice_mess
+    },
+    {
+        19, // ovl
+        0, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x17000B, // name_mess
+        0x2A0000, // data_dir
+        0x16000A, // inst_pic
+        0x16000B, // unk_14
+        0x16000C, // unk_18
+        0x16003E, // mg_pic
+        0x16000B, // unk_20
+        0x16000C, // unk_24
+        0x210028, // rules_mess
+        0x210029, // control_mess[0]
+        0, // control_mess[1]
+        0x21002B, // advice_mess
+    },
+    {
+        20, // ovl
+        0, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x17000C, // name_mess
+        0x2B0000, // data_dir
+        0x16000D, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x16000D, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x21002C, // rules_mess
+        0x21002D, // control_mess[0]
+        0, // control_mess[1]
+        0x21002F, // advice_mess
+    },
+    {
+        21, // ovl
+        0, // type
+        2, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x17000D, // name_mess
+        0x2C0000, // data_dir
+        0x16000E, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x16003F, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210030, // rules_mess
+        0x210031, // control_mess[0]
+        0, // control_mess[1]
+        0x210033, // advice_mess
+    },
+    {
+        22, // ovl
+        0, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x17000E, // name_mess
+        0x2D0000, // data_dir
+        0x16000F, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x16000F, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210034, // rules_mess
+        0x210035, // control_mess[0]
+        0, // control_mess[1]
+        0x210037, // advice_mess
+    },
+    {
+        23, // ovl
+        0, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x17000F, // name_mess
+        0x2E0000, // data_dir
+        0x160010, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160010, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210038, // rules_mess
+        0x210039, // control_mess[0]
+        0, // control_mess[1]
+        0x21003B, // advice_mess
+    },
+    {
+        24, // ovl
+        1, // type
+        1, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170010, // name_mess
+        0x2F0000, // data_dir
+        0x160011, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160011, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x21003C, // rules_mess
+        0x21003D, // control_mess[0]
+        0x21003E, // control_mess[1]
+        0x21003F, // advice_mess
+    },
+    {
+        25, // ovl
+        1, // type
+        1, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170011, // name_mess
+        0x300000, // data_dir
+        0x160012, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160012, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210040, // rules_mess
+        0x210041, // control_mess[0]
+        0x210042, // control_mess[1]
+        0x210043, // advice_mess
+    },
+    {
+        26, // ovl
+        1, // type
+        1, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170012, // name_mess
+        0x310000, // data_dir
+        0x160013, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160013, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210044, // rules_mess
+        0x210045, // control_mess[0]
+        0x210046, // control_mess[1]
+        0x210047, // advice_mess
+    },
+    {
+        27, // ovl
+        1, // type
+        1, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170013, // name_mess
+        0x320000, // data_dir
+        0x160014, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160014, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210048, // rules_mess
+        0x210049, // control_mess[0]
+        0x21004A, // control_mess[1]
+        0x21004B, // advice_mess
+    },
+    {
+        28, // ovl
+        1, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170014, // name_mess
+        0x330000, // data_dir
+        0x160015, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160015, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x21004C, // rules_mess
+        0x21004D, // control_mess[0]
+        0x21004E, // control_mess[1]
+        0x21004F, // advice_mess
+    },
+    {
+        29, // ovl
+        1, // type
+        1, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170015, // name_mess
+        0x340000, // data_dir
+        0x160016, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160016, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210050, // rules_mess
+        0x210051, // control_mess[0]
+        0x210052, // control_mess[1]
+        0x210053, // advice_mess
+    },
+    {
+        30, // ovl
+        1, // type
+        1, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170016, // name_mess
+        0x350000, // data_dir
+        0x160017, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160017, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210054, // rules_mess
+        0x210055, // control_mess[0]
+        0x210056, // control_mess[1]
+        0x210057, // advice_mess
+    },
+    {
+        31, // ovl
+        1, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170017, // name_mess
+        0x360000, // data_dir
+        0x160018, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160018, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210058, // rules_mess
+        0x210059, // control_mess[0]
+        0x21005A, // control_mess[1]
+        0x21005B, // advice_mess
+    },
+    {
+        32, // ovl
+        1, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170018, // name_mess
+        0x370000, // data_dir
+        0x160019, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160019, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x21005C, // rules_mess
+        0x21005D, // control_mess[0]
+        0x21005E, // control_mess[1]
+        0x21005F, // advice_mess
+    },
+    {
+        33, // ovl
+        2, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170019, // name_mess
+        0x380000, // data_dir
+        0x16001A, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x16001A, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210060, // rules_mess
+        0x210061, // control_mess[0]
+        0, // control_mess[1]
+        0x210063, // advice_mess
+    },
+    {
+        34, // ovl
+        2, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x17001A, // name_mess
+        0x390000, // data_dir
+        0x16001B, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x16001B, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210064, // rules_mess
+        0x210065, // control_mess[0]
+        0, // control_mess[1]
+        0x210067, // advice_mess
+    },
+    {
+        35, // ovl
+        2, // type
+        2, // flag
+        512, // unk_4
+        0, // unk_6
+        0x17001B, // name_mess
+        0x3A0000, // data_dir
+        0x16001C, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x16001C, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210068, // rules_mess
+        0x210069, // control_mess[0]
+        0, // control_mess[1]
+        0x21006B, // advice_mess
+    },
+    {
+        36, // ovl
+        2, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x17001C, // name_mess
+        0x3B0000, // data_dir
+        0x16001D, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x16001D, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x21006C, // rules_mess
+        0x21006D, // control_mess[0]
+        0, // control_mess[1]
+        0x21006F, // advice_mess
+    },
+    {
+        37, // ovl
+        2, // type
+        2, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x17001D, // name_mess
+        0x3C0000, // data_dir
+        0x16001E, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160040, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210070, // rules_mess
+        0x210071, // control_mess[0]
+        0, // control_mess[1]
+        0x210073, // advice_mess
+    },
+    {
+        38, // ovl
+        2, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x17001E, // name_mess
+        0x3D0000, // data_dir
+        0x16001F, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x16001F, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210074, // rules_mess
+        0x210075, // control_mess[0]
+        0x210076, // control_mess[1]
+        0x210077, // advice_mess
+    },
+    {
+        39, // ovl
+        2, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x17001F, // name_mess
+        0x3E0000, // data_dir
+        0x160020, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160020, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210078, // rules_mess
+        0x210079, // control_mess[0]
+        0, // control_mess[1]
+        0x21007B, // advice_mess
+    },
+    {
+        40, // ovl
+        2, // type
+        3, // flag
+        768, // unk_4
+        0, // unk_6
+        0x170020, // name_mess
+        0x3F0000, // data_dir
+        0x160021, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160021, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x21007C, // rules_mess
+        0x21007D, // control_mess[0]
+        0x21007E, // control_mess[1]
+        0x21007F, // advice_mess
+    },
+    {
+        41, // ovl
+        7, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170021, // name_mess
+        0x400000, // data_dir
+        0x160022, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160022, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210080, // rules_mess
+        0x37001F, // control_mess[0]
+        0, // control_mess[1]
+        0x210083, // advice_mess
+    },
+    {
+        42, // ovl
+        2, // type
+        2, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170022, // name_mess
+        0x410000, // data_dir
+        0x160023, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160023, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210084, // rules_mess
+        0x210085, // control_mess[0]
+        0, // control_mess[1]
+        0x210087, // advice_mess
+    },
+    {
+        43, // ovl
+        3, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170023, // name_mess
+        0x420000, // data_dir
+        0x160024, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160024, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0, // rules_mess
+        0x210089, // control_mess[0]
+        0, // control_mess[1]
+        0, // advice_mess
+    },
+    {
+        44, // ovl
+        3, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170024, // name_mess
+        0x430000, // data_dir
+        0x160025, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160025, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0, // rules_mess
+        0x21008D, // control_mess[0]
+        0, // control_mess[1]
+        0, // advice_mess
+    },
+    {
+        45, // ovl
+        3, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170025, // name_mess
+        0x440000, // data_dir
+        0x160026, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160026, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0, // rules_mess
+        0x210091, // control_mess[0]
+        0, // control_mess[1]
+        0, // advice_mess
+    },
+    {
+        46, // ovl
+        4, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170026, // name_mess
+        0x450000, // data_dir
+        0x160027, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160027, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210094, // rules_mess
+        0x210095, // control_mess[0]
+        0, // control_mess[1]
+        0x210097, // advice_mess
+    },
+    {
+        47, // ovl
+        4, // type
+        2, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170027, // name_mess
+        0x460000, // data_dir
+        0x160028, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160028, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x210098, // rules_mess
+        0x210099, // control_mess[0]
+        0, // control_mess[1]
+        0x21009B, // advice_mess
+    },
+    {
+        48, // ovl
+        4, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170028, // name_mess
+        0x470000, // data_dir
+        0x160029, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160029, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x21009C, // rules_mess
+        0x21009D, // control_mess[0]
+        0, // control_mess[1]
+        0x21009F, // advice_mess
+    },
+    {
+        49, // ovl
+        4, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170029, // name_mess
+        0x480000, // data_dir
+        0x16002A, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x16002A, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x2100A0, // rules_mess
+        0x2100A1, // control_mess[0]
+        0, // control_mess[1]
+        0x2100A3, // advice_mess
+    },
+    {
+        50, // ovl
+        7, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x17002A, // name_mess
+        0x490000, // data_dir
+        0x16002B, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160041, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x2100A4, // rules_mess
+        0x370010, // control_mess[0]
+        0, // control_mess[1]
+        0x2100A7, // advice_mess
+    },
+    {
+        51, // ovl
+        0, // type
+        2, // flag
+        1280, // unk_4
+        0, // unk_6
+        0x17002B, // name_mess
+        0x4A0000, // data_dir
+        0x16002C, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x16002C, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x2100A8, // rules_mess
+        0x2100A9, // control_mess[0]
+        0, // control_mess[1]
+        0x2100AB, // advice_mess
+    },
+    {
+        52, // ovl
+        5, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x17002C, // name_mess
+        0x4B0000, // data_dir
+        0x16002D, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x16002D, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0, // rules_mess
+        0, // control_mess[0]
+        0, // control_mess[1]
+        0, // advice_mess
+    },
+    {
+        53, // ovl
+        6, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x17002D, // name_mess
+        0x4C0000, // data_dir
+        0x16002E, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x16002E, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x2100AC, // rules_mess
+        0x2100AD, // control_mess[0]
+        0, // control_mess[1]
+        0x2100AF, // advice_mess
+    },
+    {
+        54, // ovl
+        6, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x17002E, // name_mess
+        0x4D0000, // data_dir
+        0x16002F, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x16002F, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x2100B0, // rules_mess
+        0x2100B1, // control_mess[0]
+        0, // control_mess[1]
+        0x2100B3, // advice_mess
+    },
+    {
+        55, // ovl
+        6, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x17002F, // name_mess
+        0x4E0000, // data_dir
+        0x160030, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160030, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x2100B4, // rules_mess
+        0x2100B5, // control_mess[0]
+        0, // control_mess[1]
+        0x2100B7, // advice_mess
+    },
+    {
+        56, // ovl
+        6, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170030, // name_mess
+        0x4F0000, // data_dir
+        0x160031, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160031, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x2100B8, // rules_mess
+        0x2100B9, // control_mess[0]
+        0, // control_mess[1]
+        0x2100BB, // advice_mess
+    },
+    {
+        57, // ovl
+        6, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170031, // name_mess
+        0x500000, // data_dir
+        0x160032, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160032, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x2100BC, // rules_mess
+        0x2100BD, // control_mess[0]
+        0, // control_mess[1]
+        0x2100BF, // advice_mess
+    },
+    {
+        58, // ovl
+        8, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170032, // name_mess
+        0x510000, // data_dir
+        0x160033, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160033, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x2100C0, // rules_mess
+        0x2100C1, // control_mess[0]
+        0, // control_mess[1]
+        0x2100C3, // advice_mess
+    },
+    {
+        59, // ovl
+        7, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170033, // name_mess
+        0x520000, // data_dir
+        0x160034, // inst_pic
+        0x160035, // unk_14
+        0x160036, // unk_18
+        0x160034, // mg_pic
+        0x160035, // unk_20
+        0x160036, // unk_24
+        0x2100C4, // rules_mess
+        0x37000D, // control_mess[0]
+        0, // control_mess[1]
+        0x2100C7, // advice_mess
+    },
+    {
+        58, // ovl
+        7, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170033, // name_mess
+        0x510000, // data_dir
+        0x160037, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160037, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0, // rules_mess
+        0, // control_mess[0]
+        0, // control_mess[1]
+        0, // advice_mess
+    },
+    {
+        60, // ovl
+        7, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170034, // name_mess
+        0x510000, // data_dir
+        0x160032, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160032, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x2100C8, // rules_mess
+        0x37000A, // control_mess[0]
+        0, // control_mess[1]
+        0x2100CB, // advice_mess
+    },
+    {
+        58, // ovl
+        7, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170033, // name_mess
+        0x510000, // data_dir
+        0x160037, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160037, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0, // rules_mess
+        0, // control_mess[0]
+        0, // control_mess[1]
+        0, // advice_mess
+    },
+    {
+        61, // ovl
+        4, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170035, // name_mess
+        0x540000, // data_dir
+        0x160038, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160038, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x2100CC, // rules_mess
+        0x2100CD, // control_mess[0]
+        0, // control_mess[1]
+        0x2100CF, // advice_mess
+    },
+    {
+        62, // ovl
+        0, // type
+        3, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170036, // name_mess
+        0x550000, // data_dir
+        0x160039, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160039, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0x2100D0, // rules_mess
+        0x2100D1, // control_mess[0]
+        0, // control_mess[1]
+        0x2100D3, // advice_mess
+    },
+    {
+        63, // ovl
+        8, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170037, // name_mess
+        0x560000, // data_dir
+        0x16003A, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x16003A, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0, // rules_mess
+        0, // control_mess[0]
+        0, // control_mess[1]
+        0, // advice_mess
+    },
+    {
+        64, // ovl
+        8, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170038, // name_mess
+        0x570000, // data_dir
+        0x16003B, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x16003B, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0, // rules_mess
+        0, // control_mess[0]
+        0, // control_mess[1]
+        0, // advice_mess
+    },
+    {
+        65, // ovl
+        7, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170038, // name_mess
+        0x570000, // data_dir
+        0x160032, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160032, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0, // rules_mess
+        0x370013, // control_mess[0]
+        0, // control_mess[1]
+        0, // advice_mess
+    },
+    {
+        66, // ovl
+        7, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170038, // name_mess
+        0x570000, // data_dir
+        0x160032, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160032, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0, // rules_mess
+        0x370016, // control_mess[0]
+        0, // control_mess[1]
+        0, // advice_mess
+    },
+    {
+        67, // ovl
+        7, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170038, // name_mess
+        0x570000, // data_dir
+        0x160032, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160032, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0, // rules_mess
+        0x370019, // control_mess[0]
+        0, // control_mess[1]
+        0, // advice_mess
+    },
+    {
+        68, // ovl
+        7, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170038, // name_mess
+        0x570000, // data_dir
+        0x160032, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160032, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0, // rules_mess
+        0x37001C, // control_mess[0]
+        0, // control_mess[1]
+        0, // advice_mess
+    },
+    {
+        69, // ovl
+        7, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0x170038, // name_mess
+        0x570000, // data_dir
+        0x160032, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0x160032, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0, // rules_mess
+        0x370007, // control_mess[0]
+        0, // control_mess[1]
+        0, // advice_mess
+    },
+    {
+        65535, // ovl
+        0, // type
+        0, // flag
+        65280, // unk_4
+        0, // unk_6
+        0, // name_mess
+        0, // data_dir
+        0, // inst_pic
+        0, // unk_14
+        0, // unk_18
+        0, // mg_pic
+        0, // unk_20
+        0, // unk_24
+        0, // rules_mess
+        0, // control_mess[0]
+        0, // control_mess[1]
+        0, // advice_mess
+    },
+};
+
+void MGSeqPracticeExitCheck(omObjData*);
+
+s64 lbl_801D3EA0;
+s64 lbl_801D3E98;
+s32 lbl_801D3E94;
+s32 lbl_801D3E90;
+s32 lbl_801D3E8C;
+s32 lbl_801D3E88;
+s32 lbl_801D3E84;
+s32 lbl_801D3E80;
+
+u8 lbl_801983F8[0x18];
+u8 lbl_801982F8[0x100];
+u8 GWGameStatBackup[0x118];
+
+s16 omGetMGIndex(s16 overlay) {
+    s32 i;
+    MgInfo* current_info;
+
+    current_info = (MgInfo*)&mgInfoTbl;
+    
+    for (i = 0; current_info->ovl != 0xffff; i++) {
+        if (current_info->ovl == overlay) {
+            return i;
+        }
+        
+        current_info++;
+    }
+
+    return -1;
+}
+
+void omGameSysInit(Process* process) {
+    s32 i;
+    omObjData* obj;
+
+    omSystemKeyCheckSetup(process);
+    Hu3DCameraScissorSet(1, 0, 0, 0x280, 0x1E0);
+    omSysPauseEnable(0);
+    
+    for (i = 0; i < 4; i++) {
+        if (_CheckFlag(0x1000C) == 0) {
+            GWPlayer[i].coins_mg_gain = 0;
+        }
+        
+        GWPlayer[i].unk_26 = 0;
+    }
+    
+    if (lbl_801D3E88 != 0) {
+        obj = omAddObjEx(process, 0x7FDC, 0, 0, -1, MGSeqPracticeExitCheck);
+        omSetStatBit(obj, 0xA0U);
+    }
+}
+
+void omVibrate(s16 player_cfg_index, s16 duration, s16 off, s16 on) {
+    s32 rumble = GWGameStat.rumble;
+    
+    if (rumble != 0 && GWPlayerCfg[player_cfg_index].iscom == 0) {
+        HuPadRumbleSet(GWPlayerCfg[player_cfg_index].pad_idx, duration, off, on);
+    }
+}

From 8a91c4bc79e8ace698f52d3dc74662d0146fc5d8 Mon Sep 17 00:00:00 2001
From: gamemasterplc <gamemasterplc@gmail.com>
Date: Sat, 27 Jan 2024 20:26:04 -0600
Subject: [PATCH 05/15] Label variables in objsub.c

Also improved variable names
---
 config/GMPE01_00/symbols.txt | 23 +++++++++--------
 include/game/objsub.h        | 20 ++++++++++++++-
 src/game/objsub.c            | 50 ++++++++++++++++++------------------
 3 files changed, 56 insertions(+), 37 deletions(-)

diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt
index ac3a0cdd..e022b000 100644
--- a/config/GMPE01_00/symbols.txt
+++ b/config/GMPE01_00/symbols.txt
@@ -5556,9 +5556,9 @@ SimpleControl = .bss:0x80197AC0; // type:object size:0x19C
 SoundBuffer = .bss:0x80197C60; // type:object size:0x500 scope:local align:32
 WorkBuffer = .bss:0x80198160; // type:object size:0x40 scope:local align:32
 THPFileName = .bss:0x801981A0; // type:object size:0x40 scope:local
-GWGameStatBackup = .bss:0x801981E0; // type:object size:0x118
-lbl_801982F8 = .bss:0x801982F8; // type:object size:0x100
-lbl_801983F8 = .bss:0x801983F8; // type:object size:0x18
+mgGameStatBackup = .bss:0x801981E0; // type:object size:0x118
+mgIndexList = .bss:0x801982F8; // type:object size:0x100
+mgTicTacToeGrid = .bss:0x801983F8; // type:object size:0x12
 _Sys_Flag = .bss:0x80198410; // type:object size:0x10
 curFileInfo = .bss:0x80198420; // type:object size:0x20
 saveBuf = .bss:0x80198440; // type:object size:0x4000 align:32
@@ -6310,14 +6310,15 @@ decodeThread = .sbss:0x801D3E68; // type:object size:0x4 scope:local data:4byte
 decodeStackP = .sbss:0x801D3E6C; // type:object size:0x4 scope:local data:4byte
 decodeRate = .sbss:0x801D3E70; // type:object size:0x4 scope:local data:4byte
 audioTrack = .sbss:0x801D3E74; // type:object size:0x8 scope:local data:4byte
-lbl_801D3E80 = .sbss:0x801D3E80; // type:object size:0x4
-lbl_801D3E84 = .sbss:0x801D3E84; // type:object size:0x4
-lbl_801D3E88 = .sbss:0x801D3E88; // type:object size:0x4 data:4byte
-lbl_801D3E8C = .sbss:0x801D3E8C; // type:object size:0x4 data:4byte
-lbl_801D3E90 = .sbss:0x801D3E90; // type:object size:0x4
-lbl_801D3E94 = .sbss:0x801D3E94; // type:object size:0x4
-lbl_801D3E98 = .sbss:0x801D3E98; // type:object size:0x8
-lbl_801D3EA0 = .sbss:0x801D3EA0; // type:object size:0x8
+mgBoardHostEnableF = .sbss:0x801D3E80; // type:object size:0x1
+mgInstExitEnableF = .sbss:0x801D3E84; // type:object size:0x4
+mgPracticeEnableF = .sbss:0x801D3E88; // type:object size:0x4 data:4byte
+mgQuitExtraF = .sbss:0x801D3E8C; // type:object size:0x4 data:4byte
+mgRecordExtra = .sbss:0x801D3E90; // type:object size:0x4
+lbl_801D3E94 = .sbss:0x801D3E94; // type:object size:0x1
+mgBattleStarMax = .sbss:0x801D3E96; // type:object size:0x2
+mgBattleStar = .sbss:0x801D3E98; // type:object size:0x8
+mgTypeCurr = .sbss:0x801D3EA0; // type:object size:0x2 data:2byte
 curSlotNo = .sbss:0x801D3EA8; // type:object size:0x2 data:2byte
 curBoxNo = .sbss:0x801D3EAA; // type:object size:0x1 data:byte
 saveExecF = .sbss:0x801D3EAC; // type:object size:0x4
diff --git a/include/game/objsub.h b/include/game/objsub.h
index efbbfbdd..018515a6 100644
--- a/include/game/objsub.h
+++ b/include/game/objsub.h
@@ -3,6 +3,7 @@
 
 #include "dolphin.h"
 #include "game/process.h"
+#include "game/gamework_data.h"
 
 typedef struct mg_info {
     u16 ovl;
@@ -24,7 +25,24 @@ typedef struct mg_info {
 } MgInfo;
 
 s16 omGetMGIndex(s16 overlay);
-void omGameSysInit(Process* process);
+void omGameSysInit(Process *objman);
 void omVibrate(s16 player_cfg_index, s16 duration, s16 off, s16 on);
 
+
+extern s16 mgTypeCurr;
+extern s16 mgBattleStar[4];
+extern s16 mgBattleStarMax;
+extern u8 lbl_801D3E94;
+extern s32 mgRecordExtra;
+extern s32 mgQuitExtraF;
+extern s32 mgPracticeEnableF;
+extern s32 mgInstExitEnableF;
+extern u8 mgBoardHostEnableF;
+
+extern s16 mgTicTacToeGrid[3][3];
+extern u8 mgIndexList[256];
+extern GameStat mgGameStatBackup;
+
+extern MgInfo mgInfoTbl[];
+
 #endif
diff --git a/src/game/objsub.c b/src/game/objsub.c
index b42cd6de..608bc4de 100644
--- a/src/game/objsub.c
+++ b/src/game/objsub.c
@@ -1201,7 +1201,7 @@ MgInfo mgInfoTbl[] = {
         0, // advice_mess
     },
     {
-        65535, // ovl
+        0xFFFF, // ovl
         0, // type
         0, // flag
         65280, // unk_4
@@ -1223,41 +1223,41 @@ MgInfo mgInfoTbl[] = {
 
 void MGSeqPracticeExitCheck(omObjData*);
 
-s64 lbl_801D3EA0;
-s64 lbl_801D3E98;
-s32 lbl_801D3E94;
-s32 lbl_801D3E90;
-s32 lbl_801D3E8C;
-s32 lbl_801D3E88;
-s32 lbl_801D3E84;
-s32 lbl_801D3E80;
+s16 mgTypeCurr;
+s16 mgBattleStar[4];
+s16 mgBattleStarMax;
+u8 lbl_801D3E94;
+s32 mgRecordExtra;
+s32 mgQuitExtraF;
+s32 mgPracticeEnableF;
+s32 mgInstExitEnableF;
+u8 mgBoardHostEnableF;
 
-u8 lbl_801983F8[0x18];
-u8 lbl_801982F8[0x100];
-u8 GWGameStatBackup[0x118];
+s16 mgTicTacToeGrid[3][3];
+u8 mgIndexList[256];
+GameStat mgGameStatBackup;
 
 s16 omGetMGIndex(s16 overlay) {
     s32 i;
-    MgInfo* current_info;
+    MgInfo *info;
 
-    current_info = (MgInfo*)&mgInfoTbl;
+    info = mgInfoTbl;
     
-    for (i = 0; current_info->ovl != 0xffff; i++) {
-        if (current_info->ovl == overlay) {
+    for (i = 0; info->ovl != 0xFFFF; i++) {
+        if (info->ovl == overlay) {
             return i;
         }
-        
-        current_info++;
+        info++;
     }
 
     return -1;
 }
 
-void omGameSysInit(Process* process) {
+void omGameSysInit(Process *objman) {
     s32 i;
     omObjData* obj;
 
-    omSystemKeyCheckSetup(process);
+    omSystemKeyCheckSetup(objman);
     Hu3DCameraScissorSet(1, 0, 0, 0x280, 0x1E0);
     omSysPauseEnable(0);
     
@@ -1269,16 +1269,16 @@ void omGameSysInit(Process* process) {
         GWPlayer[i].unk_26 = 0;
     }
     
-    if (lbl_801D3E88 != 0) {
-        obj = omAddObjEx(process, 0x7FDC, 0, 0, -1, MGSeqPracticeExitCheck);
+    if (mgPracticeEnableF != 0) {
+        obj = omAddObjEx(objman, 0x7FDC, 0, 0, -1, MGSeqPracticeExitCheck);
         omSetStatBit(obj, 0xA0U);
     }
 }
 
-void omVibrate(s16 player_cfg_index, s16 duration, s16 off, s16 on) {
+void omVibrate(s16 player, s16 duration, s16 off, s16 on) {
     s32 rumble = GWGameStat.rumble;
     
-    if (rumble != 0 && GWPlayerCfg[player_cfg_index].iscom == 0) {
-        HuPadRumbleSet(GWPlayerCfg[player_cfg_index].pad_idx, duration, off, on);
+    if (rumble != 0 && GWPlayerCfg[player].iscom == 0) {
+        HuPadRumbleSet(GWPlayerCfg[player].pad_idx, duration, off, on);
     }
 }

From 7593dad2bdb291c82ed048de245351c8cce6fd22 Mon Sep 17 00:00:00 2001
From: gamemasterplc <gamemasterplc@gmail.com>
Date: Sat, 27 Jan 2024 20:26:58 -0600
Subject: [PATCH 06/15] Improve name of omGetMGIndex

---
 config/GMPE01_00/symbols.txt | 2 +-
 src/game/objsub.c            | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt
index e022b000..c220eeb8 100644
--- a/config/GMPE01_00/symbols.txt
+++ b/config/GMPE01_00/symbols.txt
@@ -952,7 +952,7 @@ THPTestProc = .text:0x8005793C; // type:function size:0x27C scope:local
 THPViewFunc = .text:0x80057BB8; // type:function size:0xA4 scope:local
 THPViewSprFunc = .text:0x80057C5C; // type:function size:0x17C scope:local
 THPDecodeFunc = .text:0x80057DD8; // type:function size:0x4C scope:local
-omGetMGIndex = .text:0x80057E24; // type:function size:0x5C
+omMgIndexGet = .text:0x80057E24; // type:function size:0x5C
 omGameSysInit = .text:0x80057E80; // type:function size:0xF4
 omVibrate = .text:0x80057F74; // type:function size:0x9C
 _CheckFlag = .text:0x80058010; // type:function size:0xA0
diff --git a/src/game/objsub.c b/src/game/objsub.c
index 608bc4de..2a4ce6f9 100644
--- a/src/game/objsub.c
+++ b/src/game/objsub.c
@@ -1237,7 +1237,7 @@ s16 mgTicTacToeGrid[3][3];
 u8 mgIndexList[256];
 GameStat mgGameStatBackup;
 
-s16 omGetMGIndex(s16 overlay) {
+s16 omMgIndexGet(s16 overlay) {
     s32 i;
     MgInfo *info;
 

From 9714f393abac33d60125252d4794b18affac4978 Mon Sep 17 00:00:00 2001
From: gamemasterplc <gamemasterplc@gmail.com>
Date: Sat, 27 Jan 2024 20:28:20 -0600
Subject: [PATCH 07/15] Fix header omMgIndexGet Name

---
 include/game/objsub.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/game/objsub.h b/include/game/objsub.h
index 018515a6..5b458d18 100644
--- a/include/game/objsub.h
+++ b/include/game/objsub.h
@@ -24,7 +24,7 @@ typedef struct mg_info {
     u32 advice_mess;
 } MgInfo;
 
-s16 omGetMGIndex(s16 overlay);
+s16 omMgIndexGet(s16 overlay);
 void omGameSysInit(Process *objman);
 void omVibrate(s16 player_cfg_index, s16 duration, s16 off, s16 on);
 

From a25ab62f73336580c6d7dccb9ec4f135aacc3630 Mon Sep 17 00:00:00 2001
From: gamemasterplc <gamemasterplc@gmail.com>
Date: Sun, 28 Jan 2024 09:46:31 -0600
Subject: [PATCH 08/15] Do more work on minigame_seq.c

---
 config/GMPE01_00/symbols.txt |   2 +-
 src/game/minigame_seq.c      | 722 ++++++++++++++++++++++++++++++++---
 2 files changed, 673 insertions(+), 51 deletions(-)

diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt
index c220eeb8..c05a472b 100644
--- a/config/GMPE01_00/symbols.txt
+++ b/config/GMPE01_00/symbols.txt
@@ -5784,7 +5784,7 @@ lbl_801D34B0 = .sdata:0x801D34B0; // type:object size:0x1
 lbl_801D34B1 = .sdata:0x801D34B1; // type:object size:0x7
 mgSeqInitF = .sdata:0x801D34B8; // type:object size:0x4 data:4byte
 wordStartE = .sdata:0x801D34BC; // type:object size:0x7 scope:local data:string
-punctTbl = .sdata:0x801D34C3; // type:object size:0x3 scope:local data:byte
+seqPunctTbl = .sdata:0x801D34C3; // type:object size:0x3 scope:local data:byte
 wordStartJ = .sdata:0x801D34C6; // type:object size:0x6 scope:local
 wordFinishJ = .sdata:0x801D34CC; // type:object size:0x8 scope:local
 wordDrawJ = .sdata:0x801D34D4; // type:object size:0x6 scope:local
diff --git a/src/game/minigame_seq.c b/src/game/minigame_seq.c
index d3ecb1cd..eb60aeb4 100644
--- a/src/game/minigame_seq.c
+++ b/src/game/minigame_seq.c
@@ -2,10 +2,14 @@
 #include "game/sprite.h"
 #include "game/process.h"
 #include "game/gamework_data.h"
+#include "game/objsub.h"
 #include "game/hsfman.h"
+#include "math.h"
 
 #include "stdarg.h"
 
+void MGSeqStub(void);
+
 extern s16 HuSysVWaitGet(s16 param);
 
 typedef struct seq_work SeqWork;
@@ -28,7 +32,7 @@ typedef struct seq_work {
 	s16 work_s16[4];
 	s16 param[2];
 	s16 type;
-	s16 sprite_grp[16];
+	s16 spr_grp[16];
 	s16 sprite[16];
 	u8 seq_no;
 	u8 stat;
@@ -126,51 +130,6 @@ static char lbl_8012F336[] = {
 static char lbl_8012F389[] = "x first\n";
 static char lbl_8012F392[] = "y first\n";
 
-static char seqFontAlphaTbl[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-static char seqFontKanaTbl[] = {
-	0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
-	0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0,
-	0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8,
-	0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0,
-	0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8,
-	0xD9, 0xDA, 0xDB, 0xDC, 0xA6, 0xDD, 0xA7, 0xA8,
-	0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB6,
-	0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE,
-	0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xCA, 0xCB,
-	0xCC, 0xCD, 0xCE, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE,
-	0xB0, 0x00
-};
-
-static char seqFontNumTbl[] = "0123456789";
-
-
-static s32 *letterBufTbl[5] = { };
-
-static char wordStartE[] = "START!";
-
-static char punctTbl[] = "!?";
-
-static char wordStartJ[] = {
-	0xBD, 0xC0, 0xB0, 0xC4, 0x21, 0x00
-};
-
-static char wordFinishJ[] = {
-	0xCC, 0xA8, 0xC6, 0xAF, 0xBC, 0xAD, 0x21, 0x00
-};
-
-static char wordDrawJ[] = {
-	0xCB, 0xB7, 0xDC, 0xB9, 0x21, 0x00
-};
-
-static char wordFinishE[] = "FINISH!";
-static char wordDrawE[] = "DRAW!";
-
-static char *wordMgTbl[6] = {
-	wordStartJ, wordFinishJ, wordDrawJ,
-	wordStartE, wordFinishE, wordDrawE,
-};
-
 static s16 seqMaxTime[8];
 static SeqWork seqWorkData[8];
 
@@ -295,7 +254,7 @@ static s16 CreateSeq(u8 seq_no, va_list params)
 	work->work_float[0] = work->work_float[1] = 0.0f;
 	work->param[0] = work->param[1] = 0;
 	for(temp=0; temp<16; temp++) {
-		work->sprite[temp] = work->sprite_grp[temp] = -1;
+		work->sprite[temp] = work->spr_grp[temp] = -1;
 	}
 	if(NULL != info->init) {
 		temp = info->init(work, params);
@@ -304,8 +263,671 @@ static s16 CreateSeq(u8 seq_no, va_list params)
 			return -1;
 		} 
 	}
-	{
-		seqTimer = 30;
-		return i;
+	seqTimer = 30;
+	return i;
+}
+
+s16 MGSeqCreate(s16 type, ...)
+{
+	s16 ret;
+	va_list params;
+	va_start(params, type);
+	if(type == 3) {
+		if(GWSystem.mg_next == 0xFFFF) {
+			type = 8;
+		} else {
+			type = mgSeqTypeTbl[mgInfoTbl[GWSystem.mg_next].type];
+		}
+	}
+	//FIXME: Fix truncation of type
+	ret = CreateSeq(type, params);
+	va_end(params);
+	return ret;
+}
+
+u8 MGSeqStatGet(s16 id)
+{
+	SeqWork *work;
+	u8 ret = 0;
+	if(id < 0) {
+		int i;
+		work = seqWorkData;
+		for(i=8; i != 0; i--, work++) {
+			ret |= work->stat;
+		}
+	} else {
+		if(id < 8) {
+			ret = seqWorkData[id].stat;
+		}
+	}
+	return ret;
+}
+
+void MGSeqPosSet(s16 id, float x, float y)
+{
+	if(id >= 0 && id < 8) {
+		seqWorkData[id].x = x;
+		seqWorkData[id].y = y;
 	}
 }
+
+void MGSeqParamSet(s16 id, s16 param1, s16 param2)
+{
+	if(id >= 0 && id < 8) {
+		seqWorkData[id].param[0] = param1;
+		seqWorkData[id].param[1] = param2;
+	}
+}
+
+void MGSeqKill(s16 id, s16 param1, s16 param2)
+{
+	if(id >= 0 && id < 8) {
+		if(seqWorkData[id].stat != 0) {
+			seqWorkData[id].stat = 8;
+		}
+	}
+}
+
+void MGSeqKillAll(s16 id, s16 param1, s16 param2)
+{
+	seqDoneF = 1;
+	MGSeqMain();
+	seqDoneF = 0;
+	MGSeqStub();
+	lbl_801D3D94 = 0;
+}
+
+s32 MGSeqDoneCheck(void)
+{
+	u8 stat = MGSeqStatGet(-1);
+	if(stat == 0 || (stat & 0xC)) {
+		if(seqTimer <= 0 || (stat & 0x8)) {
+			return 1;
+		}
+	}
+	return 0;
+}
+
+void MGSeqStub(void)
+{
+	
+}
+
+void MGSeqSprKill(SeqWork *work)
+{
+	int i;
+	for(i=0; i<16; i++) {
+		if(work->spr_grp[i] >= 0) {
+			HuSprGrpKill(work->spr_grp[i]);
+		}
+		if(work->sprite[i] >= 0) {
+			HuSprKill(work->sprite[i]);
+		}
+	}
+}
+
+static void *SeqReadFile(s32 file)
+{
+	return HuAR_ARAMtoMRAMFileRead(file, MEMORY_DEFAULT_NUM, HEAP_DATA);
+}
+
+static int SeqInitTimer(SeqWork *work, va_list params)
+{
+	AnimData *spr_anim;
+	s16 sprite;
+	s16 spr_grp;
+	int duration, x, y;
+	s16 i;
+	
+	duration = va_arg(params, int);
+	x = va_arg(params, int);
+	y = va_arg(params, int);
+	if(duration <= 0 && duration > 99) {
+		duration = 99;
+	}
+	work->work_s16[0] = duration;
+	if(x >= 0) {
+		work->x = x;
+	}
+	if(y >= 0) {
+		work->y = y;
+	}
+	work->work_s16[2] = 0;
+	work->work_s16[1] = 2;
+	work->work_float[0] = 0;
+	work->spr_grp[0] = spr_grp = HuSprGrpCreate(4);
+	HuSprGrpScaleSet(spr_grp, work->scale_x, work->scale_y);
+	spr_anim = HuSprAnimRead(SeqReadFile(MAKE_DATA_NUM(DATADIR_GAMEMES, 2)));
+	x = 12;
+	for(i=0; i<2; i++) {
+		sprite = HuSprCreate(spr_anim, 5, 0);
+		HuSprGrpMemberSet(spr_grp, i, sprite);
+		HuSprSpeedSet(spr_grp, i, 0);
+		HuSprPosSet(spr_grp, i, x, 0);
+		HuSprColorSet(spr_grp, i, 112, 233, 255);
+		x -= 24;
+		(void)i; //Hack for Matching
+	}
+	spr_anim = HuSprAnimRead(SeqReadFile(MAKE_DATA_NUM(DATADIR_GAMEMES, 1)));
+	sprite = HuSprCreate(spr_anim, 7, 0);
+	HuSprGrpMemberSet(spr_grp, 2, sprite);
+	HuSprPosSet(spr_grp, 2, 0, 0);
+	HuSprTPLvlSet(spr_grp, 2, 0.5f);
+	HuSprColorSet(spr_grp, 2, 0, 0, 0);
+	spr_anim = HuSprAnimRead(SeqReadFile(MAKE_DATA_NUM(DATADIR_GAMEMES, 0)));
+	sprite = HuSprCreate(spr_anim, 6, 0);
+	HuSprGrpMemberSet(spr_grp, 3, sprite);
+	HuSprPosSet(spr_grp, 3, 0, 0);
+	if(seqPauseF) {
+		work->work_s16[1] = 1;
+		for(i=0; i<2; i++) {
+			HuSprAttrSet(spr_grp, i, SPRITE_ATTR_HIDDEN);
+			(void)i; //Hack for Matching
+		}		
+	}
+	return 1;
+}
+
+static int SeqUpdateTimer(SeqWork *work)
+{
+	float scale;
+	float tp_lvl;
+	u8 digits[2];
+	s16 i;
+	s16 spr_grp = work->spr_grp[0];
+	if(work->param[0] != 0 && work->work_s16[1] != -1) {
+		switch(work->param[0]) {
+			case 2:
+				switch(work->param[1]) {
+					case -1:
+						work->stat |= 0x4;
+						work->work_s16[1] = -1;
+						work->work_float[0] = 0.0f;
+						break;
+						
+					case 0:
+						work->work_s16[1] = 2;
+						work->work_float[0] = 0.0f;
+						break;
+						
+					case 1:
+						work->work_s16[1] = 3;
+						work->work_float[0] = 0.0f;
+						break;
+						
+					default:
+						break;
+				}
+				work->param[0] = 0;
+				break;
+				
+			case 1:
+				if(work->param[1] < 0 && !(work->stat & 0x4)) {
+					work->stat |= 0x4;
+					work->work_s16[1] = -1;
+					work->work_float[0] = 0.0f;
+				} else {
+					if(work->param[1] > 99) {
+						work->work_s16[0] = 99;
+					} else {
+						if(work->work_s16[0] != work->param[1]) {
+							work->work_s16[0] = work->param[1];
+							if(work->param[1] <= 5) {
+								HuAudFXPlay(6);
+								work->work_s16[1] = 3;
+								work->work_float[0] = 0.0f;
+								HuSprColorSet(spr_grp, 0, 255, 112, 160);
+								HuSprColorSet(spr_grp, 1, 255, 112, 160);
+							} else {
+								HuSprColorSet(spr_grp, 0, 112, 233, 255);
+								HuSprColorSet(spr_grp, 1, 112, 233, 255);
+							}
+						}
+					}
+				}
+				work->param[0] = 0;
+				break;
+				
+			case 3:
+				for(i=0; i<2; i++) {
+					HuSprAttrReset(spr_grp, i, SPRITE_ATTR_HIDDEN);
+				}
+				work->work_s16[1] = 3;
+				work->param[0] = 0;
+				break;
+				
+			default:
+				work->param[0] = 0;
+				break;
+		}
+	}
+	if(work->work_s16[1] == 1) {
+		return 1;
+	}
+	if(work->work_s16[0] > 99) {
+		digits[0] = digits[1] = 9;
+	} else {
+		s32 value;
+		value = work->work_s16[0]/10;
+		digits[1] = value;
+		digits[0] = work->work_s16[0]-(value*10);
+	}
+	HuSprGrpPosSet(spr_grp, work->x, work->y);
+	HuSprGrpScaleSet(spr_grp, work->scale_x, work->scale_y);
+	for(i=0; i<2; i++) {
+		HuSprBankSet(spr_grp, i, digits[i]);
+	}
+	if(work->work_s16[1] != 0) {
+		switch(work->work_s16[1]) {
+			case 2:
+			{
+				float scale_x, scale_y;
+				scale = fabs(((sin((work->work_float[0]*M_PI)/180)*5.0f)+1.0f)-(sin((130*M_PI)/180)*5.0f));
+				scale_x = work->scale_x*scale;
+				scale_y = work->scale_y*scale;
+				work->work_float[0] += seqSpeed*5.0f;
+				if(work->work_float[0] > 130.0f) {
+					work->work_s16[1] = 0;
+					break;
+				}
+				HuSprGrpScaleSet(spr_grp, scale_x, scale_y);
+			}
+				break;
+				
+			case 3:
+			{
+				scale = sin((work->work_float[0]*M_PI)/180)+1.0;
+				tp_lvl = 1.0-(sin((work->work_float[0]*M_PI)/180)*0.5);
+				work->work_float[0] += seqSpeed*18.0f;
+				if(work->work_float[0] > 180.0f) {
+					work->work_s16[1] = 0;
+					scale = 1.0f;
+					tp_lvl = 1.0f;
+				}
+				for(i=0; i<2; i++) {
+					HuSprScaleSet(spr_grp, i, scale, scale);
+					HuSprTPLvlSet(spr_grp, i, tp_lvl);
+				}
+			}
+				break;
+				
+			case -1:
+				HuSprGrpScaleSet(spr_grp, work->scale_x, work->scale_y);
+				for(i=0; i<2; i++) {
+					HuSprScaleSet(spr_grp, i, 1.0f, 1.0f);
+				}
+				work->work_float[0] += 1.0f;
+				if(work->work_float[0] < 60.0f) {
+					break;
+				}
+				tp_lvl = 1.0-((work->work_float[0]-60.0f)/20.0f);
+				if(tp_lvl <= 0.0f) {
+					tp_lvl = 0.0f;
+					work->work_s16[1] = 0;
+					work->stat |= 0x8;
+				}
+				
+				for(i=0; i<4; i++) {
+					HuSprTPLvlSet(spr_grp, i, tp_lvl);
+				}
+				break;
+				
+			default:
+				break;
+		}
+	}
+	if(seqDoneF || (work->stat & 0x8)) {
+		MGSeqSprKill(work);
+		return 0;
+	} else {
+		return 1;
+	}
+}
+
+static int SeqInitType2(SeqWork *work, va_list params)
+{
+	s16 spr_idx;
+	s16 spr_grp;
+	AnimData *anim_tbl[6];
+	s32 i;
+	s16 len;
+	char *str;
+	char c;
+	int time_max;
+	int x, y;
+	work->data = va_arg(params, void *);
+	time_max = va_arg(params, int);
+	x = va_arg(params, int);
+	y = va_arg(params, int);
+	if(time_max < 0) {
+		time_max = -1;
+	}
+	work->time_max = time_max;
+	if(x >= 0) {
+		work->x = x;
+	}
+	if(y >= 0) {
+		work->y = y;
+	}
+	work->work_s16[1] = 0;
+	work->work_float[0] = 0.0f;
+	x = 0;
+	len = 0;
+	str=work->data;
+	while(c=*str++) {
+		if(c >= '0' && c <= '9') {
+			x |= 1;
+			len++;
+		} else if(c >= 'A' && c <= 'Z') {
+			x |= 2;
+			len++;
+		} else if(c >= 'a' && c <= 'z') {
+			x |= 4;
+			len++;
+		} else if(c == '!' || c == '?') {
+			x |= 8;
+			len++;
+		}
+	}
+	work->work_s16[3] = len;
+	for(i=0; i<6; i++) {
+		if(x & (1 << i)) {
+			anim_tbl[i] = HuSprAnimRead(SeqReadFile(seqType2SprTbl[i]));
+		} else {
+			anim_tbl[i] = NULL;
+		}
+	}
+	work->spr_grp[0] = spr_grp = HuSprGrpCreate(len);
+	x = 0;
+	spr_idx = 0;
+	str=work->data;
+	while(c=*str++) {
+		i = -2;
+		if(c >= '0' && c <= '9') {
+			c -= '0';
+			i = 0;
+		} else if(c >= 'A' && c <= 'Z') {
+			c -= 'A';
+			i = 1;
+		} else if(c >= 'a' && c <= 'z') {
+			c -= 'a';
+			i = 2;
+		} else if(c == '!' || c == '?') {
+			if(c == '!') {
+				c = 0;
+			} else {
+				c = 1;
+			}
+			i = 3;
+		} else if(c == ' ') {
+			i = -1;
+		}
+		work->work_s16[2] = x;
+		if(i == -1) {
+			x += 32;
+		} else if(i >= 0) {
+			s16 sprite = HuSprCreate(anim_tbl[i], 5, c);
+			HuSprGrpMemberSet(spr_grp, spr_idx, sprite);
+			HuSprSpeedSet(spr_grp, spr_idx, 0.0f);
+			HuSprPosSet(spr_grp, spr_idx, x, 0.0f);
+			spr_idx++;
+			x += 64;
+		}
+	}
+	if(seqPauseF) {
+		work->work_s16[1] = 1;
+		for(i=0; i<work->work_s16[3]; i++) {
+			HuSprAttrSet(spr_grp, i, SPRITE_ATTR_HIDDEN);
+		}
+	}
+	return 1;
+}
+
+static int SeqUpdateType2(SeqWork *work)
+{
+	float tp_lvl;
+	s16 spr_grp;
+	spr_grp = work->spr_grp[0];
+	HuSprGrpPosSet(spr_grp, work->x-((0.5f*work->scale_x)*work->work_s16[2]), work->y);
+	HuSprGrpScaleSet(spr_grp, work->scale_x, work->scale_y);
+	if(work->param[0] != 0 && work->work_s16[1] != -1) {
+		switch(work->param[0]) {
+			case 2:
+				if(work->param[1] != -1) {
+					(void)work; //HACK: to introduce extra branch
+				} else {
+					work->work_s16[1] = -1;
+					work->work_float[0] = 0.0f;
+				}
+				work->param[0] = 0;
+				break;
+				
+			case 1:
+				work->time_max = work->param[1];
+				work->param[0] = 0;
+				break;
+				
+			case 3:
+			{
+				s32 i;
+				for(i=0; i<work->work_s16[3]; i++) {
+					HuSprAttrReset(spr_grp, i, SPRITE_ATTR_HIDDEN);
+					(void)i;
+				}
+				work->work_s16[1] = 0;
+				work->param[0] = 0;
+			}
+				break;
+				
+			default:
+				work->param[0] = 0;
+				break;
+		}
+	}
+	if(work->work_s16[1] == 1) {
+		return 1;
+	}
+	work->time += seqSpeed;
+	if(work->time >= work->time_max && work->work_s16[1] != -1) {
+		work->stat |= 0x4;
+		work->work_s16[1] = -1;
+		work->work_float[0] = 0.0f;
+	}
+	if(work->work_s16[1] != 0) {
+		if(work->work_s16[1] != -1) {
+			(void)work; //HACK: to introduce extra branch
+		} else {
+			s16 i;
+			work->work_float[0] += seqSpeed*0.1f;
+			tp_lvl = 1.0f-work->work_float[0];
+			if(tp_lvl <= 0.0f) {
+				tp_lvl = 0.0f;
+				work->work_s16[1] = 0;
+				work->stat |= 0x8;
+			}
+			for(i=0; i<work->work_s16[3]; i++) {
+				HuSprTPLvlSet(spr_grp, i, tp_lvl);
+				(void)i;
+			}
+		}
+	}
+	if(seqDoneF || (work->stat & 0x8)) {
+		MGSeqSprKill(work);
+		return 0;
+	} else {
+		return 1;
+	}
+}
+
+
+static char seqFontAlphaTbl[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+static char seqFontKanaTbl[] = {
+	0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
+	0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0,
+	0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8,
+	0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0,
+	0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8,
+	0xD9, 0xDA, 0xDB, 0xDC, 0xA6, 0xDD, 0xA7, 0xA8,
+	0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB6,
+	0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE,
+	0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xCA, 0xCB,
+	0xCC, 0xCD, 0xCE, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE,
+	0xB0, 0x00
+};
+
+static char seqFontNumTbl[] = "0123456789";
+
+static s32 *letterBufTbl[5] = { };
+
+static char wordStartE[] = "START!";
+
+static char seqPunctTbl[] = "!?";
+
+static char wordStartJ[] = {
+	0xBD, 0xC0, 0xB0, 0xC4, 0x21, 0x00
+};
+
+static char wordFinishJ[] = {
+	0xCC, 0xA8, 0xC6, 0xAF, 0xBC, 0xAD, 0x21, 0x00
+};
+
+static char wordDrawJ[] = {
+	0xCB, 0xB7, 0xDC, 0xB9, 0x21, 0x00
+};
+
+static char wordFinishE[] = "FINISH!";
+static char wordDrawE[] = "DRAW!";
+
+static char *wordMgTbl[6] = {
+	wordStartJ, wordFinishJ, wordDrawJ,
+	wordStartE, wordFinishE, wordDrawE,
+};
+
+void fn_80036BC8(void)
+{
+	if(!letterBufTbl[0]) {
+		letterBufTbl[0] = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s32)*strlen(seqFontAlphaTbl));
+		memset(letterBufTbl[0], 0, sizeof(s32)*strlen(seqFontAlphaTbl));
+	}
+	if(!letterBufTbl[1]) {
+		letterBufTbl[1] = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s32)*strlen(seqFontKanaTbl));
+		memset(letterBufTbl[1], 0, sizeof(s32)*strlen(seqFontKanaTbl));
+	}
+	if(!letterBufTbl[2]) {
+		letterBufTbl[2] = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s32)*strlen(seqFontKanaTbl));
+		memset(letterBufTbl[2], 0, sizeof(s32)*strlen(seqFontKanaTbl));
+	}
+	if(!letterBufTbl[3]) {
+		letterBufTbl[3] = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s32)*strlen(seqFontNumTbl));
+		memset(letterBufTbl[3], 0, sizeof(s32)*strlen(seqFontNumTbl));
+	}
+	if(!letterBufTbl[4]) {
+		letterBufTbl[4] = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s32)*strlen(seqPunctTbl));
+		memset(letterBufTbl[4], 0, sizeof(s32)*strlen(seqPunctTbl));
+	}
+}
+
+static AnimData *SeqLoadFontChar(char *str, s16 flags);
+
+static s32 SeqMakeWord(SeqWork *work, char *str, s16 flags)
+{
+	s16 *char_pos;
+	char *str_ptr;
+	s16 spr_grp;
+	s16 i;
+	s16 x;
+	s16 grp_idx;
+	s16 len;
+	AnimData **char_anim;
+	for(grp_idx=0; grp_idx<16; grp_idx++) {
+		if(work->spr_grp[grp_idx] == -1) {
+			break;
+		}
+	}
+	if(grp_idx == 16) {
+		return -1;
+	}
+	char_anim = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(AnimData *)*100);
+	char_pos = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s16)*100);
+	str_ptr = str;
+	x = 0;
+	len = 0;
+	while(*str_ptr != 0) {
+		char_anim[len] = SeqLoadFontChar(str_ptr, flags);
+		if(char_anim[len]) {
+			char_pos[len] = x;
+			x += 56;
+			len++;
+		}
+		str_ptr++;
+	}
+	work->spr_grp[grp_idx] = spr_grp = HuSprGrpCreate(len);
+	x = (x/2)-28;
+	for(i=0; i<len; i++) {
+		s16 sprite = HuSprCreate(char_anim[i], 5, 0);
+		HuSprGrpMemberSet(spr_grp, i, sprite);
+		HuSprPosSet(spr_grp, i, char_pos[i]-x, 0.0f);
+	}
+	work->work_s16[3] = len;
+	HuMemDirectFree(char_anim);
+	HuMemDirectFree(char_pos);
+	return grp_idx;
+}
+
+static AnimData *SeqLoadFontChar(char *str, s16 flags)
+{
+	s32 data_num;
+	s16 id;
+	char *list;
+	char c = *str;
+	if(c == 222 || c == 223) {
+		return NULL;
+	}
+	if(c == 32) {
+		return HuSprAnimRead(SeqReadFile(MAKE_DATA_NUM(DATADIR_GAMEMES, 10)));
+	}
+	for(id = 0, list=seqFontAlphaTbl; *list != 0; id++, list++) {
+		if(*list == c) {
+			data_num = MAKE_DATA_NUM(DATADIR_GAMEMES, id+21);
+			return HuSprAnimRead(SeqReadFile(data_num));
+		}
+	}
+	for(id = 0, list=seqFontNumTbl; *list != 0; id++, list++) {
+		if(*list == c) {
+			data_num = MAKE_DATA_NUM(DATADIR_GAMEMES, id+11);
+			return HuSprAnimRead(SeqReadFile(data_num));
+		}
+	}
+	for(id = 0, list=seqPunctTbl; *list != 0; id++, list++) {
+		if(*list == c) {
+			data_num = MAKE_DATA_NUM(DATADIR_GAMEMES, id+154);
+			return HuSprAnimRead(SeqReadFile(data_num));
+		}
+	}
+	if(str[1] == 222) {
+		list = seqFontKanaTbl;
+		list += 55;
+		id = 55;
+	} else if(str[1] == 223) {
+		list = seqFontKanaTbl;
+		list += 75;
+		id = 75;
+	} else {
+		list = seqFontKanaTbl;
+		id = 0;
+	}
+	while(*list != 0) {
+		if(*list == c) {
+			if(flags & 0x1) {
+				data_num = MAKE_DATA_NUM(DATADIR_GAMEMES, id+156);
+			} else {
+				data_num = MAKE_DATA_NUM(DATADIR_GAMEMES, id+73);
+			}
+			return HuSprAnimRead(SeqReadFile(data_num));
+		}
+		id++;
+		list++;
+	}
+	return NULL;
+}
\ No newline at end of file

From 929378e263086f4f065585294e0d098861f61019 Mon Sep 17 00:00:00 2001
From: gamemasterplc <gamemasterplc@gmail.com>
Date: Sun, 28 Jan 2024 09:53:39 -0600
Subject: [PATCH 09/15] Reformat Some minigame_seq variables

seqFontAlphaTbl, seqFontNumTbl, and seqPunctTbl are no longer string literals
---
 src/game/minigame_seq.c | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/src/game/minigame_seq.c b/src/game/minigame_seq.c
index eb60aeb4..42bf3c44 100644
--- a/src/game/minigame_seq.c
+++ b/src/game/minigame_seq.c
@@ -760,7 +760,15 @@ static int SeqUpdateType2(SeqWork *work)
 }
 
 
-static char seqFontAlphaTbl[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+static char seqFontAlphaTbl[] = {
+	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+	'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+	'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+	'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+	'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+	'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+	'w', 'x', 'y', 'z', '\0'
+};
 
 static char seqFontKanaTbl[] = {
 	0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
@@ -776,13 +784,18 @@ static char seqFontKanaTbl[] = {
 	0xB0, 0x00
 };
 
-static char seqFontNumTbl[] = "0123456789";
+static char seqFontNumTbl[] = {
+	'0', '1', '2', '3', '4', '5', '6', '7',
+	'8', '9', '\0'
+};
 
 static s32 *letterBufTbl[5] = { };
 
 static char wordStartE[] = "START!";
 
-static char seqPunctTbl[] = "!?";
+static char seqPunctTbl[] = {
+	'!', '?', '\0'
+};
 
 static char wordStartJ[] = {
 	0xBD, 0xC0, 0xB0, 0xC4, 0x21, 0x00

From 43e77ce66829c00c5fdd6f02f40b5a658a249106 Mon Sep 17 00:00:00 2001
From: gamemasterplc <gamemasterplc@gmail.com>
Date: Sun, 28 Jan 2024 14:31:50 -0600
Subject: [PATCH 10/15] Decompile to SeqInitMGCommon

---
 config/GMPE01_00/symbols.txt |   4 +-
 include/game/sprite.h        |   2 +-
 src/REL/bootDll/main.c       |   4 +-
 src/game/board/main.c        |   2 +-
 src/game/minigame_seq.c      | 317 +++++++++++++++++++++++++++++++++++
 src/game/sprman.c            |   2 +-
 src/game/sprput.c            |   2 +-
 7 files changed, 325 insertions(+), 8 deletions(-)

diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt
index c05a472b..e3a05fe0 100644
--- a/config/GMPE01_00/symbols.txt
+++ b/config/GMPE01_00/symbols.txt
@@ -695,7 +695,7 @@ MGSeqPauseKill = .text:0x8003F360; // type:function size:0xC
 MGSeqPauseEnableCtrl = .text:0x8003F36C; // type:function size:0x40
 MGSeqPracticeInit = .text:0x8003F3AC; // type:function size:0xDC
 PracticeProc = .text:0x8003F488; // type:function size:0x234 scope:local
-SeqSEPlay = .text:0x8003F6BC; // type:function size:0xD4 scope:local
+SeqPlayStartFX = .text:0x8003F6BC; // type:function size:0xD4 scope:local
 MGSeqPracticeExitCheck = .text:0x8003F790; // type:function size:0x128
 espInit = .text:0x8003F8B8; // type:function size:0xA0
 espEntry = .text:0x8003F958; // type:function size:0x1B0
@@ -4953,7 +4953,7 @@ winWordTbl = .data:0x8012F580; // type:object size:0x18 scope:local
 winPosOfs = .data:0x8012F598; // type:object size:0x50 scope:local
 practiceTbl = .data:0x8012F5E8; // type:object size:0xAC scope:local
 practicePosYTbl = .data:0x8012F694; // type:object size:0xC scope:local
-seqFXTbl = .data:0x8012F6A0; // type:object size:0xF0 scope:local
+seqStartFXTbl = .data:0x8012F6A0; // type:object size:0xF0 scope:local
 lbl_8012F790 = .data:0x8012F790; // type:object size:0x15 data:string
 lbl_8012F7A5 = .data:0x8012F7A5; // type:object size:0x10 data:string
 lbl_8012F7B5 = .data:0x8012F7B5; // type:object size:0x13 data:string
diff --git a/include/game/sprite.h b/include/game/sprite.h
index 9a9d27f8..946bf244 100644
--- a/include/game/sprite.h
+++ b/include/game/sprite.h
@@ -14,7 +14,7 @@
 #define SPRITE_ATTR_PAUSED 0x1
 #define SPRITE_ATTR_LOOP 0x2
 #define SPRITE_ATTR_HIDDEN 0x4
-#define SPIRTE_ATTR_BILINEAR 0x8
+#define SPRITE_ATTR_BILINEAR 0x8
 #define SPRITE_ATTR_FUNC 0x10
 #define SPRITE_ATTR_NOPAUSE 0x20
 #define SPRITE_ATTR_REVERSE 0x40
diff --git a/src/REL/bootDll/main.c b/src/REL/bootDll/main.c
index 88601284..2b445351 100644
--- a/src/REL/bootDll/main.c
+++ b/src/REL/bootDll/main.c
@@ -478,12 +478,12 @@ static void TitleInit(void)
 	sprite_data = HuSprAnimReadFile(MAKE_DATA_NUM(DATADIR_TITLE, 2));
 	sprite = HuSprCreate(sprite_data, 2, 0);
 	HuSprGrpMemberSet(titleGroup, 2, sprite);
-	HuSprAttrSet(titleGroup, 2, SPRITE_ATTR_HIDDEN|SPIRTE_ATTR_BILINEAR);
+	HuSprAttrSet(titleGroup, 2, SPRITE_ATTR_HIDDEN|SPRITE_ATTR_BILINEAR);
 	HuSprPosSet(titleGroup, 2, 288, 380);
 	sprite_data = HuSprAnimReadFile(MAKE_DATA_NUM(DATADIR_TITLE, 9));
 	sprite = HuSprCreate(sprite_data, 0, 0);
 	HuSprGrpMemberSet(titleGroup, 3, sprite);
-	HuSprAttrSet(titleGroup, 3, SPRITE_ATTR_HIDDEN|SPIRTE_ATTR_BILINEAR);
+	HuSprAttrSet(titleGroup, 3, SPRITE_ATTR_HIDDEN|SPRITE_ATTR_BILINEAR);
 	HuSprPosSet(titleGroup, 3, 288, 200);
 }
 
diff --git a/src/game/board/main.c b/src/game/board/main.c
index 27d7992b..6266a194 100644
--- a/src/game/board/main.c
+++ b/src/game/board/main.c
@@ -2023,7 +2023,7 @@ void BoardLast5GfxInit(void)
 			}
 			BoardSpriteCreate(spr_file, prio, NULL, &work->sprites[i]);
 			HuSprGrpMemberSet(work->group, i, work->sprites[i]);
-			HuSprAttrSet(work->group, i, SPIRTE_ATTR_BILINEAR);
+			HuSprAttrSet(work->group, i, SPRITE_ATTR_BILINEAR);
 			HuSprPosSet(work->group, i, last5GfxPosTbl[lastF][i][0], last5GfxPosTbl[lastF][i][1]);
 		}
 		if(!work->is_last) {
diff --git a/src/game/minigame_seq.c b/src/game/minigame_seq.c
index 42bf3c44..5a4d057f 100644
--- a/src/game/minigame_seq.c
+++ b/src/game/minigame_seq.c
@@ -10,6 +10,8 @@
 
 void MGSeqStub(void);
 
+void MGSeqPauseEnableCtrl(s32 flag);
+
 extern s16 HuSysVWaitGet(s16 param);
 
 typedef struct seq_work SeqWork;
@@ -888,6 +890,13 @@ static s32 SeqMakeWord(SeqWork *work, char *str, s16 flags)
 	return grp_idx;
 }
 
+static s32 SeqCloneWord(SeqWork *work, s16 grp_idx)
+{
+	s16 i;
+	
+	return i;
+}
+
 static AnimData *SeqLoadFontChar(char *str, s16 flags)
 {
 	s32 data_num;
@@ -943,4 +952,312 @@ static AnimData *SeqLoadFontChar(char *str, s16 flags)
 		list++;
 	}
 	return NULL;
+}
+
+static float ForceDefine480()
+{
+	return 480.0f;
+}
+
+static void SeqPlayStartFX(void);
+
+static int SeqInitMGBasic(SeqWork *work, va_list params)
+{
+	s16 i;
+	s16 word_grp;
+	
+	work->work_s16[1] = va_arg(params, int);
+	if(work->work_s16[1] == 2) {
+		return SeqInitDraw(work, params);
+	}
+	work->type = 0;
+	work->work_float[0] = 0;
+	
+	{
+		s32 word_katakana;
+		s32 word_flag;
+		s32 word_ofs;
+		word_katakana = 0;
+		if(work->work_s16[1] == 2 && seqLanguage == 0) {
+			word_katakana = 1;
+		}
+		if(word_katakana) {
+			word_flag = 1;
+		} else {
+			word_flag = 0;
+		}
+		if(seqLanguage == 0) {
+			word_ofs = 0;
+		} else {
+			word_ofs = 3;
+		}
+		word_grp = SeqMakeWord(work, wordMgTbl[work->work_s16[1]+word_ofs], word_flag);
+	}
+	HuSprGrpPosSet(work->spr_grp[word_grp], 0.0f, 0.0f);
+	
+	for(i=0; i<work->work_s16[3]; i++) {
+		HuSprTPLvlSet(work->spr_grp[word_grp], i, 1.0f);
+		HuSprPosSet(work->spr_grp[word_grp], i, -100.0f, 240.0f);
+	}
+	if(seqPauseF) {
+		work->type = 2;
+		HuSprAttrSet(word_grp, 0, SPRITE_ATTR_HIDDEN);
+	} else {
+		work->param[0] = 3;
+	}
+	return 1;
+}
+
+static int SeqUpdateMGBasic(SeqWork *work)
+{
+	s16 idx;
+	float scale;
+	if(work->param[0] != 0 && work->type != -1) {
+		switch(work->param[0]) {
+			case 2:
+				if(work->param[1] != -1) {
+					(void)work; //HACK: to introduce extra branch
+				} else {
+					work->type = -1;
+					work->work_float[0] = 0.0f;
+				}
+				work->param[0] = 0;
+				break;
+				
+			case 1:
+				work->time_max = work->param[1];
+				work->param[0] = 0;
+				break;
+				
+			case 3:
+				work->type = 1;
+				work->param[0] = 0;
+				break;
+				
+			default:
+				work->param[0] = 0;
+				break;
+		}
+	}
+	if(work->type == 2) {
+		return 1;
+	}
+	work->time += seqSpeed;
+	if(work->time >= work->time_max && work->type != -1) {
+		work->type = -1;
+		work->work_float[0] = 0.0f;
+	}
+	if(work->type != 0) {
+		switch(work->type) {
+			case 1:
+			{
+				float pos_x;
+				float time;
+				s16 i;
+				if(work->work_s16[1] == 0) {
+					if(work->time <= 40) {
+						for(i=0; i<work->work_s16[3]; i++) {
+							time = work->time-((20/work->work_s16[3])*(work->work_s16[3]-i-1));
+							if(time < 0 || time > 20.0f) {
+								continue;
+							}
+							pos_x = (work->x-(0.5f*(work->work_s16[3]*56)))+28.0f+(i*56);
+							if(time == 20.0f) {
+								HuSprPosSet(work->spr_grp[0], i, pos_x, work->y);
+								HuSprZRotSet(work->spr_grp[0], i, 0.0f);
+							} else {
+								HuSprPosSet(work->spr_grp[0], i, pos_x-(((1.0-sin(((time*4.5f)*M_PI)/180.0))*(work->work_s16[3]*56*2))), work->y);
+								HuSprZRotSet(work->spr_grp[0], i, (time/20.0f)*390.0f);
+							}
+						}
+					} else {
+						time = work->time-40;
+						scale = work->scale_x+(0.5*sin(((time*9.0f)*M_PI)/180.0));
+						for(i=0; i<work->work_s16[3]; i++) {
+							pos_x = ((28.0f*scale)+(work->x-(0.5f*(scale*(work->work_s16[3]*56)))))+(scale*(i*56));
+							HuSprPosSet(work->spr_grp[0], i, pos_x, work->y);
+							HuSprScaleSet(work->spr_grp[0], i, scale, work->scale_y+sin(((time*9.0f)*M_PI)/180.0));
+						}
+					}
+					if(work->time == 40) {
+						idx = HuAudFXPlay(36);
+						work->stat |= 0x10;
+					}
+					if(work->time == 60) {
+						SeqPlayStartFX();
+						work->stat |= 0x4;
+					}
+					if(work->time >= 60) {
+						work->type = 0;
+					}
+				} else {
+					if(work->time == 1) {
+						if(work->work_s16[1] == 1) {
+							HuAudFXPlay(37);
+						} else {
+							HuAudFXPlay(40);
+						}
+						MGSeqPauseEnableCtrl(0);
+						work->stat |= 0x10;
+					}
+					if(work->time <= 20) {
+						time = work->time;
+						scale = work->scale_x+(0.5*sin(((time*9.0f)*M_PI)/180.0));
+						for(i=0; i<work->work_s16[3]; i++) {
+							HuSprAttrReset(work->spr_grp[0], i, SPRITE_ATTR_HIDDEN);
+							pos_x = ((28.0f*scale)+(work->x-(0.5f*(scale*(work->work_s16[3]*56)))))+(scale*(i*56));
+							HuSprPosSet(work->spr_grp[0], i, pos_x, work->y);
+							HuSprScaleSet(work->spr_grp[0], i, work->scale_x+sin(((time*9.0f)*M_PI)/180.0), work->scale_y+sin(((time*9.0f)*M_PI)/180.0));
+						}
+						if(time == 20.0f) {
+							for(i=0; i<work->work_s16[3]; i++) {
+								HuSprAttrReset(work->spr_grp[0], i, SPRITE_ATTR_HIDDEN);
+							}
+						}
+					} else {
+						if(work->time > 80) {
+							for(i=0; i<work->work_s16[3]; i++) {
+								time = (work->time-80)-((20/work->work_s16[3])*(work->work_s16[3]-i-1));
+								if(time < 0.0f || time > 20.0f) {
+									continue;
+								}
+								pos_x = (28.0f+(work->x-(0.5f*(work->work_s16[3]*56))))+(i*56);
+								if(time == 20.0f) {
+									HuSprAttrSet(work->spr_grp[0], i, SPRITE_ATTR_HIDDEN);
+								} else {
+									HuSprPosSet(work->spr_grp[0], i, pos_x+((1.0-cos(((time*4.5f)*M_PI)/180.0f))*(work->work_s16[3]*56*2)), work->y);
+									HuSprZRotSet(work->spr_grp[0], i, (time/20.0f)*390.0f);
+								}
+							}
+						}
+					}
+					if(work->time == 110) {
+						work->stat |= 0x4;
+					}
+					if(work->time >= 110) {
+						work->type = 0;
+						work->stat |= 8;
+					}
+				}
+			}
+				break;
+				
+			case -1:
+			{
+				work->work_float[0] += seqSpeed*0.1f;
+				scale = 1.0f-work->work_float[0];
+				if(scale <= 0.0f) {
+					scale = 0.0f;
+					work->type = 0;
+					work->stat |= 0x8;
+					if(work->work_s16[1] == 0) {
+						MGSeqPauseEnableCtrl(1);
+					}
+				}
+				for(idx=0; idx<work->work_s16[3]; idx++) {
+					HuSprTPLvlSet(work->spr_grp[0], idx, scale);
+				}
+			}
+				break;
+				
+			default:
+				break;
+		}
+	}
+	if(seqDoneF || (work->stat & 0x8)) {
+		MGSeqSprKill(work);
+		return 0;
+	}
+	return 1;
+}
+
+static int SeqInitMGCommon(SeqWork *work, va_list params)
+{
+	s16 i;
+	float tp_lvl;
+	s16 j;
+	
+	s16 word_grp;
+	
+	work->work_s16[1] = va_arg(params, int);
+	if(work->work_s16[1] == 2) {
+		return SeqInitDraw(work, params);
+	}
+	work->type = 0;
+	work->work_float[0] = 0;
+	tp_lvl = 1.0f;
+	for(i=0; i<4; i++) {
+		
+		if(i == 0)
+		{
+			s32 word_katakana;
+			s32 word_flag;
+			s32 word_ofs;
+			word_katakana = 0;
+			if(work->work_s16[1] == 2 && seqLanguage == 0) {
+				word_katakana = 1;
+			}
+			if(word_katakana) {
+				word_flag = 1;
+			} else {
+				word_flag = 0;
+			}
+			if(seqLanguage == 0) {
+				word_ofs = 0;
+			} else {
+				word_ofs = 3;
+			}
+			word_grp = SeqMakeWord(work, wordMgTbl[work->work_s16[1]+word_ofs], word_flag);
+		} else {
+			s16 grp_idx;
+			s32 new_grp;
+			for(grp_idx=0; grp_idx<16; grp_idx++) {
+				if(work->spr_grp[grp_idx] == -1) {
+					break;
+				}
+			}
+			if(grp_idx == 16) {
+				new_grp = -1;
+			} else {
+				work->spr_grp[grp_idx] = HuSprGrpCopy(work->spr_grp[word_grp]);
+				new_grp = grp_idx;
+			}
+			(void)new_grp;
+			word_grp = new_grp;
+		}
+		HuSprGrpPosSet(work->spr_grp[word_grp], 0.0f, 0.0f);
+		for(j=0; j<work->work_s16[3]; j++) {
+			HuSprTPLvlSet(work->spr_grp[word_grp], j, tp_lvl);
+			HuSprPosSet(work->spr_grp[word_grp], j, -100.0f, 240.0f);
+			HuSprPriSet(work->spr_grp[word_grp], j, i+5);
+			HuSprAttrSet(work->spr_grp[word_grp], i, SPRITE_ATTR_BILINEAR);
+		}
+		if(i == 0) {
+			tp_lvl -= 0.5;
+		} else {
+			tp_lvl -= 0.1f;
+		}
+	}
+	if(seqPauseF) {
+		work->type = 2;
+		HuSprAttrSet(word_grp, 0, SPRITE_ATTR_HIDDEN);
+	} else {
+		work->param[0] = 3;
+	}
+	return 1;
+}
+
+static int SeqInitDraw(SeqWork *work, va_list params)
+{
+	
+}
+
+static void SeqPlayStartFX(void)
+{
+	
+}
+
+void MGSeqPauseEnableCtrl(s32 flag)
+{
+	
 }
\ No newline at end of file
diff --git a/src/game/sprman.c b/src/game/sprman.c
index 5f5c25d4..e0f940ab 100644
--- a/src/game/sprman.c
+++ b/src/game/sprman.c
@@ -675,7 +675,7 @@ void HuSprSprBGSet(short sprite, AnimData *bg, short bg_bank)
     sprite_ptr->bg = bg;
     sprite_ptr->bg_bank = bg_bank;
     sprite_ptr->wrap_t = sprite_ptr->wrap_s = GX_REPEAT;
-    sprite_ptr->attr &= ~SPIRTE_ATTR_BILINEAR;
+    sprite_ptr->attr &= ~SPRITE_ATTR_BILINEAR;
 }
 
 void AnimDebug(AnimData *anim)
diff --git a/src/game/sprput.c b/src/game/sprput.c
index faf8ea73..5e1a923f 100644
--- a/src/game/sprput.c
+++ b/src/game/sprput.c
@@ -123,7 +123,7 @@ void HuSprDisp(SpriteData *sprite)
                 continue;
             }
             GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0);
-            HuSprTexLoad(anim, layer->bmpNo, 0, sprite->wrap_s, sprite->wrap_t, (sprite->attr & SPIRTE_ATTR_BILINEAR) ? GX_LINEAR : GX_NEAR);
+            HuSprTexLoad(anim, layer->bmpNo, 0, sprite->wrap_s, sprite->wrap_t, (sprite->attr & SPRITE_ATTR_BILINEAR) ? GX_LINEAR : GX_NEAR);
             if(layer->alpha != 255 || color_sum != 255*4) {
                 color.a = (u16)(sprite->a*layer->alpha) >> 8;
                 GXSetTevColor(GX_TEVSTAGE1, color);

From 5bbdcd3ecaa683f1beee8073a4da97f38dc3d9e2 Mon Sep 17 00:00:00 2001
From: mrshigure <mrshigure64@gmail.com>
Date: Wed, 31 Jan 2024 13:51:56 -0800
Subject: [PATCH 11/15] Partially matched board/item

---
 include/board_unsplit.h      |   26 +-
 include/game/board/item.h    |   11 +
 include/game/board/model.h   |   10 +
 include/game/board/ui.h      |    2 +
 include/game/gamework_data.h |    5 +
 include/game/hsfanim.h       |    6 +-
 include/game/hsfman.h        |    1 +
 src/REL/w03Dll/main.c        |   12 +-
 src/REL/w10Dll/host.c        |    2 +-
 src/game/board/item.c        | 1902 ++++++++++++++++++++++++++++++++++
 src/game/board/ui.c          |   14 +-
 src/game/hsfdraw.c           |    2 +-
 12 files changed, 1960 insertions(+), 33 deletions(-)
 create mode 100755 include/game/board/item.h
 create mode 100755 src/game/board/item.c

diff --git a/include/board_unsplit.h b/include/board_unsplit.h
index c7af0a90..131f4462 100644
--- a/include/board_unsplit.h
+++ b/include/board_unsplit.h
@@ -27,22 +27,22 @@ void BoardTutorialItemSet(s32);
 void BoardCharWheelSetTarget(s32);
 void BoardTutorialDirInputSet(s32, s32, s32);
 void BoardSpaceStarSetIndex(s32);
-void BoardModelRotYSet(s16, f32);
+s32 BoardModelRotYSet(s16, f32);
 f32 BoardModelRotYGet(s16);
-void BoardModelLayerSet(s16, u8);
+s32 BoardModelLayerSet(s16, u8);
 void BoardTutorialHostSet(s16);
 s16 BoardModelIDGet(s16);
-void BoardModelScaleSetV(s16, Vec*);
+s32 BoardModelScaleSetV(s16, Vec*);
 void BoardLightHookSet(BoardLightHook set, BoardLightHook reset);
-s16 BoardModelCreate(s32, void*, s32);
+s16 BoardModelCreate(s32, s32*, s32);
 void BoardModelKill(s16);
-void fn_8006DDE8(s16, f32);
-s32 BoardModelMotionStart(s16, s32, s32);
-void BoardModelMotionSpeedSet(s16, f32);
-void BoardModelPosSetV(s16, Vec*);
-void BoardModelPosSet(s16, f32, f32, f32);
-void BoardModelRotSetV(s16 arg0, Vec* arg1);
-void BoardModelVisibilitySet(s16, s32);
+s32 fn_8006DDE8(s16, f32);
+s32 BoardModelMotionStart(s16, s32, u32);
+s32 BoardModelMotionSpeedSet(s16, f32);
+s32 BoardModelPosSetV(s16, Vec*);
+s32 BoardModelPosSet(s16, f32, f32, f32);
+s32 BoardModelRotSetV(s16 arg0, Vec* arg1);
+s32 BoardModelVisibilitySet(s16, s32);
 void BoardSpaceWalkEventFuncSet(BoardSpaceEventFunc func);
 void BoardSpaceWalkMiniEventFuncSet(BoardSpaceEventFunc func);
 void BoardSpaceLandEventFuncSet(BoardSpaceEventFunc func);
@@ -56,10 +56,10 @@ void BoardBooHouseHostSet(s16);
 void BoardTutorialHookSet(void*);
 void BoardTutorialBlockSetPos(s32, s32);
 s32 BoardCameraRotGet(Vec*);
-void BoardModelScaleSet(s16, f32, f32, f32);
+s32 BoardModelScaleSet(s16, f32, f32, f32);
 s32 BoardIsKill(void);
 void BoardModelMtxSet(s16, Mtx*);
-void BoardModelRotSet(s16, f32, f32, f32);
+s32 BoardModelRotSet(s16, f32, f32, f32);
 
 void BoardBowserExec(s32 player, s32 space);
 void BoardBattleExec(s32 player, s32 space);
diff --git a/include/game/board/item.h b/include/game/board/item.h
new file mode 100755
index 00000000..4ede4953
--- /dev/null
+++ b/include/game/board/item.h
@@ -0,0 +1,11 @@
+#ifndef _BOARD_ITEM_H
+#define _BOARD_ITEM_H
+
+#include "dolphin/types.h"
+
+void BoardItemStart(s32 arg0, s32 arg1);
+BOOL BoardItemDoneCheck(void);
+void BoardItemPlayerRestore(s32 arg0, s32 arg1);
+void BoardItemBagItemSet(s16 *arg0);
+
+#endif
diff --git a/include/game/board/model.h b/include/game/board/model.h
index 31f0577b..d9f16496 100644
--- a/include/game/board/model.h
+++ b/include/game/board/model.h
@@ -34,8 +34,18 @@ s32 BoardModelAmbSet(s16 model, float r, float g, float b);
 s32 BoardModelExistCheck(s16 model, s32 arg1);
 s32 BoardModelExistDupe(s16 model, s32 arg1);
 s32 fn_8006DDE8(s16 model, float arg1);
+s32 BoardModelMotionCreate(s16 model, s32 data_num);
+s32 BoardModelMotionStartEndSet(s16 model, s16 start, s16 end);
 s32 BoardModelMotionStart(s16 model, s32 slot, u32 attr);
+s32 BoardModelMotionShiftSet(s16 model, s32 motion, float time, float shift_time, u32 attr);
+s32 BoardModelAttrSet(s16 model, u32 attr);
+s32 BoardModelMotionTimeSet(s16 model, float time);
+float BoardModelMotionTimeGet(s16 model);
+float BoardModelMotionMaxTimeGet(s16 model);
 s32 BoardModelMotionSpeedSet(s16 model, float speed);
+s32 BoardModelMotionEndCheck(s16 model);
+s32 BoardModelAlphaSet(s16 model, u8 alpha);
+s32 BoardModelRotYSet(s16 model, float rot);
 s32 BoardModelPosSet(s16 model, float x, float y, float z);
 s32 BoardModelPosSetV(s16 model, Vec *pos);
 s32 BoardModelRotSet(s16 model, float x, float y, float z);
diff --git a/include/game/board/ui.h b/include/game/board/ui.h
index ba99e7e1..b2ba74dd 100755
--- a/include/game/board/ui.h
+++ b/include/game/board/ui.h
@@ -33,4 +33,6 @@ void BoardMakeRandomItem(void);
 void BoardItemGetDestPos(s32 arg0, Vec *arg1);
 void BoardItemStatusKill(s32 arg0);
 
+extern s8 boardItemUser;
+
 #endif
diff --git a/include/game/gamework_data.h b/include/game/gamework_data.h
index 529f9439..70d377b7 100644
--- a/include/game/gamework_data.h
+++ b/include/game/gamework_data.h
@@ -177,4 +177,9 @@ static inline s32 GWPlayerTeamGet(s32 player)
     return GWPlayer[player].team;
 }
 
+static inline s32 GWPlayerSpaceCurrGet(s32 player)
+{
+    return GWPlayer[player].space_curr;
+}
+
 #endif
diff --git a/include/game/hsfanim.h b/include/game/hsfanim.h
index 46c41f0a..e15b822a 100644
--- a/include/game/hsfanim.h
+++ b/include/game/hsfanim.h
@@ -29,7 +29,8 @@ typedef struct {
 typedef struct particle_data {
     /* 0x00 */ s16 unk_00;
     /* 0x02 */ s16 unk_02;
-    /* 0x04 */ char unk_04[0x1C];
+    /* 0x04 */ float unk_04;
+    /* 0x08 */ char unk_08[0x18];
     /* 0x20 */ s16 unk_20;
     /* 0x22 */ s16 unk_22;
     /* 0x24 */ float unk_24;
@@ -39,7 +40,7 @@ typedef struct particle_data {
     /* 0x2E */ char unk_2E[2];
     /* 0x30 */ s16 unk_30;
     /* 0x32 */ char unk_32[2];
-    /* 0x34 */ s32 unk_34;
+    /* 0x34 */ u32 unk_34;
     /* 0x38 */ s32 unk_38;
     /* 0x3C */ u32 unk_3C;
     /* 0x40 */ s32 unk_40;
@@ -115,6 +116,7 @@ void Hu3DParticleZRotSet(s16 arg0, float arg1);
 void Hu3DParticleColSet(s16 arg0, u8 arg1, u8 arg2, u8 arg3);
 void Hu3DParticleTPLvlSet(s16 arg0, float arg1);
 void Hu3DParticleBlendModeSet(s16 arg0, u8 arg1);
+void Hu3DParticleHookSet(s16 arg0, void *arg1);
 void Hu3DParticleAttrSet(s16 arg0, u8 arg1);
 void Hu3DParticleAttrReset(s16 arg0, u8 arg1);
 void Hu3DParticleAnimModeSet(s16 arg0, s16 arg1);
diff --git a/include/game/hsfman.h b/include/game/hsfman.h
index d967a058..12bd2847 100644
--- a/include/game/hsfman.h
+++ b/include/game/hsfman.h
@@ -135,6 +135,7 @@ void Hu3DNoSyncSet(s32);
 s16 Hu3DModelCreate(void *);
 s16 Hu3DModelLink(s16);
 s16 Hu3DHookFuncCreate(ModelHookFunc);
+void Hu3DModelKill(s16);
 void Hu3DModelAllKill(void);
 void Hu3DModelPosSet(s16, f32, f32, f32);
 void Hu3DModelPosSetV(s16, Vec *);
diff --git a/src/REL/w03Dll/main.c b/src/REL/w03Dll/main.c
index d7d5e61d..6e04ca5b 100644
--- a/src/REL/w03Dll/main.c
+++ b/src/REL/w03Dll/main.c
@@ -11,8 +11,8 @@
 #include "board_unsplit.h"
 #include "game/hsfman.h"
 
-void BoardModelPosSet(s16, f32, f32, f32);
-s32 BoardModelMotionStart(s16, s32, s32);
+s32 BoardModelPosSet(s16, f32, f32, f32);
+s32 BoardModelMotionStart(s16, s32, u32);
 
 void fn_8005B150(void*, void*);
 void fn_1_740(void);
@@ -26,7 +26,7 @@ void fn_1_AF8(void);
 void fn_1_DEC(void);
 void fn_1_10B0(void);
 s32 fn_1_12C8(void);
-void fn_8006DDE8(s16, f32);
+s32 fn_8006DDE8(s16, f32);
 void fn_1_10E4(omObjData* arg0);
 extern Process *boardObjMan;
 typedef void (*VoidFunc)(void);
@@ -35,7 +35,7 @@ extern const VoidFunc _dtors[];
 
 
 f32 BoardModelMotionTimeGet(s16);
-s16 BoardModelCreate(s32, void*, s32);
+s16 BoardModelCreate(s32, s32*, s32);
 void BoardModelKill(s16);
 void BoardModelMotionStartEndSet(s16, s32, s32);
 void Hu3DFogSet(f32, f32, u8, u8, u8);
@@ -142,10 +142,10 @@ void BoardCreate(void) {
     fn_8006DDE8(lbl_1_data_1E2, -1.0f);
     BoardModelPosSet(lbl_1_data_1E2, 0.0f, 0.0f, 0.0f);
     BoardModelMotionStart(lbl_1_data_1E2, 0, 0x40000001);
-    lbl_1_data_1E4 = BoardModelCreate(0x77001B, &lbl_1_data_20C, 0);
+    lbl_1_data_1E4 = BoardModelCreate(0x77001B, lbl_1_data_20C, 0);
     BoardModelPosSet(lbl_1_data_1E4, 0.0f, 0.0f, 0.0f);
     BoardModelMotionStart(lbl_1_data_1E4, 1, 0x40000001);
-    lbl_1_data_1E6 = BoardModelCreate(0x2000D, &lbl_1_data_214, 0);
+    lbl_1_data_1E6 = BoardModelCreate(0x2000D, lbl_1_data_214, 0);
     BoardModelPosSet(lbl_1_data_1E6, 0.0f, 0.0f, 0.0f);
     BoardModelMotionStart(lbl_1_data_1E6, 1, 0x40000001);
 
diff --git a/src/REL/w10Dll/host.c b/src/REL/w10Dll/host.c
index 4ef6f9b8..7b500cc9 100644
--- a/src/REL/w10Dll/host.c
+++ b/src/REL/w10Dll/host.c
@@ -14,7 +14,7 @@ Vec lbl_1_data_80[2] = {
 
 void fn_1_AEC(void) {
     lbl_1_bss_1C = 0;
-    lbl_1_bss_1E = BoardModelCreate(MAKE_DATA_NUM(DATADIR_W10, 15), &lbl_1_data_78, 0);
+    lbl_1_bss_1E = BoardModelCreate(MAKE_DATA_NUM(DATADIR_W10, 15), lbl_1_data_78, 0);
     BoardModelMotionStart(lbl_1_bss_1E, 1, 0x40000001);
     BoardTutorialHostSet(lbl_1_bss_1E);
     BoardModelLayerSet(lbl_1_bss_1E, 6);
diff --git a/src/game/board/item.c b/src/game/board/item.c
new file mode 100755
index 00000000..4fa624b8
--- /dev/null
+++ b/src/game/board/item.c
@@ -0,0 +1,1902 @@
+#include "game/board/item.h"
+#include "game/audio.h"
+#include "game/gamework.h"
+#include "game/gamework_data.h"
+#include "game/hsfanim.h"
+#include "game/hsfman.h"
+#include "game/objsub.h"
+#include "game/pad.h"
+#include "game/process.h"
+#include "game/window.h"
+#include "game/wipe.h"
+#include "game/board/main.h"
+#include "game/board/model.h"
+#include "game/board/player.h"
+#include "game/board/space.h"
+#include "game/board/ui.h"
+#include "game/board/window.h"
+
+typedef struct {
+    /* 0x00 */ s16 unk00;
+    /* 0x02 */ s16 unk02;
+    /* 0x04 */ float unk04;
+    /* 0x08 */ float unk08;
+    /* 0x0C */ float unk0C;
+    /* 0x10 */ Vec unk10;
+} UnkItemProcUserData; // Size unknown
+
+typedef struct {
+    /* 0x00 */ s16 unk00;
+    /* 0x02 */ s16 unk02;
+    /* 0x04 */ float unk04;
+    /* 0x08 */ float unk08;
+    /* 0x0C */ char unk0C[4];
+    /* 0x10 */ float unk10;
+    /* 0x14 */ float unk14;
+    /* 0x18 */ float unk18;
+    /* 0x1C */ s16 unk1C;
+} UnkItemShowProcStruct; // Size unknown
+
+typedef struct {
+    /* 0x00 */ float unk00;
+    /* 0x04 */ Vec unk04;
+    /* 0x04 */ Vec unk10;
+} UnkGenieCameraStruct; // Size 0x1C
+
+u32 frandmod(u32);
+void CharModelCreateParticle(s32, Vec*);
+void CharModelLayerSetAll(s32);
+void BoardComKeySetRight(void);
+void BoardBowserSuitInit(s32);
+s16 BoardBowserSuitPlayerModelGet(void);
+void fn_8004F578(s16, s32);
+void BoardAudSeqPause(s32, s32, s32);
+
+static void ItemProcess(void);
+static void RestoreProcess(void);
+static void ItemDestroy(void);
+static void RestoreDestroy(void);
+static void ItemSizeShowAnim(void);
+static void ItemRotProc(void);
+static Process *ItemShowProc(UnkItemShowProcStruct *arg0, Vec *arg1);
+static s16 ItemGetTarget(void);
+static void ItemSizeSet(s32 arg0);
+static void ExecItemMini(void);
+static void ExecItemMega(void);
+static void ExecItemMiniSuper(void);
+static void ExecItemMegaSuper(void);
+static void ExecItemHammer(void);
+static void ExecItemPipe(void);
+static void ExecItemSwap(void);
+static void ExecItemSpark(void);
+static void ExecItemLight(void);
+static void ExecItemWhistle(void);
+static void ExecItemBowser(void);
+static void ExecItemBooBall(void);
+static void LampParticleUpdate(s32 arg0, ParticleData *arg1);
+static void GenieParticleUpdate(s32 arg0, ParticleData *arg1);
+static void GenieCameraProc(void);
+static void GenieCameraCalc(UnkGenieCameraStruct *arg0, s32 arg1, float arg2, Vec *arg3, Vec *arg4);
+static void GenieSceneExec(void);
+static void ExecItemGenie(void);
+static void ExecItemBagJump(void);
+static void ExecItemBagShow(void);
+static void ExecItemBag(void);
+static void RestoreItemNull(void);
+static void RestoreItemMini(void);
+static void RestoreItemMega(void);
+static void RestoreItemMiniSuper(void);
+static void RestoreItemMegaSuper(void);
+static void RestoreItemBowser(void);
+
+// BSS
+static Vec booBallScale;
+static Vec booBallPos;
+static Vec booCamUp;
+static Vec booCamTarget;
+static Vec booCamPos;
+
+// SBSS
+static s16 itemBagItems[3];
+static s8 currItemRestore;
+static s8 currItem;
+static s16 suitMdl;
+static s32 suitMot[2];
+static s32 suitCommonMot[2];
+// ...
+static float genieFov;
+static AnimData *genieParticleAnim;
+static s16 geniePlayerMot[3];
+static Process *itemProc;
+
+// SDATA
+s32 lbl_801D37A0[2] = { 0x00070075, -1 };
+
+// DATA
+static void (*itemFuncTbl[])(void) = {
+    ExecItemMini,
+    ExecItemMega,
+    ExecItemMiniSuper,
+    ExecItemMegaSuper,
+    ExecItemHammer,
+    ExecItemPipe,
+    ExecItemSwap,
+    ExecItemSpark,
+    ExecItemLight,
+    ExecItemWhistle,
+    ExecItemBowser,
+    ExecItemBooBall,
+    ExecItemGenie,
+    ExecItemBag
+};
+
+// DATA + 0x38
+static void (*itemRestoreFuncTbl[])(void) = {
+    RestoreItemMini,
+    RestoreItemMega,
+    RestoreItemMiniSuper,
+    RestoreItemMegaSuper,
+    RestoreItemNull,
+    RestoreItemNull,
+    RestoreItemNull,
+    RestoreItemNull,
+    RestoreItemNull,
+    RestoreItemNull,
+    RestoreItemBowser,
+    RestoreItemNull,
+    RestoreItemNull,
+    RestoreItemNull
+};
+
+// DATA + 0x70
+static s32 itemMdlTbl[] = {
+    0x0007006D,
+    0x0007006E,
+    0x0007006F,
+    0x00070070,
+    0x00070071,
+    0x00070072,
+    0x00070073,
+    0x00070074,
+    0x00070076,
+    0x00070077,
+    0x00070078,
+    0x00070079,
+    0x0007007A,
+    0x0007007B
+};
+
+// DATA + 0xA8
+static s32 forceMoveSfxTbl[] = {
+    0x38, 0x45, 0x42, 0x4D, 0x48, 0x3F
+};
+
+// DATA + 0xC0
+static s32 callMotTbl[] = {
+    0x005F0052,
+    0x001A0052,
+    0x006D0052,
+    0x008A0052,
+    0x00850052,
+    0x00110052,
+    0x000D0052,
+    0x00810052
+};
+
+// DATA + 0xE0
+// callHookTbl items
+
+// DATA + 0x178
+static char *callHookTbl[] = {
+    "c000m01-itemhook-r",
+    "c001m01-itemhook-r",
+    "c002m01-itemhook-r",
+    "c003m01-itemhook-r",
+    "c004m01-itemhook-r",
+    "c005m01-itemhook-r",
+    "c006m01-itemhook-r",
+    "c007m01-itemhook-r"
+};
+
+// DATA + 0x198
+static s32 callAttackMotTbl[] = {
+    0x0075001F,
+    0x00760005,
+    0x0077001D,
+    0x00780009,
+    0x00790007,
+    0x007A0013
+};
+
+// DATA + 0x1B0
+static s32 callAttackMotTbl2[] = {
+    0x00750020,
+    0x00760006,
+    0x0077001E,
+    0x0078000A,
+    0x00790008,
+    0x007A0014
+};
+
+// DATA + 0x1C8
+static s32 suitMotTbl[][2] = {
+    { 0x00040001, 0x00040002 },
+    { 0x00040004, 0x00040005 },
+    { 0x00040007, 0x00040008 },
+    { 0x0004000A, 0x0004000B },
+    { 0x0004000D, 0x0004000E },
+    { 0x00040010, 0x00040011 },
+    { 0x00040013, 0x00040014 },
+    { 0x00040016, 0x00040017 }
+};
+
+void BoardItemStart(s32 arg0, s32 arg1) {
+    currItemRestore = arg0;
+    currItem = arg1;
+    suitMdl = -1;
+    itemProc = HuPrcChildCreate(ItemProcess, 0x2004, 0x1000, 0, boardMainProc);
+    HuPrcDestructorSet2(itemProc, ItemDestroy);
+}
+
+BOOL BoardItemDoneCheck(void) {
+    if (itemProc) {
+        return FALSE;
+    } else {
+        return TRUE;
+    }
+}
+
+void BoardItemPlayerRestore(s32 arg0, s32 arg1) {
+    currItemRestore = arg0;
+    currItem = arg1;
+    itemProc = HuPrcChildCreate(RestoreProcess, 0x2004, 0x1000, 0, boardMainProc);
+    HuPrcDestructorSet2(itemProc, RestoreDestroy);
+}
+
+static void ItemProcess(void) {
+    void (*temp_r31)(void) = itemFuncTbl[currItem];
+
+    HuPrcChildCreate(temp_r31, 0x2003, 0x1000, 0, HuPrcCurrentGet());
+    HuPrcChildWatch();
+    HuPrcEnd();
+}
+
+static void RestoreProcess(void) {
+    void (*temp_r31)(void) = itemRestoreFuncTbl[currItem];
+
+    HuPrcChildCreate(temp_r31, 0x2003, 0x1000, 0, HuPrcCurrentGet());
+    HuPrcChildWatch();
+    HuPrcEnd();
+}
+
+static void ItemDestroy(void) {
+    itemProc = NULL;
+}
+
+static void RestoreDestroy(void) {
+    itemProc = NULL;
+}
+
+static void ItemSizeShowAnim(void) {
+    Vec sp24;
+    Vec sp18;
+    Vec spC;
+    float sp8;
+    float var_f31;
+    s32 i;
+
+    sp8 = 1.0f;
+    var_f31 = 180.0f;
+    BoardPlayerPosGet(currItemRestore, &sp24);
+    BoardPlayerRotGet(currItemRestore, &spC);
+    sp24.y += 300.0f;
+    sp18.x = sp18.y = sp18.z = 1.0f;
+    BoardModelRotSetV(suitMdl, &spC);
+    BoardModelPosSetV(suitMdl, &sp24);
+    for (i = 0; i < 120; i++) {
+        sp24.y += 3.0 * sin(M_PI * var_f31 / 180.0);
+        BoardModelPosSetV(suitMdl, &sp24);
+        var_f31 += 9.0f;
+        if (var_f31 >= 360.0f) {
+            var_f31 -= 360.0f;
+        }
+        HuPrcVSleep();
+    }
+    for (i = 0; i < 30; i++) {
+        sp24.y -= 6.6666665f;
+        sp18.x -= 0.03f;
+        sp18.y -= 0.03f;
+        sp18.z -= 0.03f;
+        BoardModelScaleSetV(suitMdl, &sp18);
+        BoardModelPosSetV(suitMdl, &sp24);
+        HuPrcVSleep();
+    }
+    BoardModelKill(suitMdl);
+}
+
+static void ItemRotProc(void) {
+    Vec sp20;
+    Vec sp14;
+    Vec sp8;
+    UnkItemProcUserData *temp_r31;
+
+    temp_r31 = HuPrcCurrentGet()->user_data;
+    BoardModelPosGet(temp_r31->unk02, &sp20);
+    BoardModelRotGet(temp_r31->unk02, &sp8);
+    temp_r31->unk0C = 0.0f;
+    while (1) {
+        if (temp_r31->unk00 == 0) {
+            sp14 = sp20;
+            sp14.y += temp_r31->unk04 * sin(M_PI * temp_r31->unk0C / 180.0);
+            BoardModelPosSetV(temp_r31->unk02, &sp14);
+            temp_r31->unk0C += temp_r31->unk08;
+            if (temp_r31->unk0C >= 360.0f) {
+                temp_r31->unk0C -= 360.0f;
+            }
+            PSVECAdd(&sp8, &temp_r31->unk10, &sp8);
+            if (sp8.x < 0.0f) {
+                sp8.x += 360.0f;
+            }
+            if (sp8.x >= 360.0f) {
+                sp8.x -= 360.0f;
+            }
+            if (sp8.y < 0.0f) {
+                sp8.y += 360.0f;
+            }
+            if (sp8.y >= 360.0f) {
+                sp8.y -= 360.0f;
+            }
+            if (sp8.z < 0.0f) {
+                sp8.z += 360.0f;
+            }
+            if (sp8.z >= 360.0f) {
+                sp8.z -= 360.0f;
+            }
+            BoardModelRotSetV(temp_r31->unk02, &sp8);
+        }
+        HuPrcVSleep();
+    }
+}
+
+// TODO: needs the inline keyword to be inlined into ExecItemHammer, but adding it messes up sdata2.
+// sdata2 order should be: 1000.0f, 0.15f, then 20.0f.
+// With the inline keyword, it becomes 0.15f, 20.0f, then 1000.0f (workaround in BoardUiInlineFunc02 below).
+static inline void BoardUiInlineFunc01(Vec *arg0) {
+    Vec sp30;
+    Vec sp3C;
+    Vec sp48;
+    Vec sp54;
+    float spC;
+    float var_f31;
+    s32 i;
+
+    spC = 1.0f;
+    BoardPlayerPosGet(currItemRestore, &sp30);
+    BoardPlayerRotGet(currItemRestore, &sp48);
+    sp3C = sp30;
+    sp3C.y += 1000.0f;
+    sp54.x = sp54.y = sp54.z = 1.0f;
+    BoardModelRotSetV(suitMdl, &sp48);
+    BoardModelPosSetV(suitMdl, &sp3C);
+    while (1) {
+        var_f31 = 0.15f * (sp3C.y - (sp30.y + 300.0f));
+        if (var_f31 > 20.0f) {
+            var_f31 = 20.0f;
+        }
+        if (var_f31 < 1.0f) {
+            var_f31 = 1.0f;
+        }
+        if (fabs(sp3C.y - (sp30.y + 300.0f)) < var_f31) {
+            break;
+        }
+        sp3C.y -= var_f31;
+        BoardModelPosSetV(suitMdl, &sp3C);
+        PSVECAdd(&sp48, arg0, &sp48);
+        for (i = 0; i < 3; i++) {
+            if (((float*) &sp48)[i] < 0.0f) {
+                ((float*) &sp48)[i] += 360.0f;
+            }
+            if (((float*) &sp48)[i] >= 360.0f) {
+                ((float*) &sp48)[i] -= 360.0f;
+            }
+        }
+        BoardModelRotSetV(suitMdl, &sp48);
+        HuPrcVSleep();
+    }
+    sp3C.y = sp30.y + 300.0f;
+    BoardModelPosSetV(suitMdl, &sp3C);
+}
+
+static void BoardUiInlineFunc02(void) {
+    Vec sp18;
+    Vec sp24;
+    float sp8;
+    float var_f30;
+
+    (void) 1000.0f; // TODO: fix this.
+    sp8 = 1.0f;
+    BoardModelPosGet(suitMdl, &sp24);
+    BoardPlayerPosGet(currItemRestore, &sp18);
+    while (1) {
+        var_f30 = 0.15f * (sp24.y - sp18.y - 300.0f);
+        if (var_f30 > 20.0f) {
+            var_f30 = 20.0f;
+        }
+        if (var_f30 < 1.0f) {
+            var_f30 = 1.0f;
+        }
+        if (fabs(sp24.y - 1000.0f) <= var_f30) {
+            break;
+        }
+        sp24.y += var_f30;
+        BoardModelPosSetV(suitMdl, &sp24);
+        HuPrcVSleep();
+    }
+    sp24.y = 1000.0f;
+    BoardModelPosSetV(suitMdl, &sp24);
+}
+
+static inline void BoardUiInlineFunc03(s32 arg0) {
+    Vec sp8;
+    Vec sp14;
+
+    BoardSpacePosGet(0, GWPlayerSpaceCurrGet(arg0), &sp14);
+    BoardPlayerPosGet(arg0, &sp8);
+    BoardPlayerPosLerpStart(arg0, &sp8, &sp14, 0x14);
+    while (GWPlayer[arg0].moving) {
+        HuPrcVSleep();
+    }
+    BoardPlayerMotBlendSet(arg0, 0, 7);
+    while (!BoardPlayerMotBlendCheck(arg0)) {
+        HuPrcVSleep();
+    }
+    BoardRotateDiceNumbers(arg0);
+}
+
+static inline void BoardUiInlineFunc04(Process *arg0, s32 arg1) {
+    UnkItemShowProcStruct *temp_r19 = arg0->user_data;
+
+    temp_r19->unk00 = arg1;
+}
+
+static inline Process *BoardUiInlineFunc05(UnkItemShowProcStruct *arg0) {
+    Process *temp_r27;
+
+    temp_r27 = HuPrcCreate(ItemRotProc, 0x2004, 0x1000, 0);
+    temp_r27->user_data = arg0;
+    BoardUiInlineFunc04(temp_r27, 0);
+    return temp_r27;
+}
+
+static Process *ItemShowProc(UnkItemShowProcStruct *arg0, Vec *arg1) {
+    Vec sp20;
+    Vec sp14;
+    Vec sp8;
+    Process *var_r29;
+
+    var_r29 = NULL;
+    BoardPlayerPosGet(currItemRestore, &sp20);
+    BoardPlayerRotGet(currItemRestore, &sp14);
+    sp20.y += 300.0f;
+    if (currItem == 0xD) {
+        sp20.y -= 50.0f;
+    }
+    if (arg1 == NULL) {
+        sp8.x = sp8.y = sp8.z = 1.0f;
+    } else {
+        sp8 = *arg1;
+    }
+    if (suitMdl >= 0) {
+        BoardModelLayerSet(suitMdl, 2);
+        BoardModelRotSetV(suitMdl, &sp14);
+        BoardModelPosSetV(suitMdl, &sp20);
+        BoardModelScaleSetV(suitMdl, &sp8);
+        BoardModelVisibilitySet(suitMdl, 0);
+    }
+    BoardCameraRotGet(&sp14);
+    if (arg0 == NULL || arg0->unk1C != 0) {
+        CharModelLayerSetAll(3);
+        sp20.y += 35.0f;
+        sp20.z += 50.0 * cos(sp14.y * M_PI / 180.0);
+        sp20.x += 50.0 * sin(sp14.y * M_PI / 180.0);
+        CharModelCreateParticle(1, &sp20);
+        HuPrcSleep(0xA);
+    }
+    if (suitMdl >= 0) {
+        BoardModelVisibilitySet(suitMdl, 1);
+        if (arg0 != NULL) {
+            var_r29 = BoardUiInlineFunc05(arg0);
+        }
+    }
+    HuPrcSleep(30);
+    return var_r29;
+}
+
+static s16 ItemGetTarget(void) {
+    s32 sp20[4];
+    s32 sp10[4];
+    float sp8[2];
+    s16 temp_r22;
+    s16 temp_r29;
+    s32 temp_r24;
+    s32 var_r28;
+    s32 temp_r21;
+    s32 var_r27;
+    u8 var_r26;
+    s32 var_r25;
+    s32 var_r30;
+    s32 var_r31;
+    s32 temp_r23;
+
+    var_r28 = 0;
+    var_r27 = 0;
+    for (var_r31 = 0; var_r31 < 4; var_r31++) {
+        if (var_r31 != currItemRestore) {
+            sp20[var_r27++] = var_r31;
+            HuWinInsertMesSizeGet(GWPlayerCfg[var_r31].character, var_r28);
+            var_r28++;
+        }
+    }
+    HuWinMesMaxSizeGet(1, sp8, 0x12000E);
+    temp_r29 = HuWinCreate(-10000.0f, -10000.0f, sp8[0], sp8[1], 0);
+    if (!GWPlayer[currItemRestore].com) {
+        winData[temp_r29].active_pad = (1 << GWPlayer[currItemRestore].port);
+    }
+    for (var_r31 = 0; var_r31 < var_r27; var_r31++) {
+        HuWinInsertMesSet(temp_r29, GWPlayerCfg[sp20[var_r31]].character, var_r31);
+    }
+    HuWinMesSet(temp_r29, 0x12000E);
+    if (GWPlayer[currItemRestore].com) {
+        var_r26 = 0xF;
+    } else {
+        var_r26 = 0;
+        for (var_r31 = 0; var_r31 < 4; var_r31++) {
+            if (var_r31 != currItemRestore) {
+                var_r26 = (1 << GWPlayer[var_r31].port);
+            }
+        }
+    }
+    HuWinDisablePlayerSet(temp_r29, var_r26);
+    if (GWPlayer[currItemRestore].com) {
+        temp_r23 = GWPlayer[currItemRestore].port;
+        temp_r21 = frandmod(3);
+        temp_r24 = GWMessDelayGet();
+        for (var_r25 = 0; var_r25 < temp_r21; var_r25++) {
+            for (var_r30 = 0; var_r30 < 4; var_r30++) {
+                sp10[var_r30] = 0;
+            }
+            sp10[temp_r23] = 4;
+            HuWinComKeyWait(sp10[0], sp10[1], sp10[2], sp10[3], temp_r24);
+        }
+        for (var_r30 = 0; var_r30 < 4; var_r30++) {
+            sp10[var_r30] = 0;
+        }
+        sp10[temp_r23] = 0x100;
+        HuWinComKeyWait(sp10[0], sp10[1], sp10[2], sp10[3], temp_r24);
+    }
+    HuWinAttrSet(temp_r29, 0x10);
+    HuWinMesSpeedSet(temp_r29, 0);
+    temp_r22 = sp20[HuWinChoiceGet(temp_r29, 0)];
+    HuWinKill(temp_r29);
+    return temp_r22;
+}
+
+static void ItemSizeSet(s32 arg0) {
+    float sp24[9];
+    float sp14[4];
+    float sp8[3] = { 1.0f, 0.3f, 2.5f };
+    float var_f31;
+    float temp_f30;
+    s16 temp_r28;
+    s32 var_r27;
+    s16 temp_r26;
+    s32 i;
+    s32 j;
+
+    var_f31 = sp8[BoardPlayerSizeGet(currItemRestore)];
+    sp14[0] = var_f31;
+    sp14[1] = var_f31 + (sp8[arg0] - var_f31) / 3.0f;
+    sp14[2] = var_f31 + (sp8[arg0] - var_f31) / 1.5f;
+    sp14[3] = sp8[arg0];
+    sp24[0] = sp14[1];
+    sp24[1] = sp14[0];
+    sp24[2] = sp14[1];
+    sp24[3] = sp14[2];
+    sp24[4] = sp14[1];
+    sp24[5] = sp14[2];
+    sp24[6] = sp14[3];
+    sp24[7] = sp14[2];
+    sp24[8] = sp14[3];
+    temp_r26 = BoardPlayerModelGet(currItemRestore);
+    temp_r28 = BoardModelIDGet(temp_r26);
+    Hu3DModelAttrSet(temp_r28, 0x40000002);
+    var_r27 = 0;
+    for (i = 0; i < 9; i++) {
+        temp_f30 = (sp24[var_r27++] - var_f31) / 10.0f;
+        for (j = 0; j < 10; j++) {
+            BoardPlayerScaleSet(currItemRestore, var_f31, var_f31, var_f31);
+            var_f31 += temp_f30;
+            HuPrcVSleep();
+        }
+    }
+    Hu3DModelAttrReset(temp_r28, 0x40000002);
+    BoardPlayerSizeSet(currItemRestore, arg0);
+}
+
+static void ExecItemMini(void) {
+    suitMdl = BoardModelCreate(itemMdlTbl[currItem], NULL, 0);
+    BoardModelLayerSet(suitMdl, 2);
+    HuAudFXPlay(0x350);
+    ItemShowProc(NULL, NULL);
+    ItemSizeShowAnim();
+    HuAudFXPlay(0x314);
+    omVibrate(currItemRestore, 90, 6, 6);
+    HuAudFXPlay(0x313);
+    ItemSizeSet(1);
+    HuPrcSleep(0x3C);
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
+}
+
+static void ExecItemMega(void) {
+    suitMdl = BoardModelCreate(itemMdlTbl[currItem], NULL, 0);
+    BoardModelLayerSet(suitMdl, 2);
+    HuAudFXPlay(0x350);
+    ItemShowProc(NULL, NULL);
+    ItemSizeShowAnim();
+    HuAudFXPlay(0x312);
+    omVibrate(currItemRestore, 90, 4, 2);
+    HuAudFXPlay(0x311);
+    ItemSizeSet(2);
+    HuPrcSleep(0x3C);
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
+}
+
+static void ExecItemMiniSuper(void) {
+    suitMdl = BoardModelCreate(itemMdlTbl[currItem], NULL, 0);
+    BoardModelLayerSet(suitMdl, 2);
+    HuAudFXPlay(0x350);
+    ItemShowProc(NULL, NULL);
+    ItemSizeShowAnim();
+    HuAudFXPlay(0x314);
+    omVibrate(currItemRestore, 90, 4, 2);
+    HuAudFXPlay(0x313);
+    ItemSizeSet(1);
+    HuPrcSleep(0x3C);
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
+}
+
+static void ExecItemMegaSuper(void) {
+    suitMdl = BoardModelCreate(itemMdlTbl[currItem], NULL, 0);
+    BoardModelLayerSet(suitMdl, 2);
+    HuAudFXPlay(0x350);
+    ItemShowProc(NULL, NULL);
+    ItemSizeShowAnim();
+    HuAudFXPlay(0x312);
+    omVibrate(currItemRestore, 90, 0xC, 0);
+    HuAudFXPlay(0x311);
+    ItemSizeSet(2);
+    HuPrcSleep(0x3C);
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
+}
+
+static void ExecItemHammer(void) {
+    Vec sp6C;
+    Vec sp60;
+    float sp10[2];
+    s32 i;
+    s16 temp_r28;
+    s16 temp_r27;
+    s16 var_r26;
+    s16 var_r30;
+
+    HuAudFXPlay(0x350);
+    ItemShowProc(NULL, NULL);
+    temp_r27 = ItemGetTarget();
+    suitMdl = BoardModelCreate(itemMdlTbl[currItem], NULL, 0);
+    BoardModelLayerSet(suitMdl, 2);
+    var_r30 = frand() & 1;
+    if (var_r30 != 0) {
+        BoardModelMotionTimeSet(suitMdl, 1.5f);
+    } else {
+        BoardModelMotionTimeSet(suitMdl, 0.0f);
+    }
+    BoardModelAttrSet(suitMdl, 0x40000002);
+    sp60.x = sp60.y = sp60.z = 2.0f;
+    BoardModelScaleSetV(suitMdl, &sp60);
+    sp6C.x = sp6C.y = sp6C.z = 0.0f;
+    BoardUiInlineFunc01(&sp6C);
+    HuWinMesMaxSizeGet(1, sp10, 0x120011);
+    temp_r28 = HuWinCreate(-10000.0f, 320.0f, sp10[0], sp10[1], 0);
+    HuWinMesSet(temp_r28, 0x120011);
+    HuWinBGTPLvlSet(temp_r28, 0.0f);
+    HuWinMesSpeedSet(temp_r28, 0);
+    if (GWPlayer[currItemRestore].com) {
+        var_r26 = frandmod(0x78) + 0x1E;
+    }
+    for (i = 1; i <= 0x12C; i++) {
+        if (i % 10 == 0) {
+            HuAudFXPlay(0x315);
+            var_r30 ^= 1;
+            if (var_r30 != 0) {
+                BoardModelMotionTimeSet(suitMdl, 1.5f);
+            } else {
+                BoardModelMotionTimeSet(suitMdl, 0.0f);
+            }
+        }
+        if (GWPlayer[currItemRestore].com) {
+            var_r26--;
+            if (var_r26 == 0) {
+                break;
+            }
+        } else {
+            if (HuPadBtnDown[GWPlayerCfg[currItemRestore].pad_idx] & 0x100) {
+                break;
+            }
+        }
+        HuPrcVSleep();
+    }
+    BoardModelAttrSet(suitMdl, 0x40000002);
+    HuAudFXPlay(0x316);
+    HuWinKill(temp_r28);
+    omVibrate(temp_r27, 0xC, 6, 6);
+    if (var_r30 != 0) {
+        BoardPlayerAutoSizeSet(temp_r27, 2);
+    } else {
+        BoardPlayerAutoSizeSet(temp_r27, 1);
+    }
+    HuPrcSleep(30);
+    BoardUiInlineFunc02();
+    BoardModelKill(suitMdl);
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
+}
+
+// https://decomp.me/scratch/QqVh2
+static void ExecItemPipe(void) {
+}
+
+// https://decomp.me/scratch/r8MWA
+static void ExecItemSwap(void) {
+    (void) 0.033333335f;
+    (void) 3.3333333f;
+    (void) 5.0f;
+    (void) 0.05f;
+    (void) 0.65f;
+    (void) 1.08f;
+    (void) 19.0f;
+    (void) 0.06666667f;
+    (void) 0.25f;
+    (void) 8.0f;
+    (void) 0.044444446f;
+    (void) 45.0f;
+    (void) 0.94f;
+    (void) 6.0f;
+    (void) 0.6f;
+    (void) 255.0f;
+    (void) 1.02f;
+    (void) 5.6666665f;
+    (void) 4503601774854144.0;
+    (void) 106.0;
+}
+
+void ExecItemSpark(void) {
+    Vec sp68;
+    Vec sp5C;
+    Vec sp50;
+    Vec sp44;
+    Vec sp38;
+    Vec sp2C;
+    Vec sp20;
+    float var_f31;
+    float var_f30;
+    s32 temp_r28;
+    s16 temp_r30;
+    s32 i;
+
+    temp_r30 = BoardModelCreate(0x70067, NULL, 0);
+    BoardModelLayerSet(temp_r30, 3);
+    BoardModelVisibilitySet(temp_r30, 0);
+    HuAudFXPlay(0x350);
+    suitMdl = BoardModelCreate(itemMdlTbl[currItem], lbl_801D37A0, 0);
+    BoardModelLayerSet(suitMdl, 2);
+    ItemShowProc(NULL, NULL);
+    temp_r28 = GWPlayer[currItemRestore].space_curr;
+    sp38.x = sp38.y = sp38.z = 1.0f;
+    for (i = 0; i < 0x1E; i++) {
+        sp38.x += 0.033333335f;
+        sp38.y += 0.033333335f;
+        sp38.z += 0.033333335f;
+        BoardModelScaleSetV(suitMdl, &sp38);
+        HuPrcVSleep();
+    }
+    sp38.x = sp38.y = sp38.z = 2.0f;
+    BoardModelScaleSetV(suitMdl, &sp38);
+    HuAudFXPlay(0x31A);
+    BoardPlayerPosGet(currItemRestore, &sp44);
+    BoardSpaceCornerPosGet(temp_r28, 0, &sp50);
+    BoardPlayerPosLerpStart(currItemRestore, &sp44, &sp50, 0x14);
+    while (GWPlayer[currItemRestore].moving) {
+        HuPrcVSleep();
+    }
+    BoardPlayerMotBlendSet(currItemRestore, 0, 7);
+    while (!BoardPlayerMotBlendCheck(currItemRestore)) {
+        HuPrcVSleep();
+    }
+    BoardRotateDiceNumbers(currItemRestore);
+    BoardSpacePosGet(0, temp_r28, &sp5C);
+    BoardModelPosSetV(temp_r30, &sp5C);
+    sp5C.y += 106.0f;
+    BoardModelPosGet(suitMdl, &sp68);
+    var_f30 = -3.0f;
+    while (1) {
+        sp68.y += var_f30;
+        if (sp68.y <= sp5C.y) {
+            break;
+        }
+        BoardModelPosSetV(suitMdl, &sp68);
+        var_f30 *= 1.08f;
+        HuPrcVSleep();
+    }
+    sp68.y = sp5C.y;
+    BoardModelPosSetV(suitMdl, &sp68);
+    sp5C.y -= 106.0f;
+    BoardSpaceRotGet(0, GWPlayer[currItemRestore].space_curr, &sp20);
+    BoardModelRotSetV(suitMdl, &sp20);
+    BoardModelPosGet(suitMdl, &sp2C);
+    sp2C.z += 106.0 * sin(M_PI * sp20.x / 180.0);
+    sp2C.x -= 106.0 * sin(M_PI * sp20.z / 180.0);
+    BoardModelPosSetV(suitMdl, &sp2C);
+    HuAudFXPlay(0x31B);
+    BoardModelMotionStart(suitMdl, 1, 0);
+    BoardModelMotionTimeSet(suitMdl, 0.0f);
+    while (BoardModelMotionTimeGet(suitMdl) < BoardModelMotionMaxTimeGet(suitMdl)) {
+        HuPrcVSleep();
+    }
+    for (i = 0; i < 4; i++) {
+        omVibrate(i, 0xC, 4, 2);
+    }
+    HuAudFXPlay(0x31C);
+    BoardModelVisibilitySet(temp_r30, 1);
+    BoardModelMotionTimeSet(temp_r30, 0.0f);
+    while (BoardModelMotionTimeGet(temp_r30) < BoardModelMotionMaxTimeGet(temp_r30)) {
+        HuPrcVSleep();
+    }
+    var_f31 = 255.0f;
+    for (i = 0; i < 0x2D; i++) {
+        var_f31 -= 5.6666665f;
+        BoardModelAlphaSet(suitMdl, var_f31);
+        HuPrcVSleep();
+    }
+    BoardModelAlphaSet(suitMdl, 0);
+    BoardUiInlineFunc03(currItemRestore);
+    BoardModelKill(suitMdl);
+    BoardModelKill(temp_r30);
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
+}
+
+static void ExecItemLight(void) {
+    s16 temp_r31;
+
+    HuAudFXPlay(0x350);
+    ItemShowProc(NULL, NULL);
+    BoardWinCreateChoice(2, 0x12000F, -1, 0);
+    BoardWinInsertMesSet(0x80008, 3);
+    if (GWPlayer[currItemRestore].com) {
+        BoardComKeySetRight();
+    }
+    BoardWinWait();
+    temp_r31 = BoardWinChoiceGet();
+    BoardWinKill();
+    if (temp_r31 == -1 || temp_r31 == 0) {
+        BoardPlayerItemAdd(boardItemUser, currItem);
+    }
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
+}
+
+// https://decomp.me/scratch/gbgTk
+static void ExecItemWhistle(void) {
+    (void) 0.003921569f;
+    (void) 0.5f;
+    (void) 120.0f;
+    (void) 120.0;
+    (void) 100.0f;
+    (void) 90.0f;
+    (void) 200.0f;
+    (void) 0.03448276f;
+    (void) 30.0f;
+    (void) 95.0f;
+    (void) 185.0f;
+    (void) 275.0f;
+    (void) -1.0f;
+    (void) -35.0f;
+    (void) 0.16f;
+    (void) 1.0;
+    (void) 4.0f;
+    (void) 4.5f;
+    (void) 1.7f;
+    (void) 0.083333336f;
+    (void) 0.945f;
+    (void) 500.0f;
+}
+
+static void ExecItemBowser(void) {
+    Vec sp2C;
+    Vec sp20;
+    Vec sp14;
+    Vec sp8;
+    float var_f31;
+    s16 temp_r31;
+    s32 var_r29;
+    s32 i;
+
+    BoardBowserSuitInit(currItemRestore);
+    suitMdl = BoardBowserSuitModelGet();
+    temp_r31 = BoardBowserSuitPlayerModelGet();
+    suitMot[0] = BoardModelMotionCreate(suitMdl, 0x4001C);
+    suitMot[1] = BoardModelMotionCreate(suitMdl, 0x4001D);
+    suitCommonMot[0] = BoardModelMotionCreate(temp_r31, suitMotTbl[GWPlayer[currItemRestore].character][0]);
+    suitCommonMot[1] = BoardModelMotionCreate(temp_r31, suitMotTbl[GWPlayer[currItemRestore].character][1]);
+    BoardModelVisibilitySet(temp_r31, 0);
+    HuAudFXPlay(0x350);
+    sp20.x = sp20.y = sp20.z = 0.3f;
+    ItemShowProc(NULL, &sp20);
+    for (i = 0; i < 0x1E; i++) {
+        sp20.x += 0.023333333f;
+        sp20.y += 0.023333333f;
+        sp20.z += 0.023333333f;
+        BoardModelScaleSetV(suitMdl, &sp20);
+        HuPrcVSleep();
+    }
+    sp20.x = sp20.y = sp20.z = 1.0f;
+    BoardModelScaleSetV(suitMdl, &sp20);
+    HuAudFXPlay(0x325);
+    var_r29 = GWPlayer[currItemRestore].space_curr;
+    BoardSpacePosGet(0, var_r29, &sp14);
+    BoardModelPosGet(suitMdl, &sp2C);
+    var_f31 = -4.0f;
+    sp8.x = sp8.y = sp8.z = 1.0f;
+    while (1) {
+        sp2C.y += var_f31;
+        if (sp2C.y <= sp14.y + 100.0f) {
+            sp8.y = (sp2C.y - sp14.y) / 100.0f;
+            BoardPlayerScaleSetV(currItemRestore, &sp8);
+        }
+        if (sp2C.y <= sp14.y) {
+            break;
+        }
+        BoardModelPosSetV(suitMdl, &sp2C);
+        var_f31 *= 1.09f;
+        HuPrcVSleep();
+    }
+    sp2C.y = sp14.y;
+    BoardModelPosSetV(suitMdl, &sp2C);
+    BoardModelVisibilitySet(BoardPlayerModelGet(currItemRestore), 0);
+    omVibrate(currItemRestore, 0xC, 4, 2);
+    HuAudFXPlay(0x326);
+    BoardModelVisibilitySet(temp_r31, 1);
+    BoardModelHookSet(suitMdl, "itemhook_head", temp_r31);
+    BoardModelMotionShiftSet(suitMdl, suitMot[1], 0.0f, 5.0f, 0);
+    BoardModelMotionShiftSet(temp_r31, suitCommonMot[1], 0.0f, 5.0f, 0);
+    while (!BoardModelMotionEndCheck(suitMdl)) {
+        HuPrcVSleep();
+    }
+    BoardModelMotionShiftSet(suitMdl, suitMot[0], 0.0f, 5.0f, 0);
+    BoardModelMotionShiftSet(temp_r31, suitCommonMot[0], 0.0f, 5.0f, 0);
+    HuPrcSleep(0x28);
+    HuAudPlayerVoicePlay(currItemRestore, 0x129);
+    omVibrate(currItemRestore, 0xC, 4, 2);
+    HuPrcSleep(0x3C);
+    BoardModelMotionShiftSet(suitMdl, 0, 0.0f, 5.0f, 0x40000001);
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
+}
+
+// DATA + 0x218
+// ...
+static u8 data_offset_temp[0xC] = { 0 };
+
+// https://decomp.me/scratch/0M6lm
+static void ExecItemBooBall(void) {
+    (void) 4.25f;
+    (void) 0.016666668f;
+    (void) 0.33333334f;
+    (void) 8.5f;
+    (void) 0.6666667f;
+    (void) 325.0f;
+    (void) -0.5f;
+    (void) 40.0f;
+    (void) 125.0f;
+    (void) booBallPos;
+    (void) booBallScale;
+}
+
+static void LampParticleUpdate(s32 arg0, ParticleData *arg1) {
+    HsfanimStruct01 *var_r31;
+    Vec spC;
+    float sp8;
+    float temp_f31;
+    float temp_f30;
+    s32 i;
+    s32 j;
+
+    if (arg1->unk_34 == 0) {
+        var_r31 = arg1->unk_48;
+        for (i = 0; i < arg1->unk_30; i++, var_r31++) {
+            var_r31->unk2C = 0.0f;
+            var_r31->unk40.a = 0;
+        }
+        arg1->unk_04 = 0.0f;
+        arg1->unk_00 = 0;
+    }
+    if (arg1->unk_00 == 0) {
+        arg1->unk_00 = 2;
+        BoardModelRotGet(suitMdl, &spC);
+        for (i = 0; i < 2; i++) {
+            var_r31 = arg1->unk_48;
+            for (j = 0; j < arg1->unk_30; j++, var_r31++) {
+                if (var_r31->unk2C == 0.0f) {
+                    break;
+                }
+            }
+            if (j != arg1->unk_30) {
+                var_r31->unk34.x = 60.0 * sin((spC.y - 90.0f) * M_PI / 180.0);
+                var_r31->unk34.y = 30.0f;
+                var_r31->unk34.z = 60.0 * cos((spC.y - 90.0f) * M_PI / 180.0);
+                sp8 = 12.0f;
+                var_r31->unk08.x = 12.0 * cos((i * 110.0f + 35.0f) * M_PI / 180.0);
+                var_r31->unk08.y = 12.0 * sin((i * 110.0f + 35.0f) * M_PI / 180.0);
+                var_r31->unk08.z = 3.0f + (frand() & 0xFF) * 5.0f * 0.003921569f;
+                var_r31->unk14.y = 255.0f;
+                var_r31->unk2C = 25.0f;
+                temp_f30 = 175.0f + (frand() & 0xFF) * 0x50 * 0.003921569f;
+                var_r31->unk40.r = var_r31->unk40.g = var_r31->unk40.b = temp_f30;
+                var_r31->unk00_s16 = 0;
+            }
+        }
+    } else {
+        arg1->unk_00--;
+    }
+    var_r31 = arg1->unk_48;
+    for (i = 0; i < arg1->unk_30; i++, var_r31++) {
+        if (var_r31->unk2C != 0.0f) {
+            if (var_r31->unk00_s16 == 0) {
+                PSVECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34);
+                PSVECScale(&var_r31->unk08, &var_r31->unk08, 0.95f);
+                var_r31->unk2C += 8.0f;
+                var_r31->unk14.y -= 2.8333333f;
+                if (var_r31->unk14.y <= 120.0f) {
+                    var_r31->unk14.y = 200.0f;
+                    temp_f31 = (frand() & 0xFF) * 180.0f * 0.003921569f;
+                    var_r31->unk08.x = 6.0 * cos(temp_f31 * M_PI / 180.0);
+                    var_r31->unk08.y = -4.0f;
+                    var_r31->unk08.z = 6.0 * sin(temp_f31 * M_PI / 180.0);
+                    var_r31->unk00_s16 = 1;
+                }
+                var_r31->unk40.a = var_r31->unk14.y;
+            } else {
+                PSVECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34);
+                var_r31->unk2C += 0.2f;
+                var_r31->unk14.y -= 1.8214285f;
+                if (var_r31->unk14.y <= 55.0f) {
+                    var_r31->unk14.y = 0.0f;
+                    var_r31->unk2C = 0.0f;
+                }
+                var_r31->unk40.a = var_r31->unk14.y;
+            }
+        }
+    }
+}
+
+static void GenieParticleUpdate(s32 arg0, ParticleData *arg1) {
+    HsfanimStruct01* var_r31;
+    float temp_f31;
+    float temp_f30;
+    s32 var_r28;
+    s32 i;
+
+    if (arg1->unk_34 == 0) {
+        var_r31 = arg1->unk_48;
+        for (i = 0; i < arg1->unk_30; i++, var_r31++) {
+            var_r31->unk34.x = -50.0f + (frand() & 0xFF) * 100.0f * 0.003921569f;
+            var_r31->unk34.y = -50.0f + (frand() & 0xFF) * 100.0f * 0.003921569f;
+            var_r31->unk34.z = -10.0f + (frand() & 0xFF) * 20.0f * 0.003921569f;
+            temp_f31 = 0.5f + (frand() & 0xFF) * 3.0f * 0.003921569f;
+            var_r31->unk08.x = temp_f31 * cos((i * 110.0f + 35.0f) * M_PI / 180.0);
+            var_r31->unk08.y = temp_f31 * sin((i * 110.0f + 35.0f) * M_PI / 180.0);
+            var_r31->unk08.z = 0.0f;
+            var_r31->unk14.y = 255.0f;
+            temp_f30 = 125.0f + (frand() & 0xFF) * 0x64 * 0.003921569f;
+            var_r31->unk40.r = var_r31->unk40.g = var_r31->unk40.b = temp_f30;
+            var_r31->unk00 = 0;
+            var_r31->unk2C = 80.0f + (frand() & 0xFF) * 60.0f * 0.003921569f;
+        }
+    }
+    var_r31 = arg1->unk_48;
+    var_r28 = 0;
+    for (i = 0; i < arg1->unk_30; i++, var_r31++) {
+        if (var_r31->unk2C != 0.0f) {
+            var_r28++;
+            PSVECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34);
+            PSVECScale(&var_r31->unk08, &var_r31->unk08, 0.995f);
+            var_r31->unk2C -= 0.2f;
+            var_r31->unk14.y -= 1.59375f;
+            if (var_r31->unk14.y <= 20.0f) {
+                var_r31->unk14.y = 0.0f;
+                var_r31->unk2C = 0.0f;
+            }
+            var_r31->unk40.a = var_r31->unk14.y;
+        }
+    }
+    if (var_r28 == 0) {
+        arg1->unk_02 = 0;
+    }
+}
+
+// DATA + 0x224
+static Vec shadowPos = { 0.0f, 4500.0f, 500.0f };
+static Vec shadowTarget = { 0.0f, 0.9f, -0.1f };
+static Vec shadowUp = { 0.0f, 0.0f, 500.0f };
+
+static void GenieCameraProcInlineFunc(void) {
+    Hu3DShadowPosSet(&shadowPos, &shadowTarget, &shadowUp);
+}
+
+static void GenieCameraProc(void) {
+    while (1) {
+        Hu3DCameraPerspectiveSet(2, genieFov, 10.0f, 20000.0f, 1.2f);
+        Hu3DCameraPosSetV(2, &booCamPos, &booCamTarget, &booCamUp);
+        Hu3DShadowData.unk_08.x = genieFov;
+        C_MTXLightPerspective(Hu3DShadowData.unk_68, Hu3DShadowData.unk_08.x, 1.2f, 0.5f, -0.5f, 0.5f, 0.5f);
+        GenieCameraProcInlineFunc();
+        Hu3DShadowTPLvlSet(0.8f);
+        HuPrcVSleep();
+    }
+}
+
+static void GenieCameraCalc(UnkGenieCameraStruct *arg0, s32 arg1, float arg2, Vec *arg3, Vec *arg4) {
+    Vec spC = { 0.0f, 0.0f, 0.0f };
+    float temp_f31 = arg2 * arg2;
+    float sp8 = temp_f31 * arg2;
+    Vec *temp_r31;
+    Vec *temp_r30;
+    Vec *temp_r29;
+    Vec *temp_r28;
+    Vec *temp_r27;
+    Vec *temp_r26;
+    Vec *temp_r25;
+    Vec *temp_r24;
+
+    if (arg1 == 0) {
+        temp_r31 = &arg0[arg1].unk04;
+        temp_r29 = &arg0[arg1 + 1].unk04;
+        temp_r28 = &arg0[arg1 + 2].unk04;
+        temp_r30 = &arg0[arg1].unk10;
+        temp_r27 = &arg0[arg1 + 1].unk10;
+        temp_r26 = &arg0[arg1 + 2].unk10;
+        arg3->x = 0.5f * ((temp_r31->x - temp_r29->x * 2.0f + temp_r28->x) * temp_f31 + (temp_r31->x * -3.0f + temp_r29->x * 4.0f - temp_r28->x) * arg2 + temp_r31->x * 2.0f);
+        arg3->y = 0.5f * ((temp_r31->y - temp_r29->y * 2.0f + temp_r28->y) * temp_f31 + (temp_r31->y * -3.0f + temp_r29->y * 4.0f - temp_r28->y) * arg2 + temp_r31->y * 2.0f);
+        arg3->z = 0.5f * ((temp_r31->z - temp_r29->z * 2.0f + temp_r28->z) * temp_f31 + (temp_r31->z * -3.0f + temp_r29->z * 4.0f - temp_r28->z) * arg2 + temp_r31->z * 2.0f);
+        arg4->x = 0.5f * ((temp_r30->x - temp_r27->x * 2.0f + temp_r26->x) * temp_f31 + (temp_r30->x * -3.0f + temp_r27->x * 4.0f - temp_r26->x) * arg2 + temp_r30->x * 2.0f);
+        arg4->y = 0.5f * ((temp_r30->y - temp_r27->y * 2.0f + temp_r26->y) * temp_f31 + (temp_r30->y * -3.0f + temp_r27->y * 4.0f - temp_r26->y) * arg2 + temp_r30->y * 2.0f);
+        arg4->z = 0.5f * ((temp_r30->z - temp_r27->z * 2.0f + temp_r26->z) * temp_f31 + (temp_r30->z * -3.0f + temp_r27->z * 4.0f - temp_r26->z) * arg2 + temp_r30->z * 2.0f);
+    } else {
+        temp_r31 = &arg0[arg1 - 1].unk04;
+        temp_r29 = &arg0[arg1].unk04;
+        temp_r28 = &arg0[arg1 + 1].unk04;
+        temp_r25 = &arg0[arg1 + 2].unk04;
+        temp_r30 = &arg0[arg1 - 1].unk10;
+        temp_r27 = &arg0[arg1].unk10;
+        temp_r26 = &arg0[arg1 + 1].unk10;
+        temp_r24 = &arg0[arg1 + 2].unk10;
+        arg3->x = 0.5f * ((-temp_r31->x + temp_r29->x * 3.0f - temp_r28->x * 3.0f + temp_r25->x) * temp_f31 * arg2 + (temp_r31->x * 2.0f - temp_r29->x * 5.0f + temp_r28->x * 4.0f - temp_r25->x) * temp_f31 + (-temp_r31->x + temp_r28->x) * arg2 + temp_r29->x * 2.0f);
+        arg3->y = 0.5f * ((-temp_r31->y + temp_r29->y * 3.0f - temp_r28->y * 3.0f + temp_r25->y) * temp_f31 * arg2 + (temp_r31->y * 2.0f - temp_r29->y * 5.0f + temp_r28->y * 4.0f - temp_r25->y) * temp_f31 + (-temp_r31->y + temp_r28->y) * arg2 + temp_r29->y * 2.0f);
+        arg3->z = 0.5f * ((-temp_r31->z + temp_r29->z * 3.0f - temp_r28->z * 3.0f + temp_r25->z) * temp_f31 * arg2 + (temp_r31->z * 2.0f - temp_r29->z * 5.0f + temp_r28->z * 4.0f - temp_r25->z) * temp_f31 + (-temp_r31->z + temp_r28->z) * arg2 + temp_r29->z * 2.0f);
+        arg4->x = 0.5f * ((-temp_r30->x + temp_r27->x * 3.0f - temp_r26->x * 3.0f + temp_r24->x) * temp_f31 * arg2 + (temp_r30->x * 2.0f - temp_r27->x * 5.0f + temp_r26->x * 4.0f - temp_r24->x) * temp_f31 + (-temp_r30->x + temp_r26->x) * arg2 + temp_r27->x * 2.0f);
+        arg4->y = 0.5f * ((-temp_r30->y + temp_r27->y * 3.0f - temp_r26->y * 3.0f + temp_r24->y) * temp_f31 * arg2 + (temp_r30->y * 2.0f - temp_r27->y * 5.0f + temp_r26->y * 4.0f - temp_r24->y) * temp_f31 + (-temp_r30->y + temp_r26->y) * arg2 + temp_r27->y * 2.0f);
+        arg4->z = 0.5f * ((-temp_r30->z + temp_r27->z * 3.0f - temp_r26->z * 3.0f + temp_r24->z) * temp_f31 * arg2 + (temp_r30->z * 2.0f - temp_r27->z * 5.0f + temp_r26->z * 4.0f - temp_r24->z) * temp_f31 + (-temp_r30->z + temp_r26->z) * arg2 + temp_r27->z * 2.0f);
+    }
+}
+
+// DATA + 0x248
+static s32 armUpMotTbl[] = {
+    0x005F005C,
+    0x001A005C,
+    0x006D005C,
+    0x008A005C,
+    0x0085005C,
+    0x0011005C,
+    0x000D005C,
+    0x0081005C
+};
+
+// DATA + 0x268
+static s32 scareMotTbl[] = {
+    0x005F001C,
+    0x001A001C,
+    0x006D001C,
+    0x008A001C,
+    0x0085001C,
+    0x0011001C,
+    0x000D001C,
+    0x0081001C
+};
+
+// DATA + 0x288
+static s32 impactMotTbl[] = {
+    0x005F005E,
+    0x001A005E,
+    0x006D005E,
+    0x008A005E,
+    0x0085005E,
+    0x0011005E,
+    0x000D005E,
+    0x0081005E
+};
+
+// DATA + 0x2A8
+static UnkGenieCameraStruct cameraDataTbl[] = {
+    60.0f, {    0.0f, 100.0f,  950.0f }, { 0.0f, 100.0f, 600.0f },
+    60.0f, { -353.0f, 100.0f,  662.5f }, { 0.0f, 100.0f, 600.0f },
+    60.0f, { -500.0f, 100.0f,  375.0f }, { 0.0f, 100.0f, 600.0f },
+    60.0f, { -353.0f, 100.0f,   87.5f }, { 0.0f, 100.0f, 600.0f },
+     1.0f, {    0.0f, 100.0f, -200.0f }, { 0.0f, 100.0f, 600.0f },
+    89.0f, {    0.0f, 100.0f, -200.0f }, { 0.0f, 100.0f, 600.0f },
+     1.0f, {    0.0f, 100.0f, -200.0f }, { 0.0f, 100.0f, 600.0f },
+     9.0f, {    0.0f, 100.0f, -200.0f }, { 0.0f, 100.0f, 600.0f },
+     1.0f, {    0.0f, 100.0f, -200.0f }, { 0.0f, 500.0f, 600.0f },
+     5.0f, {    0.0f, 100.0f, -200.0f }, { 0.0f, 500.0f, 600.0f },
+     5.0f, {    0.0f, 100.0f, -200.0f }, { 0.0f, 500.0f, 600.0f }
+};
+
+// DATA + 0x3DC
+static s32 genieMotTbl[] = {
+    0x0007007D,
+    0x0007007E,
+    0x0007007F,
+    -1
+};
+
+static void GenieSceneExec(void) {
+    GXColor sp1C = { 0xFF, 0xFF, 0xFF, 0xFF };
+    Vec sp50;
+    Vec sp44;
+    Vec sp38;
+    Vec sp2C;
+    Vec sp20;
+    Process *temp_r21;
+    float temp_f30;
+    float var_f31;
+    s16 temp_r25;
+    s16 temp_r28;
+    s16 temp_r24;
+    s16 temp_r27;
+    s16 var_r22;
+    s16 temp_r20;
+    s32 var_r26;
+    s32 i;
+    ParticleData *temp_r23;
+
+    BoardModelHideSetAll(1);
+    BoardSpaceHide(1);
+    for (i = 0; i < 4; i++) {
+        BoardStatusShowSet(i, 0);
+    }
+    BoardLightResetExec();
+    temp_r25 = BoardModelCreate(0x70080, NULL, 0);
+    sp50.x = sp50.y = sp50.z = 0.0f;
+    BoardModelPosSetV(temp_r25, &sp50);
+    BoardModelCameraSet(temp_r25, 2);
+    Hu3DModelAmbSet(BoardModelIDGet(temp_r25), 1.0f, 1.0f, 1.0f);
+    temp_r24 = BoardModelCreate(0x70081, NULL, 0);
+    BoardModelPosSetV(temp_r24, &sp50);
+    BoardModelCameraSet(temp_r24, 2);
+    Hu3DModelAmbSet(BoardModelIDGet(temp_r24), 1.0f, 1.0f, 1.0f);
+    temp_r28 = BoardModelCreate(0x7007C, genieMotTbl, 0);
+    sp50.x = sp50.y = 0.0f;
+    sp50.z = 600.0f;
+    sp44.x = sp44.z = 0.0f;
+    sp44.y = 180.0f;
+    BoardModelPosSetV(temp_r28, &sp50);
+    BoardModelRotSetV(temp_r28, &sp44);
+    BoardModelCameraSet(temp_r28, 2);
+    BoardModelAttrSet(temp_r28, 0x40000001);
+    sp38.x = sp38.y = sp38.z = 0.0f;
+    BoardPlayerCameraSet(currItemRestore, 2);
+    BoardPlayerPosSetV(currItemRestore, &sp38);
+    BoardModelVisibilitySet(BoardPlayerModelGet(currItemRestore), 1);
+    PSVECSubtract(&shadowUp, &shadowPos, &sp2C);
+    PSVECNormalize(&sp2C, &sp2C);
+    temp_r20 = Hu3DGLightCreateV(&shadowPos, &sp2C, &sp1C);
+    Hu3DShadowCreate(60.0f, 10.0f, 20000.0f);
+    Hu3DModelShadowSet(BoardModelIDGet(BoardPlayerModelGet(currItemRestore)));
+    Hu3DModelShadowSet(BoardModelIDGet(temp_r28));
+    Hu3DModelShadowMapSet(BoardModelIDGet(temp_r25));
+    Hu3DShadowSizeSet(0xF0);
+    Hu3DCameraCreate(2);
+    booCamPos.x = 0.0f;
+    booCamPos.y = 100.0f;
+    booCamPos.z = 950.0f;
+    booCamTarget.x = booCamTarget.z = 0.0f;
+    booCamTarget.y = 1.0f;
+    booCamUp.x = 0.0f;
+    booCamUp.y = 100.0f;
+    booCamUp.z = 600.0f;
+    genieFov = 15.0f;
+    Hu3DShadowData.unk_08.x = genieFov;
+    C_MTXLightPerspective(Hu3DShadowData.unk_68, Hu3DShadowData.unk_08.x, 1.2f, 0.5f, -0.5f, 0.5f, 0.5f);
+    temp_r21 = HuPrcChildCreate(GenieCameraProc, 0x2005, 0x1000, 0, HuPrcCurrentGet());
+    Hu3DBGColorSet(0xFF, 0xFF, 0xFF);
+    temp_r27 = Hu3DParticleCreate(genieParticleAnim, 0x32);
+    Hu3DParticleHookSet(temp_r27, &GenieParticleUpdate);
+    Hu3DParticleBlendModeSet(temp_r27, 1);
+    Hu3DParticleColSet(temp_r27, 0xFF, 0xFF, 0xFF);
+    Hu3DParticleAnimModeSet(temp_r27, 0);
+    Hu3DParticleAttrSet(temp_r27, 1);
+    Hu3DModelLayerSet(temp_r27, 7);
+    Hu3DModelPosSet(temp_r27, booCamPos.x, booCamPos.y, booCamPos.z - 175.0f);
+    temp_r23 = Hu3DData[temp_r27].unk_120;
+    temp_r23->unk_02 = 1;
+    WipeCreate(1, 0, 0x2D);
+    while (WipeStatGet() != 0) {
+        HuPrcVSleep();
+    }
+    BoardMusStart(1, 9, 0x7F, 0);
+    while (temp_r23->unk_02 != 0) {
+        HuPrcVSleep();
+    }
+    HuPrcSleep(0x2D);
+    HuAudPlayerVoicePlay(currItemRestore, 0x128);
+    BoardPlayerMotionStart(currItemRestore, geniePlayerMot[1], 0);
+    BoardPlayerMotionEndWait(currItemRestore);
+    HuPrcSleep(0x19);
+    Hu3DModelKill(temp_r27);
+    for (i = 0; i < 0xA; i++) {
+        genieFov += 4.5f;
+        HuPrcVSleep();
+    }
+    genieFov = 60.0f;
+    HuPrcSleep(0x5A);
+    var_f31 = 0.0f;
+    var_r26 = 0;
+    while (1) {
+        GenieCameraCalc(&cameraDataTbl[0], var_r26, var_f31 / cameraDataTbl[var_r26].unk00, &booCamPos, &booCamUp);
+        var_f31 += 1.0f;
+        if (var_f31 >= cameraDataTbl[var_r26].unk00) {
+            var_r26++;
+            var_f31 = 0.0f;
+        }
+        if (var_r26 >= 8) {
+            break;
+        }
+        HuPrcVSleep();
+    }
+    GenieCameraCalc(&cameraDataTbl[0], var_r26, 1.0f, &booCamPos, &booCamUp);
+    HuPrcSleep(0x96);
+    BoardRotateDiceNumbers(currItemRestore);
+    sp2C = booCamPos;
+    sp20 = booCamUp;
+    booCamUp.x = sp38.x + (sp50.x - sp38.x) * 0.7f;
+    booCamUp.y = sp38.y + 400.0f;
+    booCamUp.z = sp38.z + (sp50.z - sp38.z) * 0.7f;
+    booCamPos.x = booCamUp.x + sin(-5 * M_PI / 9) * 1100.0;
+    booCamPos.y = booCamUp.y + 950.0f;
+    booCamPos.z = booCamUp.z + cos(-5 * M_PI / 9) * 1100.0;
+    HuAudFXPlay(0x356);
+    BoardWinCreate(2, 0x12001B, -1);
+    BoardWinWait();
+    BoardWinKill();
+    booCamUp = sp20;
+    booCamPos = sp2C;
+    HuAudFXPlay(0x33E);
+    HuAudFXPlay(0x367);
+    BoardModelMotionStart(temp_r28, 1, 0);
+    var_r22 = 0;
+    while (BoardModelMotionTimeGet(temp_r28) <= 30.0f) {
+        HuPrcVSleep();
+    }
+    var_f31 = 0.0f;
+    while (1) {
+        temp_f30 = 40.0f - var_f31 * var_f31 * 0.25f * 0.0125f;
+        if (temp_f30 <= 0.0f && var_r22 == 0) {
+            var_r22 = 1;
+            BoardModelMotionShiftSet(temp_r28, 3, 0.0f, 4.0f, 0);
+        }
+        var_f31 += 1.0f;
+        sp50.y += temp_f30;
+        if (sp50.y <= 0.0f) {
+            break;
+        }
+        BoardModelPosSetV(temp_r28, &sp50);
+        booCamUp.y = sp50.y + 140.0f;
+        HuPrcVSleep();
+    }
+    HuAudFXPlay(0x368);
+    sp50.y = 0.0f;
+    BoardModelPosSetV(temp_r28, &sp50);
+    booCamUp.y = sp38.y + 100.0f;
+    BoardModelMotionStart(temp_r28, 2, 0);
+    omVibrate(currItemRestore, 0xC, 0xC, 0);
+    booCamUp.y = 500.0f;
+    HuAudFXPlay(0x35B);
+    HuAudFXPlay((GWPlayer[currItemRestore].character << 6) + 0x123);
+    var_f31 = 0.0f;
+    while (1) {
+        temp_f30 = 60.0f - var_f31 * var_f31 * 0.25f * 0.009166667f;
+        var_f31 += 1.0f;
+        sp38.y += temp_f30;
+        BoardPlayerPosSetV(currItemRestore, &sp38);
+        if (booCamUp.y < 1100.0f) {
+            booCamUp.y = sp38.y + 160.0f;
+        }
+        if (sp38.y >= 2800.0f) {
+            break;
+        }
+        HuPrcVSleep();
+    }
+    WipeCreate(2, 0, 0x2D);
+    BoardAudSeqFadeOut(1, 0x3E8);
+    while (WipeStatGet() != 0) {
+        HuPrcVSleep();
+    }
+    BoardModelKill(temp_r28);
+    BoardModelKill(temp_r25);
+    BoardModelKill(temp_r24);
+    Hu3DCameraKill(2);
+    Hu3DGLightKill(temp_r20);
+    BoardModelHideSetAll(0);
+    BoardSpaceHide(0);
+    for (i = 0; i < 4; i++) {
+        BoardStatusShowSet(i, 1);
+    }
+    HuPrcKill(temp_r21);
+    BoardPlayerCameraSet(currItemRestore, 1);
+    BoardLightSetExec();
+    HuAudFXPauseAll(0);
+}
+
+static void ExecItemGenie(void) {
+    UnkItemShowProcStruct sp24;
+    Vec sp18;
+    Vec spC;
+    ParticleData *sp8;
+    Process *temp_r27;
+    float var_f29;
+    float var_f31;
+    float var_f30;
+    s16 temp_r31;
+    s16 var_r26;
+    s32 temp_r28;
+    s32 temp_r25;
+    s32 var_r30;
+
+    suitMdl = BoardModelCreate(itemMdlTbl[currItem], NULL, 1);
+    BoardModelLayerSet(suitMdl, 2);
+    genieParticleAnim = HuSprAnimRead(HuDataSelHeapReadNum(0x70069, MEMORY_DEFAULT_NUM, HEAP_DATA));
+    HuSprAnimLock(genieParticleAnim);
+    geniePlayerMot[0] = BoardPlayerMotionCreate(currItemRestore, armUpMotTbl[GWPlayer[currItemRestore].character]);
+    geniePlayerMot[1] = BoardPlayerMotionCreate(currItemRestore, scareMotTbl[GWPlayer[currItemRestore].character]);
+    geniePlayerMot[2] = BoardPlayerMotionCreate(currItemRestore, impactMotTbl[GWPlayer[currItemRestore].character]);
+    sp24.unk02 = suitMdl;
+    sp24.unk04 = 4.0f;
+    sp24.unk08 = 3.0f;
+    sp24.unk10 = sp24.unk14 = sp24.unk18 = 0.0f;
+    sp24.unk14 = 4.0f;
+    sp24.unk1C = 1;
+    HuAudFXPlay(0x350);
+    temp_r27 = ItemShowProc(&sp24, NULL);
+    BoardCameraViewSet(3);
+    HuAudFXPlay(0x323);
+    var_r30 = 0;
+    while (1) {
+        if (var_r30 == 0x69) {
+            BoardPlayerMotionStart(currItemRestore, geniePlayerMot[0], 0);
+        }
+        BoardModelRotGet(suitMdl, &spC);
+        if (90.0f - spC.y <= sp24.unk14 && 90.0f - spC.y >= 0.0f && var_r30 >= 0x78) {
+            break;
+        }
+        HuPrcVSleep();
+        var_r30++;
+    }
+    HuAudPlayerVoicePlay(currItemRestore, 0x125);
+    temp_r25 = HuAudFXPlay(0x34D);
+    temp_r31 = Hu3DParticleCreate(genieParticleAnim, 0x96);
+    Hu3DParticleHookSet(temp_r31, &LampParticleUpdate);
+    Hu3DParticleBlendModeSet(temp_r31, 0);
+    Hu3DParticleColSet(temp_r31, 0xFF, 0xFF, 0xFF);
+    Hu3DParticleAnimModeSet(temp_r31, 0);
+    Hu3DParticleAttrSet(temp_r31, 1);
+    Hu3DModelLayerSet(temp_r31, 7);
+    BoardModelPosGet(suitMdl, &spC);
+    Hu3DModelPosSet(temp_r31, spC.x, spC.y, spC.z);
+    sp8 = Hu3DData[temp_r31].unk_120;
+    omVibrate(currItemRestore, 0xB5, 6, 6);
+    HuPrcSleep(0x87);
+    BoardAudSeqPause(0, 1, 0x3E8);
+    HuAudFXStop(temp_r25);
+    HuAudFXPauseAll(1);
+    WipeColorSet(0xFF, 0xFF, 0xFF);
+    WipeCreate(2, 0, 0x2D);
+    while (WipeStatGet() != 0) {
+        HuPrcVSleep();
+    }
+    Hu3DModelKill(temp_r31);
+    BoardModelKill(suitMdl);
+    HuPrcKill(temp_r27);
+    BoardRotateDiceNumbers(currItemRestore);
+    GenieSceneExec();
+    BoardCameraMoveSet(0);
+    BoardCameraViewSet(2);
+    temp_r28 = BoardSpaceStarGetCurr();
+    BoardCameraTargetSpaceSet(temp_r28);
+    GWPlayer[currItemRestore].space_curr = temp_r28;
+    BoardSpacePosGet(0, temp_r28, &spC);
+    sp18 = spC;
+    spC.y += 1000.0f;
+    BoardPlayerPosSetV(currItemRestore, &spC);
+    BoardCameraMotionWait();
+    BoardCameraMoveSet(1);
+    WipeCreate(1, 0, 0x2D);
+    HuPrcSleep(0xF);
+    BoardAudSeqPause(0, 0, 1000);
+    while (WipeStatGet() != 0) {
+        HuPrcVSleep();
+    }
+    HuAudFXPlay(0x35E);
+    fn_8004F578(GWPlayer[currItemRestore].character, 0);
+    BoardPlayerMotionStart(currItemRestore, 6, 0x40000001);
+    var_f29 = 0.0f;
+    var_f31 = 1.0f;
+    var_r26 = 0;
+    while (1) {
+        var_f30 = var_f29 - var_f31 * var_f31 * 0.25f * 0.06666667f;
+        if (var_f30 < -35.0f) {
+            var_f30 = -35.0f;
+        }
+        if (var_f30 > 35.0f) {
+            var_f30 = 35.0f;
+        }
+        var_f31 += 1.0f;
+        spC.y += var_f30;
+        if (spC.y <= sp18.y) {
+            omVibrate(currItemRestore, 0xC, 6, 6);
+            spC.y = sp18.y;
+            var_f29 = -var_f30 * 0.2f;
+            if (fabs(var_f29) <= 5.0) {
+                var_f31 = -1.0f;
+                break;
+            }
+            var_f31 = 1.0f;
+            if (var_r26 == 0) {
+                BoardPlayerMotionStart(currItemRestore, geniePlayerMot[2], 0);
+            }
+        }
+        BoardPlayerPosSetV(currItemRestore, &spC);
+        HuPrcVSleep();
+    }
+    BoardRotateDiceNumbers(currItemRestore);
+    fn_8004F578(GWPlayer[currItemRestore].character, 1);
+    HuSprAnimKill(genieParticleAnim);
+    BoardPlayerMotionKill(currItemRestore, geniePlayerMot[0]);
+    BoardPlayerMotionKill(currItemRestore, geniePlayerMot[1]);
+    BoardPlayerMotionKill(currItemRestore, geniePlayerMot[2]);
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
+}
+
+void BoardItemBagItemSet(s16 *arg0) {
+    s32 i;
+
+    for (i = 0; i < 3; i++) {
+        itemBagItems[i] = arg0[i];
+    }
+}
+
+static void ExecItemBagJump(void) {
+    Vec sp20;
+    Vec sp14;
+    Vec sp8;
+    float temp_f29;
+    float var_f30;
+    float var_f31;
+    s16 temp_r31;
+
+    temp_r31 = (s16) HuPrcCurrentGet()->user_data;
+    BoardModelScaleGet(temp_r31, &sp20);
+    BoardModelPosGet(temp_r31, &sp14);
+    sp8 = sp14;
+    sp8.y += 80.0f;
+    var_f31 = 0.0f;
+    var_f30 = 0.0f;
+    HuAudFXPlay(0x310);
+    while (1) {
+        temp_f29 = 8.0f - var_f30 * var_f30 * 0.25f * 0.075f;
+        var_f31 += 0.1f;
+        if (var_f31 > 1.0f) {
+            var_f31 = 1.0f;
+        }
+        sp20.x = sp20.y = sp20.z = var_f31;
+        sp14.y += temp_f29;
+        BoardModelPosSetV(temp_r31, &sp14);
+        BoardModelScaleSetV(temp_r31, &sp20);
+        var_f30 += 1.0f;
+        if (temp_f29 < 0.0f) {
+            break;
+        }
+        HuPrcVSleep();
+    }
+    CharModelLayerSetAll(3);
+    CharModelCreateParticle(1, &sp14);
+    BoardModelVisibilitySet(temp_r31, 0);
+    HuAudFXPlay(0x30D);
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
+}
+
+static void ExecItemBagShow(void) {
+    Vec sp14;
+    Vec sp8;
+    float var_f31;
+    Process *temp_r31;
+    UnkItemShowProcStruct *temp_r30;
+    UnkItemShowProcStruct *temp_r29;
+
+    temp_r31 = HuPrcCurrentGet()->user_data;
+    temp_r30 = temp_r31->user_data;
+    temp_r30->unk00 = 1;
+    BoardModelPosGet(suitMdl, &sp14);
+    var_f31 = 0.0f;
+    while (1) {
+        if (var_f31 >= 180.0f) {
+            break;
+        }
+        sp8 = sp14;
+        sp8.y += 15.0 * sin(M_PI * var_f31 / 180.0);
+        BoardModelPosSetV(suitMdl, &sp8);
+        var_f31 += 36.0f;
+        HuPrcVSleep();
+    }
+    BoardModelPosSetV(suitMdl, &sp14);
+    temp_r29 = temp_r31->user_data;
+    temp_r29->unk00 = 0;
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
+}
+
+static void ExecItemBag(void) {
+    UnkItemShowProcStruct sp3C;
+    Vec sp30;
+    Vec sp24;
+    Vec sp18;
+    float temp_f31;
+    float sp10[2];
+    s16 sp8[3];
+    s16 temp_r28;
+    s16 temp_r27;
+    s16 var_r26;
+    s16 var_r30;
+    s16 temp_r23;
+    s16 i;
+    u16 var_r25;
+    Process *temp_r29;
+    Process *temp_r24;
+
+    for (i = 0; i < 3; i++) {
+        if (itemBagItems[i] == -1) {
+            itemBagItems[i] = rand8() % 13;
+        }
+    }
+    temp_r23 = GWPlayer[currItemRestore].port;
+    suitMdl = BoardModelCreate(itemMdlTbl[currItem], NULL, 1);
+    BoardModelLayerSet(suitMdl, 2);
+    BoardCameraRotGet(&sp18);
+    BoardModelRotYSet(suitMdl, sp18.y);
+    temp_r27 = var_r30 = 3 - BoardPlayerItemCount(currItemRestore);
+    for (i = 0; i < temp_r27; i++) {
+        sp8[i] = BoardModelCreate(itemMdlTbl[itemBagItems[i]], NULL, 1);
+        if (itemBagItems[i] == 0xB) {
+            BoardModelAttrSet(sp8[i], 0x40000001);
+        }
+        if (itemBagItems[i] == 5) {
+            temp_f31 = -50.0f;
+            Hu3DData[BoardModelIDGet(sp8[i])].unk_F0[1][3] = temp_f31;
+        }
+        BoardModelRotYSet(sp8[i], sp18.y);
+        BoardModelLayerSet(sp8[i], 2);
+        BoardModelVisibilitySet(sp8[i], 0);
+    }
+    sp3C.unk02 = suitMdl;
+    sp3C.unk04 = 2.0f;
+    sp3C.unk08 = 5.0f;
+    sp3C.unk10 = sp3C.unk14 = sp3C.unk18 = 0.0f;
+    sp3C.unk1C = 0;
+    HuAudFXPlay(0x350);
+    temp_r24 = ItemShowProc(&sp3C, NULL);
+    HuWinMesMaxSizeGet(1, sp10, 0x120014);
+    temp_r28 = HuWinCreate(-10000.0f, 320.0f, sp10[0], sp10[1], 0);
+    HuWinMesSet(temp_r28, 0x120014);
+    HuWinBGTPLvlSet(temp_r28, 0.0f);
+    HuWinMesSpeedSet(temp_r28, 0);
+    var_r26 = frandmod(0x28) + 0x1E;
+    var_r30 = 0;
+    sp24.x = sp24.y = sp24.z = 0.0f;
+    while (var_r30 < temp_r27) {
+        if (GWPlayerCfg[currItemRestore].iscom == 1) {
+            if (--var_r26 == 0) {
+                var_r25 = 0x100;
+                var_r26 = frandmod(0x28) + 0x1E;
+            }
+        } else {
+            var_r25 = HuPadBtnDown[temp_r23];
+        }
+        if (!(var_r25 & 0x100)) {
+            HuPrcVSleep();
+        } else {
+            BoardPlayerDiceJumpStart(currItemRestore);
+            while (!BoardPlayerDiceJumpCheck(currItemRestore)) {
+                HuPrcVSleep();
+            }
+            HuAudFXPlay(0x324);
+            BoardModelPosGet(suitMdl, &sp30);
+            BoardModelPosSetV(sp8[var_r30], &sp30);
+            BoardModelScaleSetV(sp8[var_r30], &sp24);
+            BoardModelVisibilitySet(sp8[var_r30], 1);
+            temp_r29 = HuPrcChildCreate(ExecItemBagJump, 0x2004, 0x1000, 0, HuPrcCurrentGet());
+            temp_r29->user_data = (void*) sp8[var_r30];
+            temp_r29 = HuPrcChildCreate(ExecItemBagShow, 0x2004, 0x1000, 0, HuPrcCurrentGet());
+            temp_r29->user_data = temp_r24;
+            while (GWPlayer[currItemRestore].field08_bit3) {
+                HuPrcVSleep();
+            }
+            HuPrcChildWatch();
+            BoardPlayerItemAdd(currItemRestore, itemBagItems[var_r30]);
+            BoardPlayerMotionShiftSet(currItemRestore, 1, 0.0f, 10.0f, 0x40000001);
+            HuPrcSleep(0xA);
+            var_r30++;
+        }
+    }
+    HuWinKill(temp_r28);
+    BoardModelPosGet(suitMdl, &sp30);
+    CharModelLayerSetAll(3);
+    CharModelCreateParticle(1, &sp30);
+    HuAudFXPlay(0x351);
+    HuPrcSleep(0xA);
+    HuPrcKill(temp_r24);
+    BoardModelKill(suitMdl);
+    for (i = 0; i < temp_r27; i++) {
+        BoardModelKill(sp8[i]);
+    }
+    HuPrcSleep(0x1E);
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
+}
+
+static void RestoreItemNull(void) {
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
+}
+
+static void RestoreItemMini(void) {
+    HuAudFXPlay(0x311);
+    ItemSizeSet(0);
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
+}
+
+static void RestoreItemMega(void) {
+    HuAudFXPlay(0x313);
+    ItemSizeSet(0);
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
+}
+
+static void RestoreItemMiniSuper(void) {
+    HuAudFXPlay(0x311);
+    ItemSizeSet(0);
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
+}
+
+static void RestoreItemMegaSuper(void) {
+    HuAudFXPlay(0x313);
+    ItemSizeSet(0);
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
+}
+
+static void RestoreItemBowser(void) {
+    Vec sp20;
+    Vec sp14;
+    Vec sp8;
+    s16 temp_r31;
+    s16 temp_r29;
+    s16 i;
+
+    temp_r31 = BoardModelCreate(0x70063, NULL, 0);
+    BoardModelVisibilitySet(temp_r31, 0);
+    BoardModelLayerSet(temp_r31, 3);
+    BoardPlayerPosGet(currItemRestore, &sp14);
+    sp20.x = sp20.y = sp20.z = 0.0f;
+    sp14.y += 100.0f;
+    BoardModelPosSetV(temp_r31, &sp14);
+    BoardModelScaleSetV(temp_r31, &sp20);
+    BoardModelAttrSet(temp_r31, 0x40000001);
+    BoardModelAttrSet(temp_r31, 0x400000);
+    suitMdl = BoardBowserSuitModelGet();
+    temp_r29 = BoardBowserSuitPlayerModelGet();
+    BoardModelMotionShiftSet(suitMdl, suitMot[0], 0.0f, 5.0f, 0);
+    BoardModelMotionShiftSet(temp_r29, suitCommonMot[0], 0.0f, 5.0f, 0);
+    HuPrcSleep(0x28);
+    HuAudPlayerVoicePlay(currItemRestore, 0x129);
+    HuPrcSleep(0x14);
+    HuAudFXPlay(0x32B);
+    BoardModelVisibilitySet(temp_r31, 1);
+    for (i = 0; i < 0x3C; i++) {
+        sp20.x += 0.15f;
+        sp20.y += 0.15f;
+        sp20.z += 0.15f;
+        BoardModelScaleSetV(temp_r31, &sp20);
+        HuPrcVSleep();
+    }
+    sp20.x = sp20.y = sp20.z = 9.0f;
+    BoardModelScaleSetV(temp_r31, &sp20);
+    HuPrcSleep(0x3C);
+    HuAudFXPlay(0x313);
+    BoardModelHookReset(suitMdl);
+    BoardBowserSuitKill(currItemRestore);
+    sp8.x = sp8.y = sp8.z = 1.0f;
+    BoardPlayerScaleSetV(currItemRestore, &sp8);
+    BoardModelVisibilitySet(BoardPlayerModelGet(currItemRestore), 1);
+    for (i = 0; i < 0x3C; i++) {
+        sp20.x -= 0.15f;
+        sp20.y -= 0.15f;
+        sp20.z -= 0.15f;
+        BoardModelScaleSetV(temp_r31, &sp20);
+        HuPrcVSleep();
+    }
+    BoardModelKill(temp_r31);
+    HuPrcKill(NULL);
+    while (1) {
+        HuPrcVSleep();
+    }
+}
diff --git a/src/game/board/ui.c b/src/game/board/ui.c
index bb7d2ded..fa0e6c56 100755
--- a/src/game/board/ui.c
+++ b/src/game/board/ui.c
@@ -9,13 +9,15 @@
 #include "game/pad.h"
 #include "game/process.h"
 #include "game/window.h"
+#include "game/board/item.h"
 #include "game/board/main.h"
+#include "game/board/model.h"
 #include "game/board/player.h"
 #include "board_unsplit.h"
 
 #include "math.h"
 
-#define ABS(x) ((x < 0) ? -x : x)
+#define ABS(x) (((x) < 0) ? -(x) : (x))
 
 typedef struct {
     /* 0x00 */ struct {
@@ -91,18 +93,10 @@ typedef struct {
 } UnkUiWork04;
 
 void BoardPlayerSparkSet(s32);
-s32 BoardItemDoneCheck(void);
-void BoardItemStart(s32, s32);
 void BoardTutorialHookExec(s16, s32);
-s16 BoardBowserSuitModelGet(void);
 void BoardBowserSuitMotionCreate(void);
 s16 BoardBowserSuitPlayerModelGet(void);
 void CharModelLayerSetAll(s32);
-void BoardItemBagItemSet(void*);
-float BoardModelMotionTimeGet(s16);
-void BoardModelMotionStartEndSet(s16, s16, s16);
-void BoardModelMotionTimeSet(s16, float);
-void BoardModelPosGet(s16, Vec*);
 s32 BoardComTutorialItemGet(s32);
 void BoardTutorialHostHide(s32);
 
@@ -1201,7 +1195,7 @@ void BoardMakeRandomItem(void) {
             itemRandTbl[i] = temp_r3;
         }
     }
-    BoardItemBagItemSet(&itemRandTbl);
+    BoardItemBagItemSet(itemRandTbl);
 }
 
 static inline void TeamItemPosSetInlineFunc01(s32 arg0, s32 arg1, Vec *arg2) {
diff --git a/src/game/hsfdraw.c b/src/game/hsfdraw.c
index 5d360457..5f8b4646 100755
--- a/src/game/hsfdraw.c
+++ b/src/game/hsfdraw.c
@@ -6,7 +6,7 @@
 #include "math.h"
 #include "string.h"
 
-#define ABS(x) ((x < 0) ? -x : x)
+#define ABS(x) (((x) < 0) ? -(x) : (x))
 
 typedef struct {
     /* 0x00 */ ModelData *unk00;

From 3e728b0fda6da37ef008b3fac3b69bd9ff846372 Mon Sep 17 00:00:00 2001
From: mrshigure <mrshigure64@gmail.com>
Date: Thu, 1 Feb 2024 14:05:48 -0800
Subject: [PATCH 12/15] Matched board/boo

---
 config/GMPE01_00/splits.txt |    4 +-
 configure.py                |    2 +-
 include/game/board/boo.h    |   18 +
 include/game/board/window.h |    1 +
 include/game/hsfman.h       |    2 +-
 src/game/board/boo.c        | 1487 +++++++++++++++++++++++++++++++++++
 src/game/hsfman.c           |    8 +-
 7 files changed, 1514 insertions(+), 8 deletions(-)
 create mode 100755 include/game/board/boo.h
 create mode 100755 src/game/board/boo.c

diff --git a/config/GMPE01_00/splits.txt b/config/GMPE01_00/splits.txt
index 19024042..bcebe4b5 100644
--- a/config/GMPE01_00/splits.txt
+++ b/config/GMPE01_00/splits.txt
@@ -497,7 +497,7 @@ game/board/boo.c:
 	.data       start:0x8013AB28 end:0x8013AD00
 	.sdata      start:0x801D37D8 end:0x801D37E8
 	.sbss       start:0x801D41B0 end:0x801D41E8
-	.sdata2     start:0x801D5E98 end:0x801D5FA0
+	.sdata2     start:0x801D5E98 end:0x801D5FA8
 
 game/board/mg_setup.c:
 	.text       start:0x800A1A34 end:0x800A4F6C
@@ -506,7 +506,7 @@ game/board/mg_setup.c:
 	.bss        start:0x801A4C58 end:0x801A4CC8
 	.sdata      start:0x801D37E8 end:0x801D37F0
 	.sbss       start:0x801D41E8 end:0x801D4218
-	.sdata2     start:0x801D5FA0 end:0x801D6080
+	.sdata2     start:0x801D5FA8 end:0x801D6080
 
 game/board/boo_house.c:
 	.text       start:0x800A4F6C end:0x800A6EE4
diff --git a/configure.py b/configure.py
index 2e5e2462..f9ee5812 100644
--- a/configure.py
+++ b/configure.py
@@ -381,7 +381,7 @@ config.libs = [
             Object(NonMatching, "game/board/bowser.c"),
             Object(NonMatching, "game/board/battle.c"),
             Object(NonMatching, "game/board/fortune.c"),
-            Object(NonMatching, "game/board/boo.c"),
+            Object(Matching, "game/board/boo.c"),
             Object(NonMatching, "game/board/mg_setup.c"),
             Object(NonMatching, "game/board/boo_house.c"),
             Object(NonMatching, "game/board/start.c"),
diff --git a/include/game/board/boo.h b/include/game/board/boo.h
new file mode 100755
index 00000000..39c7d971
--- /dev/null
+++ b/include/game/board/boo.h
@@ -0,0 +1,18 @@
+#ifndef _BOARD_BOO_H
+#define _BOARD_BOO_H
+
+#include "dolphin.h"
+#include "game/object.h"
+
+s16 BoardBooCreate(s32 arg0, Vec *arg1);
+void BoardBooKill(void);
+s32 BoardBooStealTypeSet(s32 arg0);
+s32 BoardBooStealMain(void);
+BOOL CheckBallCoinDone(void);
+void TakeBallStar(void);
+void ExecTakeBallStar(omObjData *arg0);
+BOOL CheckTakeBallStarDone(void);
+s32 BoardBooStealValueGet(s16 *arg0, s16 *arg1);
+BOOL BoardBooStealLightCheck(void);
+
+#endif
diff --git a/include/game/board/window.h b/include/game/board/window.h
index 6a307621..2792395a 100644
--- a/include/game/board/window.h
+++ b/include/game/board/window.h
@@ -12,6 +12,7 @@ void BoardWinKillAll(void);
 void BoardWinDestroy(void);
 void BoardWinProc(void);
 int BoardWinChoiceGet(void);
+void BoardWinPause(void);
 void BoardWinCreateChoice(s32 pos, u32 mess, s32 portrait, s32 choice);
 void BoardWinCreate(s32 pos, u32 mess, s32 portrait);
 void BoardWinInsertMesSet(u32 value, s32 index);
diff --git a/include/game/hsfman.h b/include/game/hsfman.h
index 12bd2847..b0481822 100644
--- a/include/game/hsfman.h
+++ b/include/game/hsfman.h
@@ -222,7 +222,7 @@ void Hu3DShadowSizeSet(u16);
 void Hu3DShadowExec(void);
 s16 Hu3DProjectionCreate(void*, f32, f32, f32);
 void Hu3DProjectionKill(s16);
-void Hu3DProjectionPosSet(s16, Vec, Vec, Vec);
+void Hu3DProjectionPosSet(s16, Vec*, Vec*, Vec*);
 void Hu3DProjectionTPLvlSet(s16, f32);
 void Hu3DMipMapSet(char*, s16, s32, f32);
 
diff --git a/src/game/board/boo.c b/src/game/board/boo.c
new file mode 100755
index 00000000..603f6017
--- /dev/null
+++ b/src/game/board/boo.c
@@ -0,0 +1,1487 @@
+#include "game/board/boo.h"
+#include "game/audio.h"
+#include "game/gamework.h"
+#include "game/gamework_data.h"
+#include "game/hsfman.h"
+#include "game/objsub.h"
+#include "game/pad.h"
+#include "game/process.h"
+#include "game/window.h"
+#include "game/board/main.h"
+#include "game/board/model.h"
+#include "game/board/player.h"
+#include "game/board/window.h"
+
+#include "math.h"
+
+typedef struct {
+    struct {
+        u8 unk00_field0 : 1;
+    };
+    s8 unk01;
+    s8 unk02;
+    char unk03[1];
+    s16 unk04;
+    s16 unk06;
+} BooEventWork;
+
+typedef struct {
+    struct {
+        s8 unk00_field0 : 1;
+    };
+    s8 unk01;
+    s16 unk02;
+    s16 unk04;
+    s16 unk06;
+    AnimData *unk08;
+} BallWork;
+
+typedef struct {
+    struct {
+        s8 unk00_field0 : 1;
+    };
+    char unk01[1];
+    u16 unk02;
+} BallCameraWork;
+
+typedef struct {
+    s16 unk00;
+    s16 unk02;
+    s16 unk04[6];
+} BallPlayerData; // Size 0x10
+
+typedef struct {
+    struct {
+        s8 unk00_field0 : 1;
+        u8 unk00_field1 : 1;
+    };
+    s8 unk01;
+    u8 unk02;
+} BallPlayerWork;
+
+typedef struct {
+    struct {
+        s8 unk00_field0 : 1;
+        u8 unk00_field1 : 4;
+        u8 unk00_field2 : 1;
+    };
+    u8 unk01;
+    u8 unk02;
+    char unk03[1];
+    s16 unk04;
+    char unk06[2];
+    float unk08;
+} BallBooWork;
+
+typedef struct {
+    /* 0x00 */ s16 unk00;
+    /* 0x02 */ char unk02[2];
+    /* 0x04 */ Vec unk04;
+    /* 0x10 */ Vec unk10;
+    /* 0x1C */ Vec unk1C;
+    /* 0x28 */ char unk28[4];
+} BallTakeCoinData; // Size 0x2C
+
+typedef struct {
+    struct {
+        u8 unk00_field0 : 1;
+    };
+    u8 unk01;
+    s16 unk02;
+    float unk04;
+} BallTakeCoinWork;
+
+void BoardSpaceCameraSet(u16);
+char *CharModelHookNameGet(s16, s32, s32);
+
+static void ComSetupStealPlayer(s32 arg0);
+static void ComSetStealPlayerInput(s32 arg0, s32 arg1);
+static void ExecCoinSteal(void);
+static void ExecStarSteal(void);
+static void ExecLightSteal(void);
+static void SetBooMode(s32 arg0);
+static void CreateBallMdl(s16 *arg0, Vec *arg1);
+static void CreateBallView(void);
+static void SetBallView(s32 arg0);
+static void SetBallActive(s32 arg0);
+static s32 CheckBallKill(void);
+static void BallMain(omObjData *arg0);
+static void BallRenderHook(void);
+static void ExecBoo(omObjData *arg0);
+static void UpdateBallCamera(omObjData *arg0);
+static void CreateBallPlayer(void);
+static s32 GetBallPlayerState(void);
+static void SetBallPlayerState(s32 arg0);
+static void ExecBallPlayer(omObjData *arg0);
+static void BallPlayerZoomOut(omObjData *arg0, BallPlayerWork *arg1);
+static void BallPlayerScare(omObjData *arg0, BallPlayerWork *arg1);
+static void BallPlayerTurn(omObjData *arg0, BallPlayerWork *arg1);
+static void BallPlayerPunch(omObjData *arg0, BallPlayerWork *arg1);
+static void BallPlayerUseLight(omObjData *arg0, BallPlayerWork *arg1);
+static void BallPlayerCatch(omObjData *arg0, BallPlayerWork *arg1);
+static void BallBooCreate(void);
+static void SetBallBooState(s32 arg0);
+static s32 GetBallBooState(void);
+static void ExecBallBoo(omObjData *arg0);
+static void BallBooSpawn(omObjData *arg0, BallBooWork *arg1);
+static void BallBooChase(omObjData *arg0, BallBooWork *arg1);
+static void BallBooBattle(omObjData *arg0, BallBooWork *arg1);
+static void BallBooAttack(omObjData *arg0, BallBooWork *arg1);
+static void BallBooFlash(omObjData *arg0, BallBooWork *arg1);
+static void TakeBallCoin(void);
+static void ExecTakeBallCoin(omObjData *arg0);
+static void TakeBallCoinPosSet(BallTakeCoinData *arg0, Vec *arg1);
+static void UpdatePlayerCoins(void);
+
+s8 lbl_801D41E2;
+static s8 stealTarget;
+static s8 stealType;
+static s32 booKillF;
+static u8 stealValue;
+static u8 stealSuccess;
+static u8 punchCount;
+static s8 stealAvail[3];
+static s8 starChoiceEnable[3];
+static s32 battleTimer;
+static s32 attackTimer;
+static omObjData *ballTakeCoinObj;
+static omObjData *ballPlayerObj;
+static omObjData *ballBooObj;
+static omObjData *ballCameraObj;
+static omObjData *ballObj;
+static omObjData *booEventObj;
+
+static s32 booPlayerMotTbl[8][6] = {
+    { 0x0009000B, 0x00090013, 0x0009001B, 0x00090023, 0x0009002B, 0x00090033 },
+    { 0x0009000C, 0x00090014, 0x0009001C, 0x00090024, 0x0009002C, 0x00090034 },
+    { 0x0009000D, 0x00090015, 0x0009001D, 0x00090025, 0x0009002D, 0x00090035 },
+    { 0x0009000E, 0x00090016, 0x0009001E, 0x00090026, 0x0009002E, 0x00090036 },
+    { 0x0009000F, 0x00090017, 0x0009001F, 0x00090027, 0x0009002F, 0x00090037 },
+    { 0x00090010, 0x00090018, 0x00090020, 0x00090028, 0x00090030, 0x00090038 },
+    { 0x00090011, 0x00090019, 0x00090021, 0x00090029, 0x00090031, 0x00090039 },
+    { 0x00090012, 0x0009001A, 0x00090022, 0x0009002A, 0x00090032, 0x0009003A }
+};
+
+static s32 booSfxTbl[4][8] = {
+    {
+        0x0000012F, 0x0000016F, 0x000001AF, 0x000001EF,
+        0x0000022F, 0x0000026F, 0x000002AF, 0x000002EF,
+    },
+    {
+        0x00000130, 0x00000170, 0x000001B0, 0x000001F0,
+        0x00000230, 0x00000270, 0x000002B0, 0x000002F0
+    },
+    {
+        0x00000131, 0x00000171, 0x000001B1, 0x000001F1,
+        0x00000231, 0x00000271, 0x000002B1, 0x000002F1,
+    },
+    {
+        0x00000123, 0x00000163, 0x000001A3, 0x000001E3,
+        0x00000223, 0x00000263, 0x000002A3, 0x000002E3
+    }
+};
+
+static s32 hostMess[] = {
+    0x0007000E,
+    0x00070014,
+    0x0007001A,
+    0x00070020,
+    0x00070026,
+    0x0007002C
+};
+
+static s32 ballMdlTbl[] = {
+    0x00090002,
+    0x00090006
+};
+
+s16 BoardBooCreate(s32 arg0, Vec *arg1) {
+    BooEventWork *temp_r31;
+    Vec spC;
+
+    if (arg1) {
+        spC = *arg1;
+    } else {
+        spC.x = spC.y = spC.z = 0.0f;
+    }
+    booEventObj = omAddObjEx(boardObjMan, 0x1000, 0, 0, -1, ExecBoo);
+    temp_r31 = OM_GET_WORK_PTR(booEventObj, BooEventWork);
+    temp_r31->unk00_field0 = 0;
+    temp_r31->unk01 = 0;
+    temp_r31->unk02 = arg0;
+    booKillF = 0;
+    stealTarget = -1;
+    lbl_801D41E2 = 0;
+    punchCount = 0;
+    stealValue = 0;
+    stealSuccess = 0;
+    booEventObj->trans.x = spC.x;
+    booEventObj->trans.y = spC.y;
+    booEventObj->trans.z = spC.z;
+    CreateBallMdl(&temp_r31->unk04, &spC);
+    return temp_r31->unk04;
+}
+
+void BoardBooKill(void) {
+    booKillF = 1;
+    if (booEventObj) {
+        OM_GET_WORK_PTR(booEventObj, BooEventWork)->unk00_field0 = 1;
+    }
+}
+
+s32 BoardBooStealTypeSet(s32 arg0) {
+    BooEventWork *temp_r29 = OM_GET_WORK_PTR(booEventObj, BooEventWork);
+    s32 var_r25;
+    s32 var_r27;
+    s32 var_r26;
+    s32 var_r28;
+    s32 var_r30;
+    s32 i;
+
+    stealType = arg0;
+    for (var_r26 = var_r30 = i = 0; i < 4; i++) {
+        if (i != temp_r29->unk02) {
+            var_r27 = i;
+            stealAvail[var_r30] = var_r27;
+            if ((stealType == 0 && BoardPlayerCoinsGet(var_r27) == 0) || (stealType == 1 && GWStarsGet(var_r27) == 0)) {
+                starChoiceEnable[var_r30] = 0;
+            } else {
+                starChoiceEnable[var_r30] = 1;
+                var_r26++;
+            }
+            var_r30++;
+        }
+    }
+    if (var_r26 == 0) {
+        stealType = -1;
+        return 0;
+    }
+    if (_CheckFlag(0x10018)) {
+        var_r25 = BoardWinPortraitGet();
+        var_r28 = hostMess[GWBoardGet()];
+    } else {
+        var_r25 = 3;
+        var_r28 = 0x120019;
+    }
+    BoardWinCreateChoice(1, var_r28, var_r25, 0);
+    BoardWinAttrSet(0x10);
+    if (stealType == 0) {
+        var_r28 = 0x70030;
+    } else {
+        var_r28 = 0x70031;
+    }
+    BoardWinInsertMesSet(var_r28, 0);
+    for (i = 0; i < 3; i++) {
+        BoardWinInsertMesSet(BoardPlayerGetCharMess(stealAvail[i]), i + 1);
+        if (starChoiceEnable[i] == 0) {
+            BoardWinChoiceDisable(i);
+        }
+    }
+    if (GWPlayer[temp_r29->unk02].com) {
+        ComSetupStealPlayer(temp_r29->unk02);
+    }
+    BoardWinWait();
+    stealTarget = BoardWinChoiceGet();
+    if (stealTarget == 3) {
+        stealTarget = -1;
+        while (stealTarget == -1) {
+            var_r30 = BoardRandMod(3);
+            if (starChoiceEnable[var_r30] != 0) {
+                stealTarget = stealAvail[var_r30];
+            }
+        }
+    } else {
+        stealTarget = stealAvail[stealTarget];
+    }
+    BoardWinKill();
+    CreateBallView();
+    SetBallView(1);
+}
+
+static void ComSetupStealPlayer(s32 arg0) {
+    s32 var_r25;
+    s32 var_r26;
+    s32 var_r29;
+    s32 temp_r28;
+    s32 var_r27;
+    s32 var_r30;
+    s32 var_r24;
+    s32 var_r22;
+    s32 i;
+    s16 sp8[3];
+
+    switch (GWPlayer[arg0].diff) {
+        case 0:
+            var_r29 = 0x5F;
+            break;
+        case 1:
+            var_r29 = 0x32;
+            break;
+        case 2:
+            var_r29 = 5;
+            break;
+        case 3:
+            var_r29 = 0;
+            break;
+    }
+    var_r22 = BoardRandMod(0x64);
+    if (var_r22 >= var_r29) {
+        var_r24 = 1;
+    } else {
+        var_r24 = 0;
+    }
+    for (i = 0; i < 3; i++) {
+        temp_r28 = stealAvail[i];
+        if (stealType == 1) {
+            var_r30 = GWStarsGet(temp_r28);
+        } else {
+            var_r30 = BoardPlayerCoinsGet(temp_r28);
+        }
+        if (starChoiceEnable[i] == 0) {
+            var_r30 = -1;
+        }
+        if ((s32) GWSystem.team != 0 && temp_r28 == BoardPlayerSameTeamFind(arg0)) {
+            var_r30 = 0;
+        }
+        if (BoardPlayerItemFind(temp_r28, 8) != -1 && var_r24 != 0) {
+            var_r30 = 0;
+        }
+        sp8[i] = var_r30;
+    }
+    var_r25 = var_r27 = -1;
+    for (var_r26 = i = 0; i < 3; i++) {
+        var_r30 = sp8[i];
+        if (var_r30 != -1) {
+            if (var_r30 > 0 && var_r30 >= var_r25) {
+                var_r25 = var_r30;
+                var_r27 = var_r26;
+            }
+            var_r26++;
+        }
+    }
+    if (var_r27 == -1) {
+        var_r27 = 0;
+    }
+    ComSetStealPlayerInput(arg0, var_r27);
+}
+
+static void ComSetStealPlayerInput(s32 arg0, s32 arg1) {
+    s32 spC[4];
+    s32 temp_r30;
+    s32 i;
+    s16 temp_r29;
+
+    spC[0] = spC[1] = spC[2] = spC[3] = 0;
+    temp_r30 = GWPlayer[arg0].port;
+    temp_r29 = GWMessDelayGet();
+    spC[temp_r30] = 4;
+    if (arg1 != 0) {
+        for (i = 0; i < arg1; i++) {
+            HuWinComKeyWait(spC[0], spC[1], spC[2], spC[3], temp_r29);
+        }
+    }
+    spC[temp_r30] = 0x100;
+    HuWinComKeyWait(spC[0], spC[1], spC[2], spC[3], temp_r29);
+}
+
+s32 BoardBooStealMain(void) {
+    BooEventWork *sp8;
+    s32 var_r31;
+    s32 var_r30;
+
+    stealType == -1;
+    sp8 = OM_GET_WORK_PTR(booEventObj, BooEventWork);
+    if (stealType == 0) {
+        SetBooMode(2);
+    } else {
+        SetBooMode(1);
+    }
+    var_r31 = BoardPlayerItemFind(stealTarget, 8);
+    if (var_r31 != -1) {
+        stealType = 2;
+        BoardPlayerItemRemove(stealTarget, var_r31);
+        var_r30 = 0x70004;
+    } else {
+        var_r30 = 0x70003;
+    }
+    BoardCameraMotionWait();
+    for (var_r31 = 0; var_r31 < 4; var_r31++) {
+        if (stealTarget != var_r31) {
+            BoardModelVisibilitySet(BoardPlayerModelGet(var_r31), 0);
+        }
+    }
+    CreateBallPlayer();
+    omVibrate(stealTarget, 0xC, 4, 2);
+    SetBallActive(1);
+    while (!CheckBallKill()) {
+        HuPrcVSleep();
+    }
+    if (stealType == 0) {
+        BoardWinCreate(2, var_r30, -1);
+        BoardWinInsertMesSet(BoardPlayerGetCharMess(stealTarget), 0);
+        BoardWinPause();
+    }
+    switch (stealType) {
+        case 0:
+            ExecCoinSteal();
+            break;
+        case 1:
+            ExecStarSteal();
+            break;
+        case 2:
+            ExecLightSteal();
+            break;
+    }
+    BoardWinKill();
+    SetBallActive(-1);
+    while (!CheckBallKill()) {
+        HuPrcVSleep();
+    }
+    booKillF = 1;
+    SetBallView(0);
+    for (var_r31 = 0; var_r31 < 4; var_r31++) {
+        if (stealTarget != var_r31) {
+            BoardModelVisibilitySet(BoardPlayerModelGet(var_r31), 1);
+        }
+    }
+    HuPrcSleep(2);
+    if (stealType == 2) {
+        return 0;
+    } else {
+        return 1;
+    }
+}
+
+static void ExecCoinSteal(void) {
+    while (GetBallPlayerState() != 2) {
+        HuPrcVSleep();
+    }
+    BallBooCreate();
+    while (GetBallBooState() != 0) {
+        HuPrcVSleep();
+    }
+    while (GetBallPlayerState() != 0) {
+        HuPrcVSleep();
+    }
+    SetBallBooState(2);
+    while (GetBallBooState() != 0) {
+        HuPrcVSleep();
+    }
+    SetBallPlayerState(4);
+    SetBallBooState(3);
+    punchCount = 0;
+    HuPrcSleep(0x78);
+    while (GetBallBooState() != 0) {
+        HuPrcVSleep();
+    }
+    while (GetBallPlayerState() != 0) {
+        HuPrcVSleep();
+    }
+}
+
+static void ExecStarSteal(void) {
+    while (GetBallPlayerState() != 2) {
+        HuPrcVSleep();
+    }
+    BallBooCreate();
+    while (GetBallBooState() != 0) {
+        HuPrcVSleep();
+    }
+    while (GetBallPlayerState() != 0) {
+        HuPrcVSleep();
+    }
+    SetBallBooState(2);
+    while (GetBallBooState() != 0) {
+        HuPrcVSleep();
+    }
+    SetBallBooState(4);
+    while (GetBallBooState() != 0) {
+        HuPrcVSleep();
+    }
+    while (GetBallPlayerState() != 0) {
+        HuPrcVSleep();
+    }
+}
+
+static void ExecLightSteal(void) {
+    while (GetBallPlayerState() != 0) {
+        HuPrcVSleep();
+    }
+    BallBooCreate();
+    while (GetBallBooState() != 0) {
+        HuPrcVSleep();
+    }
+    SetBallBooState(2);
+    while (GetBallBooState() != 0) {
+        HuPrcVSleep();
+    }
+    SetBallPlayerState(6);
+    while (GetBallPlayerState() != 0) {
+        HuPrcVSleep();
+    }
+    while (GetBallBooState() != 0) {
+        HuPrcVSleep();
+    }
+}
+
+static void SetBooMode(s32 arg0) {
+    OM_GET_WORK_PTR(booEventObj, BooEventWork)->unk01 = arg0;
+}
+
+static void CreateBallMdl(s16 *arg0, Vec *arg1) {
+    s32 i;
+
+    for (i = 0; i < 2; i++) {
+        arg0[i] = BoardModelCreate(ballMdlTbl[i], NULL, 0);
+        BoardModelPosSetV(arg0[i], arg1);
+    }
+    BoardModelMotionStart(arg0[0], 0, 0x40000001);
+    BoardModelHookSet(arg0[0], "sui", arg0[1]);
+    BoardModelPosSet(arg0[1], 0.0f, 0.0f, 0.0f);
+    BoardModelVisibilitySet(arg0[1], 1);
+}
+
+static void CreateBallView(void) {
+    AnimBmpData *temp_r29;
+    BooEventWork *temp_r28;
+    BallWork *temp_r31;
+    BallCameraWork *temp_r30;
+
+    temp_r28 = OM_GET_WORK_PTR(booEventObj, BooEventWork);
+    ballObj = omAddObjEx(boardObjMan, 0x1001, 0, 0, -1, BallMain);
+    temp_r31 = OM_GET_WORK_PTR(ballObj, BallWork);
+    temp_r31->unk00_field0 = 0;
+    temp_r31->unk08 = HuSprAnimMake(0x50, 0x50, 2);
+    temp_r29 = temp_r31->unk08->bmp;
+    temp_r29->data = HuMemDirectMallocNum(HEAP_SYSTEM, 0x3200, MEMORY_DEFAULT_NUM);
+    memset(temp_r29->data, 0, 0x3200);
+    temp_r31->unk04 = Hu3DHookFuncCreate((void*) BallRenderHook);
+    Hu3DModelLayerSet(temp_r31->unk04, 3);
+    Hu3DModelCameraSet(temp_r31->unk04, 1);
+    temp_r31->unk06 = Hu3DProjectionCreate(temp_r31->unk08, 25.0f, 100.0f, 13000.0f);
+    Hu3DModelProjectionSet(BoardModelIDGet(temp_r28->unk06), temp_r31->unk06);
+    Hu3DProjectionTPLvlSet(temp_r31->unk06, 0.0f);
+    ballCameraObj = omAddObjEx(boardObjMan, 0x7E03, 0, 0, -1, UpdateBallCamera);
+    temp_r30 = OM_GET_WORK_PTR(ballCameraObj, BallCameraWork);
+    temp_r30->unk00_field0 = 0;
+    temp_r30->unk02 = 1;
+    ballCameraObj->rot.x = -8.0f;
+    ballCameraObj->rot.y = 80.0f;
+    ballCameraObj->rot.z = 300.0f;
+    Hu3DCameraPerspectiveSet(temp_r30->unk02, 25.0f, 10.0f, 2000.0f, 1.2f);
+    Hu3DCameraScissorSet(temp_r30->unk02, 0, 0, 0xA0, 0xA0);
+    Hu3DCameraViewportSet(temp_r30->unk02, 0.0f, 0.0f, 160.0f, 160.0f, 0.0f, 1.0f);
+}
+
+static void SetBallView(s32 arg0) {
+    u16 var_r31;
+    s32 i;
+
+    if (arg0 != 0) {
+        var_r31 = 2;
+    } else {
+        Hu3DCameraPerspectiveSet(2, -1.0f, 0.0f, 0.0f, 0.0f);
+        var_r31 = 1;
+    }
+    for (i = 0; i < 4; i++) {
+        BoardPlayerCameraSet(i, var_r31);
+    }
+    BoardSpaceCameraSet(var_r31);
+    BoardModelCameraSetAll(var_r31);
+    BoardCameraMaskSet((u16) var_r31);
+    BoardCameraScissorSet(0, 0, 0x280, 0x1E0);
+}
+
+static void SetBallActive(s32 arg0) {
+    BallWork *temp_r31 = OM_GET_WORK_PTR(ballObj, BallWork);
+
+    temp_r31->unk01 = arg0 * 8;
+}
+
+static s32 CheckBallKill(void) {
+    BallWork *temp_r31;
+
+    if (!ballObj) {
+        return 1;
+    }
+    temp_r31 = OM_GET_WORK_PTR(ballObj, BallWork);
+    if (temp_r31->unk01 != 0) {
+        return 0;
+    } else {
+        return 1;
+    }
+}
+
+static void BallMain(omObjData *arg0) {
+    BallWork *temp_r30 = OM_GET_WORK_PTR(arg0, BallWork);
+    Vec sp2C;
+    Vec sp20;
+    Vec sp14;
+    Vec sp8;
+    float temp_f30;
+    float var_f29;
+    s16 *temp_r29;
+
+    if (booKillF != 0 || BoardIsKill() != 0) {
+        temp_r29 = (s16*) &OM_GET_WORK_PTR(booEventObj, BooEventWork)->unk04;
+        Hu3DModelProjectionReset(BoardModelIDGet(temp_r29[1]), temp_r30->unk06);
+        Hu3DProjectionKill(temp_r30->unk06);
+        Hu3DModelKill(temp_r30->unk04);
+        ballObj = NULL;
+        omDelObjEx(HuPrcCurrentGet(), arg0);
+        return;
+    }
+    temp_f30 = 240.0f;
+    BoardCameraRotGet(&sp20);
+    BoardCameraTargetGet(&sp2C);
+    sp8.x = sp2C.x + sin(sp20.y * M_PI / 180.0) * cos(sp20.x * M_PI / 180.0) * temp_f30;
+    sp8.y = sp2C.y + -sin(sp20.x * M_PI / 180.0) * temp_f30;
+    sp8.z = sp2C.z + cos(sp20.y * M_PI / 180.0) * cos(sp20.x * M_PI / 180.0) * temp_f30;
+    sp14.x = sin(sp20.y * M_PI / 180.0) * sin(sp20.x * M_PI / 180.0);
+    sp14.y = cos(sp20.x * M_PI / 180.0);
+    sp14.z = cos(sp20.y * M_PI / 180.0) * sin(sp20.x * M_PI / 180.0);
+    if (temp_r30->unk01 != 0) {
+        temp_r30->unk02 += temp_r30->unk01;
+        if (temp_r30->unk02 > 0xFF) {
+            temp_r30->unk02 = 0xFF;
+            temp_r30->unk01 = 0;
+        } else if (temp_r30->unk02 < 0) {
+            temp_r30->unk02 = 0;
+            temp_r30->unk01 = 0;
+        }
+    }
+    Hu3DProjectionPosSet(temp_r30->unk06, &sp8, &sp14, &sp2C);
+    OSs16tof32(&temp_r30->unk02, &var_f29);
+    var_f29 = var_f29 * 0.003921569f;
+    Hu3DProjectionTPLvlSet(temp_r30->unk06, var_f29);
+}
+
+static void BallRenderHook(void) {
+    BallWork *temp_r31;
+    GXColor sp10;
+    Vec sp2C;
+    Vec sp20;
+    Vec sp14;
+    Mtx44 sp68;
+    Mtx sp38;
+
+    if (!ballObj) {
+        return;
+    }
+    temp_r31 = OM_GET_WORK_PTR(ballObj, BallWork);
+    sp10.a = sp10.r = sp10.g = sp10.b = 0;
+    GXSetCopyClear(sp10, -1);
+    GXSetTexCopySrc(0, 0, 0xA0, 0xA0);
+    GXSetTexCopyDst(0x50, 0x50, GX_TF_RGB5A3, GX_TRUE);
+    GXCopyTex(temp_r31->unk08->bmp->data, GX_TRUE);
+    DCFlushRange(temp_r31->unk08->bmp->data, 0x3200);
+    GXPixModeSync();
+    C_MTXPerspective(sp68, 25.0f, 1.2f, 100.0f, 13000.0f);
+    GXSetProjection(sp68, GX_PERSPECTIVE);
+    GXSetViewport(0.0f, 0.0f, 160.0f, 160.0f, 0.0f, 1.0f);
+    GXSetScissor(0, 0, 0xA0, 0xA0);
+    GXClearVtxDesc();
+    GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
+    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_TEX_ST, GX_RGBA6, 0);
+    sp10.r = 0;
+    sp10.g = 0;
+    sp10.b = 0;
+    sp10.a = 0xFF;
+    GXSetTevColor(GX_TEVREG0, sp10);
+    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
+    GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_C0);
+    GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
+    GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_A0);
+    GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
+    GXSetNumTexGens(0);
+    GXSetNumTevStages(1);
+    GXSetCullMode(GX_CULL_NONE);
+    GXSetColorUpdate(GX_FALSE);
+    GXSetAlphaUpdate(GX_FALSE);
+    GXSetZMode(GX_TRUE, GX_ALWAYS, GX_TRUE);
+    sp2C.x = 0.0f;
+    sp2C.y = 0.0f;
+    sp2C.z = 100.0f;
+    sp14.x = 0.0f;
+    sp14.y = 0.0f;
+    sp14.z = 0.0f;
+    sp20.x = 0.0f;
+    sp20.y = 1.0f;
+    sp20.z = 0.0f;
+    C_MTXLookAt(sp38, &sp2C, &sp20, &sp14);
+    GXLoadPosMtxImm(sp38, GX_PNMTX0);
+    sp2C.x = sin(5 * M_PI / 72) * 20000.0 * 1.2000000476837158;
+    sp2C.y = sin(5 * M_PI / 72) * 20000.0 * 0.8333333134651184;
+    sp2C.z = -9000.0f;
+    GXBegin(GX_QUADS, GX_VTXFMT0, 4);
+    GXPosition3f32(-sp2C.x, -sp2C.y, sp2C.z);
+    GXPosition3f32(sp2C.x, -sp2C.y, sp2C.z);
+    GXPosition3f32(sp2C.x, sp2C.y, sp2C.z);
+    GXPosition3f32(-sp2C.x, sp2C.y, sp2C.z);
+    GXEnd();
+    GXSetColorUpdate(GX_TRUE);
+    GXSetAlphaUpdate(GX_TRUE);
+    GXSetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
+}
+
+static void ExecBoo(omObjData *arg0) {
+    BooEventWork *temp_r30 = OM_GET_WORK_PTR(arg0, BooEventWork);
+    s32 i;
+
+    if (temp_r30->unk00_field0 != 0 || BoardIsKill()) {
+        for (i = 0; i < 2; i++) {
+            BoardModelKill(((s16*) ((u8*) temp_r30 + 4))[i]);
+        }
+        BoardWinKill();
+        booEventObj = NULL;
+        omDelObjEx(HuPrcCurrentGet(), arg0);
+        return;
+    }
+}
+
+static void UpdateBallCamera(omObjData *arg0) {
+    BallCameraWork *var_r30 = OM_GET_WORK_PTR(arg0, BallCameraWork);
+    Vec sp20;
+    Vec sp14;
+    Vec sp8;
+
+    if (booKillF != 0 || BoardIsKill()) {
+        ballCameraObj = NULL;
+        omDelObjEx(HuPrcCurrentGet(), arg0);
+        return;
+    }
+    sp20.x = arg0->trans.x;
+    sp20.y = arg0->trans.y + arg0->rot.y;
+    sp20.z = arg0->trans.z;
+    sp14.x = sp20.x + sin(0.0) * cos(arg0->rot.x * M_PI / 180.0) * arg0->rot.z;
+    sp14.y = sp20.y + -sin(arg0->rot.x * M_PI / 180.0) * arg0->rot.z;
+    sp14.z = sp20.z + cos(0.0) * cos(arg0->rot.x * M_PI / 180.0) * arg0->rot.z;
+    sp8.x = sin(0.0) * sin(arg0->rot.x * M_PI / 180.0);
+    sp8.y = cos(arg0->rot.x * M_PI / 180.0);
+    sp8.z = cos(0.0) * sin(arg0->rot.x * M_PI / 180.0);
+    Hu3DCameraPosSetV(var_r30->unk02, &sp14, &sp8, &sp20);
+}
+
+static inline void CreateBallPlayerInlineFunc(float x, float y, float z) {
+    if (ballCameraObj) {
+        ballCameraObj->trans.x = x;
+        ballCameraObj->trans.y = y;
+        ballCameraObj->trans.z = z;
+    }
+}
+
+static void CreateBallPlayer(void) {
+    char *temp_r27;
+    Vec sp8;
+    s32 temp_r28;
+    s32 var_r26;
+    s32 i;
+    omObjData *temp_r31;
+    BallPlayerData *temp_r30;
+    BallPlayerWork *temp_r25;
+
+    ballPlayerObj = temp_r31 = omAddObjEx(boardObjMan, 0x1005, 0, 0, -1, ExecBallPlayer);
+    temp_r31->data = HuMemDirectMallocNum(HEAP_SYSTEM, sizeof(BallPlayerData), MEMORY_DEFAULT_NUM);
+    temp_r25 = OM_GET_WORK_PTR(temp_r31, BallPlayerWork);
+    temp_r25->unk00_field0 = 0;
+    SetBallPlayerState(1);
+    temp_r31->trans.x = 0.0f;
+    temp_r31->trans.y = 0.0f;
+    temp_r31->trans.z = 0.0f;
+    BoardPlayerPosGet(stealTarget, &sp8);
+    temp_r31->scale.x = sp8.x;
+    temp_r31->scale.y = sp8.y;
+    temp_r31->scale.z = sp8.z;
+    temp_r31->rot.x = 300.0f;
+    temp_r31->rot.y = 750.0f;
+    temp_r28 = GWPlayer[stealTarget].character;
+    temp_r30 = temp_r31->data;
+    for (i = 0; i < 6; i++) {
+        var_r26 = booPlayerMotTbl[temp_r28][i];
+        temp_r30->unk04[i] = BoardPlayerMotionCreate(stealTarget, var_r26);
+    }
+    if (stealType == 2) {
+        temp_r30->unk00 = BoardModelCreate(0x70076, 0, 0);
+        temp_r30->unk02 = BoardModelCreate(0x70082, 0, 0);
+        BoardModelLayerSet(temp_r30->unk00, 0);
+        BoardModelLayerSet(temp_r30->unk02, 0);
+        BoardModelCameraSet(temp_r30->unk00, 1);
+        BoardModelCameraSet(temp_r30->unk02, 1);
+        BoardModelScaleSet(temp_r30->unk00, 0.4f, 0.4f, 0.4f);
+        temp_r27 = CharModelHookNameGet(temp_r28, 2, 0);
+        BoardModelHookSet(temp_r30->unk00, "b00p_item30", temp_r30->unk02);
+        BoardModelHookSet(BoardPlayerModelGet(stealTarget), temp_r27, temp_r30->unk00);
+    } else {
+        temp_r30->unk00 = -1;
+        temp_r30->unk02 = -1;
+    }
+    if (stealType != 2) {
+        BoardPlayerMotionStart(stealTarget, temp_r30->unk04[1], 0x40000001);
+    } else {
+        BoardPlayerMotionStart(stealTarget, temp_r30->unk04[3], 0x40000001);
+    }
+    BoardPlayerPosSet(stealTarget, temp_r31->trans.x, temp_r31->trans.y, temp_r31->trans.z);
+    BoardPlayerLayerSet(stealTarget, 0);
+    BoardPlayerCameraSet(stealTarget, 1);
+    if (ballCameraObj) {
+        ballCameraObj->rot.x = -8.0f;
+        ballCameraObj->rot.y = 80.0f;
+        ballCameraObj->rot.z = 300.0f;
+    }
+    CreateBallPlayerInlineFunc(temp_r31->trans.x, temp_r31->trans.y, temp_r31->trans.z);
+}
+
+static s32 GetBallPlayerState(void) {
+    BallPlayerWork *temp_r31 = OM_GET_WORK_PTR(ballPlayerObj, BallPlayerWork);
+
+    return temp_r31->unk01;
+}
+
+static void SetBallPlayerState(s32 arg0) {
+    BallPlayerWork *temp_r31 = OM_GET_WORK_PTR(ballPlayerObj, BallPlayerWork);
+
+    temp_r31->unk01 = arg0;
+    temp_r31->unk02 = 0;
+}
+
+static void ExecBallPlayer(omObjData *arg0) {
+    BallPlayerWork *temp_r30 = OM_GET_WORK_PTR(arg0, BallPlayerWork);
+    BallPlayerData *temp_r29 = arg0->data;
+    BallWork *temp_r27;
+    s32 i;
+
+    if (booKillF != 0 || BoardIsKill()) {
+        BoardPlayerPosSet(stealTarget, arg0->scale.x, arg0->scale.y, arg0->scale.z);
+        BoardPlayerRotYSet(stealTarget, 0.0f);
+        BoardPlayerLayerSet(stealTarget, 0);
+        BoardPlayerCameraSet(stealTarget, 1);
+        BoardModelHookReset(temp_r29->unk00);
+        BoardModelHookReset(BoardPlayerModelGet(stealTarget));
+        BoardModelKill(temp_r29->unk00);
+        BoardModelKill(temp_r29->unk02);
+        BoardPlayerMotionStart(stealTarget, 1, 0x40000001);
+        for (i = 0; i < 6; i++) {
+            BoardPlayerMotionKill(stealTarget, temp_r29->unk04[i]);
+        }
+        if (arg0->data) {
+            HuMemDirectFree(arg0->data);
+            arg0->data = NULL;
+        }
+        ballPlayerObj = NULL;
+        omDelObjEx(HuPrcCurrentGet(), arg0);
+        return;
+    }
+    temp_r27 = OM_GET_WORK_PTR(ballObj, BallWork);
+    if (temp_r27->unk01 == 0) {
+        switch (temp_r30->unk01) {
+            case 1:
+                BallPlayerZoomOut(arg0, temp_r30);
+                break;
+            case 3:
+                BallPlayerScare(arg0, temp_r30);
+                break;
+            case 2:
+                BallPlayerTurn(arg0, temp_r30);
+                break;
+            case 4:
+                BallPlayerPunch(arg0, temp_r30);
+                break;
+            case 6:
+                BallPlayerUseLight(arg0, temp_r30);
+                break;
+            case 5:
+                BallPlayerCatch(arg0, temp_r30);
+                break;
+        }
+    }
+}
+
+static void BallPlayerZoomOut(omObjData *arg0, BallPlayerWork *arg1) {
+    Vec sp14;
+    Vec sp8;
+    float temp_f31;
+    s32 var_r29;
+
+    arg0->rot.x += 8.0f;
+    if (arg0->rot.y < arg0->rot.x) {
+        arg0->rot.x = arg0->rot.y;
+        sp14.x = arg0->trans.x;
+        sp14.y = arg0->trans.y;
+        sp14.z = arg0->trans.z;
+        sp8.x = sp14.x + 120.0 * sin(-M_PI / 2);
+        sp8.y = sp14.y;
+        sp8.z = sp14.z + 120.0 * cos(-M_PI / 2);
+        BoardPlayerPosLerpStart(stealTarget, &sp14, &sp8, 0x14);
+        var_r29 = GWPlayer[stealTarget].character;
+        HuAudFXPlay(booSfxTbl[0][var_r29]);
+        SetBallPlayerState(3);
+    }
+    temp_f31 = arg0->rot.x;
+    if (ballCameraObj && temp_f31 != -1.0f) {
+        ballCameraObj->rot.z = temp_f31;
+    }
+}
+
+static void BallPlayerScare(omObjData *arg0, BallPlayerWork *arg1) {
+    BallPlayerData *temp_r29;
+    float temp_f31;
+
+    if (!GWPlayer[stealTarget].moving) {
+        temp_r29 = arg0->data;
+        temp_f31 = -BoardPlayerRotYGet(stealTarget);
+        if (stealType == 2) {
+            BoardPlayerMotionShiftSet(stealTarget, temp_r29->unk04[3], 0.0f, 10.0f, 0x40000001);
+            SetBallPlayerState(0);
+        } else {
+            BoardPlayerMotBlendSet(stealTarget, temp_f31, 0xF);
+            SetBallPlayerState(2);
+        }
+    }
+}
+
+static void BallPlayerTurn(omObjData *arg0, BallPlayerWork *arg1) {
+    if (BoardPlayerMotBlendCheck(stealTarget)) {
+        SetBallPlayerState(0);
+        arg1->unk00_field1 = 0;
+    }
+}
+
+static void BallPlayerPunch(omObjData *arg0, BallPlayerWork *arg1) {
+    BallPlayerData *temp_r29;
+    s32 temp_r30;
+    u32 var_r31;
+
+    var_r31 = 0;
+    temp_r29 = arg0->data;
+    if (GWPlayer[stealTarget].com) {
+        temp_r30 = BoardRandMod(0x64);
+        switch (GWPlayer[stealTarget].diff) {
+            case 0:
+                if (temp_r30 > 0x5A) {
+                    var_r31 = 0x100;
+                }
+                break;
+            case 1:
+                if (temp_r30 > 0x53) {
+                    var_r31 = 0x100;
+                }
+                break;
+            case 2:
+                if (temp_r30 > 0x4B) {
+                    var_r31 = 0x100;
+                }
+                break;
+            case 3:
+                if (temp_r30 > 0x44) {
+                    var_r31 = 0x100;
+                }
+                break;
+        }
+    } else {
+        var_r31 = HuPadBtnDown[GWPlayer[stealTarget].port] & 0x100;
+    }
+    if ((var_r31 & 0x100) && GetBallBooState() == 3 && battleTimer < 0x78) {
+        punchCount++;
+    }
+    if (arg1->unk00_field1 != 0) {
+        if (BoardPlayerMotionEndCheck(stealTarget)) {
+            arg1->unk00_field1 = 0;
+            BoardPlayerMotionStart(stealTarget, 1, 0x40000001);
+        }
+    } else {
+        if (var_r31 & 0x100) {
+            arg1->unk00_field1 = 1;
+            BoardPlayerMotionStart(stealTarget, temp_r29->unk04[2], 0);
+        }
+    }
+}
+
+static void BallPlayerUseLight(omObjData *arg0, BallPlayerWork *arg1) {
+    BallPlayerData *temp_r31 = arg0->data;
+
+    switch (arg1->unk02) {
+        case 0:
+            BoardModelScaleSet(temp_r31->unk02, 2.5f, 2.5f, 2.5f);
+            BoardPlayerMotionStart(stealTarget, temp_r31->unk04[4], 0);
+            arg1->unk02 = 1;
+            break;
+        case 1:
+            if (BoardPlayerMotionEndCheck(stealTarget)) {
+                SetBallBooState(7);
+                BoardPlayerMotionStart(stealTarget, temp_r31->unk04[5], 0);
+                arg1->unk02 = 2;
+            }
+            break;
+        case 2:
+            if (BoardPlayerMotionEndCheck(stealTarget)) {
+                SetBallPlayerState(0);
+            }
+            break;
+    }
+}
+
+static void BallPlayerCatch(omObjData *arg0, BallPlayerWork *arg1) {
+    s32 temp_r28;
+    BallPlayerData *temp_r27 = arg0->data;
+
+    temp_r28 = GWPlayer[stealTarget].character;
+    if (arg1->unk02 == 0) {
+        if (stealType == 0) {
+            UpdatePlayerCoins();
+            HuAudFXPlay(booSfxTbl[2][temp_r28]);
+            omVibrate(stealTarget, 0xC, 4, 2);
+            TakeBallCoin();
+        }
+        if (stealType == 1) {
+            BoardPlayerStarsAdd(stealTarget, -1);
+            HuAudFXPlay(booSfxTbl[2][temp_r28]);
+            omVibrate(stealTarget, 0xC, 4, 2);
+            TakeBallStar();
+        }
+        BoardPlayerMotionShiftSet(stealTarget, temp_r27->unk04[0], 0.0f, 10.0f, 0);
+        arg1->unk02 = 1;
+    }
+    if (stealType == 0) {
+        if (CheckBallCoinDone()) {
+            SetBallPlayerState(0);
+        }
+    } else {
+        if (stealType == 1 && CheckTakeBallStarDone()) {
+            SetBallPlayerState(0);
+        }
+    }
+}
+
+static s32 ballBooMdl[] = {
+    0x00020013,
+    0x00020014,
+    0x00020015,
+    0x00020016,
+    0x00020017,
+    -1
+};
+
+static void BallBooCreate(void) {
+    BallBooWork *temp_r31;
+    Vec sp14;
+    Vec sp8;
+    float temp_f31;
+    float var_f30;
+    float var_f29;
+
+    ballBooObj = omAddObjEx(boardObjMan, 0x1004, 0, 0, -1, ExecBallBoo);
+    temp_r31 = OM_GET_WORK_PTR(ballBooObj, BallBooWork);
+    temp_r31->unk00_field0 = 0;
+    temp_r31->unk00_field2 = 0;
+    temp_r31->unk01 = 0;
+    SetBallBooState(1);
+    temp_r31->unk04 = BoardModelCreate(0x20012, ballBooMdl, 0);
+    BoardModelAlphaSet(temp_r31->unk04, 0xFF);
+    BoardModelLayerSet(temp_r31->unk04, 0);
+    BoardModelCameraSet(temp_r31->unk04, 1);
+    temp_f31 = BoardPlayerRotYGet(stealTarget);
+    BoardPlayerPosGet(stealTarget, &sp14);
+    ballBooObj->trans.x = sp14.x + 240.0 * sin(-temp_f31 * M_PI / 180.0);
+    ballBooObj->trans.y = sp14.y + 160.0f;
+    ballBooObj->trans.z = sp14.z + 240.0 * cos(-temp_f31 * M_PI / 180.0);
+    BoardModelPosSet(temp_r31->unk04, ballBooObj->trans.x, ballBooObj->trans.y, ballBooObj->trans.z);
+    if (stealType == 2) {
+        var_f30 = 126.0f;
+        var_f29 = 80.0f;
+    } else {
+        var_f30 = 90.0f;
+        var_f29 = 100.0f;
+    }
+    sp8.x = sp14.x + var_f30 * sin(-temp_f31 * M_PI / 180.0);
+    sp8.y = sp14.y + var_f29;
+    sp8.z = sp14.z + var_f30 * cos(-temp_f31 * M_PI / 180.0);
+    ballBooObj->rot.x = (sp8.x - ballBooObj->trans.x) / 60.0f;
+    ballBooObj->rot.y = (sp8.y - ballBooObj->trans.y) / 60.0f;
+    ballBooObj->rot.z = (sp8.z - ballBooObj->trans.z) / 60.0f;
+    temp_r31->unk02 = 0x3C;
+    ballBooObj->scale.x = 1.0f;
+    ballBooObj->scale.z = 1.0f;
+    sp8.x = sp14.x - ballBooObj->trans.x;
+    sp8.z = sp14.z - ballBooObj->trans.z;
+    ballBooObj->scale.y = 180.0 * (atan2(sp8.x, sp8.z) / M_PI);
+    BoardModelRotYSet(temp_r31->unk04, ballBooObj->scale.y);
+    BoardModelMotionStart(temp_r31->unk04, 1, 0x40000001);
+}
+
+static void SetBallBooState(s32 arg0) {
+    BallBooWork *temp_r31 = OM_GET_WORK_PTR(ballBooObj, BallBooWork);
+    Vec sp8;
+
+    temp_r31->unk00_field1 = arg0;
+    if (arg0 == 2) {
+        HuAudFXPlay(0x64);
+    }
+    if (arg0 == 4) {
+        BoardPlayerPosGet(stealTarget, &sp8);
+        sp8.y += 100.0f;
+        ballBooObj->rot.x = (sp8.x - ballBooObj->trans.x) / 30.0f;
+        ballBooObj->rot.y = (sp8.y - ballBooObj->trans.y) / 30.0f;
+        ballBooObj->rot.z = (sp8.z - ballBooObj->trans.z) / 30.0f;
+        temp_r31->unk02 = 0x1E;
+        BoardModelMotionShiftSet(temp_r31->unk04, 1, 0.0f, 10.0f, 0x40000001);
+    }
+    if (arg0 == 5) {
+        HuAudFXPlay(0x64);
+        temp_r31->unk02 = 0;
+    }
+    if (arg0 == 7) {
+        temp_r31->unk08 = -ballBooObj->scale.y;
+        HuAudFXPlay(0x64);
+        BoardModelMotionShiftSet(temp_r31->unk04, 5, 0.0f, 10.0f, 0x40000001);
+    }
+    if (arg0 == 3) {
+        battleTimer = 0;
+        attackTimer = 0;
+    }
+}
+
+static s32 GetBallBooState(void) {
+    BallBooWork *temp_r31 = OM_GET_WORK_PTR(ballBooObj, BallBooWork);
+
+    return temp_r31->unk00_field1;
+}
+
+static void ExecBallBoo(omObjData *arg0) {
+    BallBooWork *temp_r30 = OM_GET_WORK_PTR(arg0, BallBooWork);
+
+    if (booKillF != 0 || BoardIsKill()) {
+        BoardModelKill(temp_r30->unk04);
+        omDelObjEx(HuPrcCurrentGet(), arg0);
+        return;
+    }
+    if (temp_r30->unk01 != 0) {
+        temp_r30->unk01--;
+        return;
+    }
+    switch (temp_r30->unk00_field1) {
+        case 1:
+            BallBooSpawn(arg0, temp_r30);
+            break;
+        case 2:
+        case 4:
+        case 6:
+            BallBooChase(arg0, temp_r30);
+            break;
+        case 3:
+            BallBooBattle(arg0, temp_r30);
+            break;
+        case 5:
+            BallBooAttack(arg0, temp_r30);
+            break;
+        case 7:
+            BallBooFlash(arg0, temp_r30);
+            break;
+    }
+    BoardModelRotYSet(temp_r30->unk04, arg0->scale.y);
+    BoardModelPosSet(temp_r30->unk04, arg0->trans.x, arg0->trans.y, arg0->trans.z);
+    BoardModelScaleSet(temp_r30->unk04, arg0->scale.z, arg0->scale.z, arg0->scale.z);
+}
+
+static void BallBooSpawn(omObjData *arg0, BallBooWork *arg1) {
+    BoardModelAlphaSet(arg1->unk04, 0xFF);
+    SetBallBooState(0);
+}
+
+static void BallBooChase(omObjData *arg0, BallBooWork *arg1) {
+    if (arg1->unk02 != 0) {
+        arg1->unk02--;
+        arg0->trans.x += arg0->rot.x;
+        arg0->trans.y += arg0->rot.y;
+        arg0->trans.z += arg0->rot.z;
+    } else {
+        if (arg1->unk00_field1 == 4) {
+            SetBallBooState(5);
+        } else {
+            SetBallBooState(0);
+        }
+        BoardModelMotionShiftSet(arg1->unk04, 1, 0.0f, 10.0f, 0x40000001);
+    }
+}
+
+static void BallBooBattle(omObjData *arg0, BallBooWork *arg1) {
+    s32 temp_r29;
+
+    battleTimer++;
+    if (attackTimer != 0) {
+        attackTimer--;
+    }
+    if (battleTimer >= 0x78) {
+        SetBallBooState(4);
+        return;
+    }
+    if (arg1->unk00_field2 != 0) {
+        if (BoardModelMotionEndCheck(arg1->unk04)) {
+            arg1->unk00_field2 = 0;
+            BoardModelMotionStart(arg1->unk04, 1, 0x40000001);
+        }
+        return;
+    }
+    if (BoardRandMod(0x64) <= 0x46) {
+        BoardModelMotionStart(arg1->unk04, 2, 0);
+        arg1->unk00_field2 = 1;
+        if (BoardRandMod(0x64) > 0x32 && attackTimer == 0) {
+            temp_r29 = GWPlayer[stealTarget].character;
+            HuAudFXPlay(booSfxTbl[1][temp_r29]);
+            omVibrate(stealTarget, 0xC, 6, 6);
+            attackTimer = 0x30;
+        }
+    }
+}
+
+static void BallBooAttack(omObjData *arg0, BallBooWork *arg1) {
+    float var_f29;
+
+    if (arg1->unk02 < 0x5A) {
+        arg1->unk02 += 6;
+        if (arg1->unk02 >= 0x5A) {
+            arg1->unk02 = 0x5A;
+            SetBallBooState(0);
+            SetBallPlayerState(5);
+        }
+    }
+    OSu8tof32(&arg1->unk02, &var_f29);
+    arg0->scale.z = 1.0 + sin(var_f29 * M_PI / 180.0);
+}
+
+static void BallBooFlash(omObjData *arg0, BallBooWork *arg1) {
+    Vec sp8;
+    float temp_f31;
+
+    if (BoardDAngleCalcRange(&arg0->scale.y, arg1->unk08, 8.0f) != 0) {
+        SetBallBooState(6);
+        BoardModelMotionShiftSet(arg1->unk04, 3, 0.0f, 10.0f, 0x40000001);
+        temp_f31 = BoardPlayerRotYGet(stealTarget);
+        BoardPlayerPosGet(stealTarget, &sp8);
+        sp8.x += 500.0 * sin(-temp_f31 * M_PI / 180.0);
+        sp8.y = sp8.y + 160.0f;
+        sp8.z += 500.0 * cos(-temp_f31 * M_PI / 180.0);
+        arg0->rot.x = (sp8.x - arg0->trans.x) / 72.0f;
+        arg0->rot.y = (sp8.y - arg0->trans.y) / 72.0f;
+        arg0->rot.z = (sp8.z - arg0->trans.z) / 72.0f;
+        arg1->unk02 = 0x48;
+    }
+}
+
+static void TakeBallCoin(void) {
+    BallTakeCoinData *var_r31;
+    Vec sp8;
+    s32 i;
+
+    ballTakeCoinObj = omAddObjEx(boardObjMan, 0x1002, 0, 0, -1, ExecTakeBallCoin);
+    ballTakeCoinObj->data = HuMemDirectMallocNum(HEAP_SYSTEM, sizeof(BallTakeCoinData) * 10, MEMORY_DEFAULT_NUM);
+    memset(ballTakeCoinObj->data, 0, sizeof(BallTakeCoinData) * 10);
+    BoardPlayerPosGet(stealTarget, &sp8);
+    ballTakeCoinObj->trans.x = sp8.x;
+    ballTakeCoinObj->trans.y = sp8.y;
+    ballTakeCoinObj->trans.z = sp8.z;
+    var_r31 = ballTakeCoinObj->data;
+    for (i = 0; i < 10; i++, var_r31++) {
+        var_r31->unk00 = BoardModelCreate(0x7000A, NULL, 1);
+        BoardModelCameraSet(var_r31->unk00, 1);
+        fn_8006DDE8(var_r31->unk00, -1.0f);
+        BoardModelScaleSet(var_r31->unk00, 0.5f, 0.5f, 0.5f);
+        var_r31->unk04.x = sp8.x;
+        var_r31->unk04.y = sp8.y + 100.0f;
+        var_r31->unk04.z = sp8.z;
+        var_r31->unk1C.x = 3.0f * (BoardRandFloat() - 0.5f);
+        var_r31->unk1C.y = 3.0 * sin(BoardRandFloat());
+        var_r31->unk1C.z = 3.0f * (BoardRandFloat() - 0.5f);
+        PSVECScale(&var_r31->unk1C, &var_r31->unk1C, 4.0f);
+        BoardModelPosSetV(var_r31->unk00, &var_r31->unk04);
+        var_r31->unk10 = var_r31->unk1C;
+    }
+}
+
+static void ExecTakeBallCoin(omObjData *arg0) {
+    BallTakeCoinData *var_r30;
+    Vec sp8;
+    s32 i;
+
+    if (CheckBallCoinDone() || booKillF != 0 || BoardIsKill()) {
+        if (arg0->data) {
+            HuMemDirectFree(arg0->data);
+            arg0->data = NULL;
+        }
+        ballTakeCoinObj = NULL;
+        omDelObjEx(HuPrcCurrentGet(), arg0);
+        return;
+    }
+    sp8.x = arg0->trans.x;
+    sp8.y = arg0->trans.y;
+    sp8.z = arg0->trans.z;
+    var_r30 = arg0->data;
+    for (i = 0; i < 10; i++, var_r30++) {
+        if (var_r30->unk00 != -1) {
+            TakeBallCoinPosSet(var_r30, &sp8);
+        }
+    }
+}
+
+static void TakeBallCoinPosSet(BallTakeCoinData *arg0, Vec *arg1) {
+    if (arg1->y > arg0->unk04.y + 50.0f) {
+        BoardModelKill(arg0->unk00);
+        arg0->unk00 = -1;
+        return;
+    }
+    PSVECAdd(&arg0->unk04, &arg0->unk10, &arg0->unk04);
+    PSVECAdd(&arg0->unk04, &arg0->unk1C, &arg0->unk04);
+    arg0->unk10.y += -0.98f;
+    BoardModelPosSetV(arg0->unk00, &arg0->unk04);
+}
+
+BOOL CheckBallCoinDone(void) {
+    BallTakeCoinData *var_r31;
+    s32 i;
+
+    if (!ballTakeCoinObj) {
+        return TRUE;
+    }
+    var_r31 = ballTakeCoinObj->data;
+    for (i = 0; i < 10; i++, var_r31++) {
+        if (var_r31->unk00 > 0) {
+            return FALSE;
+        }
+    }
+    return TRUE;
+}
+
+void TakeBallStar(void) {
+    BallTakeCoinWork *temp_r31;
+    Vec sp8;
+
+    ballTakeCoinObj = omAddObjEx(boardObjMan, 0x1003, 0, 0, -1, ExecTakeBallStar);
+    temp_r31 = OM_GET_WORK_PTR(ballTakeCoinObj, BallTakeCoinWork);
+    temp_r31->unk00_field0 = 0;
+    temp_r31->unk01 = 0;
+    temp_r31->unk02 = BoardModelCreate(0x7000B, 0, 0);
+    BoardPlayerPosGet(stealTarget, &sp8);
+    ballTakeCoinObj->trans.x = sp8.x;
+    ballTakeCoinObj->trans.y = sp8.y + 150.0f;
+    ballTakeCoinObj->trans.z = sp8.z;
+    temp_r31->unk04 = sp8.y;
+    ballTakeCoinObj->rot.x = 3.0 * sin(4 * M_PI / 9);
+    ballTakeCoinObj->rot.z = 3.0 * cos(4 * M_PI / 9);
+    ballTakeCoinObj->rot.y = 0.0f;
+    BoardModelPosSet(temp_r31->unk02, ballTakeCoinObj->trans.x, ballTakeCoinObj->trans.y, ballTakeCoinObj->trans.z);
+    BoardModelVisibilitySet(temp_r31->unk02, 1);
+    BoardModelCameraSet(temp_r31->unk02, 1);
+    fn_8006DDE8(temp_r31->unk02, -1.0f);
+    BoardModelScaleSet(temp_r31->unk02, 0.5f, 0.5f, 0.5f);
+    HuAudFXPlay(0x361);
+}
+
+void ExecTakeBallStar(omObjData *arg0) {
+    BallTakeCoinWork *temp_r29 = OM_GET_WORK_PTR(arg0, BallTakeCoinWork);
+    Vec sp8;
+    float var_f30;
+
+    if (temp_r29->unk00_field0 != 0) {
+        if (arg0->data) {
+            HuMemDirectFree(arg0->data);
+            arg0->data = NULL;
+        }
+        BoardModelKill(temp_r29->unk02);
+        ballTakeCoinObj = NULL;
+        omDelObjEx(HuPrcCurrentGet(), arg0);
+        return;
+    }
+    BoardPlayerPosGet(stealTarget, &sp8);
+    temp_r29->unk01++;
+    OSu8tof32(&temp_r29->unk01, &var_f30);
+    arg0->trans.x += arg0->rot.x;
+    arg0->trans.z += arg0->rot.z;
+    arg0->trans.y += 20.0f + var_f30 * var_f30 * -0.08166667f * 0.3f;
+    arg0->rot.y = BoardDAngleCalc(arg0->rot.y + 24.0f);
+    if (temp_r29->unk04 > arg0->trans.y) {
+        temp_r29->unk00_field0 = 1;
+    }
+    BoardModelPosSet(temp_r29->unk02, arg0->trans.x, arg0->trans.y, arg0->trans.z);
+    BoardModelRotYSet(temp_r29->unk02, arg0->rot.y);
+}
+
+BOOL CheckTakeBallStarDone(void) {
+    if (ballTakeCoinObj) {
+        return FALSE;
+    } else {
+        return TRUE;
+    }
+}
+
+s32 BoardBooStealValueGet(s16 *arg0, s16 *arg1) {
+    if (stealType == 2) {
+        return 0;
+    }
+    *arg0 = stealValue;
+    *arg1 = stealSuccess;
+    return 1;
+}
+
+BOOL BoardBooStealLightCheck(void) {
+    if (stealType == 2) {
+        return FALSE;
+    } else {
+        return TRUE;
+    }
+}
+
+static s8 stealSuccessTbl[][3] = {
+    { 0x00, 0x00, 0x00 },
+    { 0x01, 0x06, 0x01 },
+    { 0x07, 0x07, 0x03 },
+    { 0x08, 0x0C, 0x02 },
+    { 0x0D, 0x0F, 0x03 },
+    { 0x10, 0x12, 0x04 },
+    { 0x13, 0x14, 0x06 },
+    { 0x15, 0x17, 0x05 },
+    { 0x18, 0x1A, 0x06 },
+    { 0x1B, 0x1C, 0x07 },
+    { 0x1D, 0x1D, 0x08 },
+    { 0x1E, 0x63, 0x09 }
+};
+
+static s8 stealTbl[][3] = {
+    { 0x01, 0x05, 0x0F },
+    { 0x06, 0x0F, 0x19 },
+    { 0x10, 0x19, 0x1B },
+    { 0x1A, 0x23, 0x1E },
+    { 0x24, 0x2D, 0x20 },
+    { 0x2E, 0x32, 0x23 }
+};
+
+static void UpdatePlayerCoins(void) {
+    s32 sp8;
+    s32 var_r29;
+    s32 var_r30;
+    s32 i;
+
+    sp8 = punchCount;
+    if (punchCount > 0x63) {
+        punchCount = 0x63;
+    }
+    var_r30 = GWSystem.turn;
+    if (var_r30 > 0x32) {
+        var_r30 = 0x32;
+    }
+    for (stealSuccess = i = 0; i < 12; i++) {
+        if (punchCount >= stealSuccessTbl[i][0] && punchCount <= stealSuccessTbl[i][1]) {
+            stealSuccess = stealSuccessTbl[i][2];
+            break;
+        }
+    }
+    for (var_r29 = i = 0; i < 6; i++) {
+        if (var_r30 >= stealTbl[i][0] && var_r30 <= stealTbl[i][1]) {
+            var_r29 = stealTbl[i][2];
+            break;
+        }
+    }
+    stealValue = var_r29 - stealSuccess;
+    if (BoardPlayerCoinsGet(stealTarget) < stealValue) {
+        stealValue = BoardPlayerCoinsGet(stealTarget);
+    }
+    BoardPlayerCoinsAdd(stealTarget, -stealValue);
+}
diff --git a/src/game/hsfman.c b/src/game/hsfman.c
index 19b39d33..91f52d18 100644
--- a/src/game/hsfman.c
+++ b/src/game/hsfman.c
@@ -2063,10 +2063,10 @@ void Hu3DProjectionKill(s16 arg0) {
     Hu3DProjection[arg0].unk_04 = NULL;
 }
 
-void Hu3DProjectionPosSet(s16 arg0, Vec arg1, Vec arg2, Vec arg3) {
-    Hu3DProjection[arg0].unk_14 = arg1;
-    Hu3DProjection[arg0].unk_20 = arg3;
-    Hu3DProjection[arg0].unk_2C = arg2;
+void Hu3DProjectionPosSet(s16 arg0, Vec* arg1, Vec* arg2, Vec* arg3) {
+    Hu3DProjection[arg0].unk_14 = *arg1;
+    Hu3DProjection[arg0].unk_20 = *arg3;
+    Hu3DProjection[arg0].unk_2C = *arg2;
 }
 
 void Hu3DProjectionTPLvlSet(s16 arg0, f32 arg8) {

From 828ad3ba56fb7d87f8709098a601c4448f20233f Mon Sep 17 00:00:00 2001
From: gamemasterplc <gamemasterplc@gmail.com>
Date: Sat, 3 Feb 2024 10:56:05 -0600
Subject: [PATCH 13/15] Match more functions in minigame_seq.c

CreateSeq fully matched. SeqUpdateMGBattle matched
---
 config/GMPE01_00/symbols.txt |   6 +-
 src/game/minigame_seq.c      | 253 ++++++++++++++++++++++++++++++++++-
 2 files changed, 250 insertions(+), 9 deletions(-)

diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt
index e3a05fe0..62bc469a 100644
--- a/config/GMPE01_00/symbols.txt
+++ b/config/GMPE01_00/symbols.txt
@@ -4943,9 +4943,9 @@ seqFontKanaTbl = .data:0x8012F3D0; // type:object size:0x52 scope:local data:str
 seqFontNumTbl = .data:0x8012F422; // type:object size:0xB scope:local data:string
 letterBufTbl = .data:0x8012F430; // type:object size:0x14 scope:local
 wordMgTbl = .data:0x8012F444; // type:object size:0x18 scope:local
-letterBattleOfs = .data:0x8012F45C; // type:object size:0x40 scope:local
-letter2vs2Ofs = .data:0x8012F49C; // type:object size:0x1C scope:local
-letterBowserOfs = .data:0x8012F4B8; // type:object size:0x38 scope:local
+letterOfs$912 = .data:0x8012F45C; // type:object size:0x40 scope:local
+letterOfs$913 = .data:0x8012F49C; // type:object size:0x1C scope:local
+letterOfs$914 = .data:0x8012F4B8; // type:object size:0x38 scope:local
 charMKoopaNameE = .data:0x8012F4F0; // type:object size:0xA scope:local data:string
 winCharNameTbl = .data:0x8012F4FC; // type:object size:0x78 scope:local
 wordChampionE = .data:0x8012F574; // type:object size:0xA scope:local data:string
diff --git a/src/game/minigame_seq.c b/src/game/minigame_seq.c
index 5a4d057f..4e31c6a7 100644
--- a/src/game/minigame_seq.c
+++ b/src/game/minigame_seq.c
@@ -222,14 +222,14 @@ void MGSeqMain(void)
 	}
 }
 
-static s16 CreateSeq(u8 seq_no, va_list params)
+static s16 CreateSeq(s16 seq_no, va_list params)
 {
 	SeqWork *work;
 	SeqInfo *info;
 	int i;
 	int temp;
 	work = seqWorkData;
-	info = &seqInfoTbl[seq_no];
+	info = &seqInfoTbl[(u8)seq_no];
 	for(i=0; i<8; i++, work++) {
 		if(work->stat == 0) {
 			break;
@@ -243,7 +243,7 @@ static s16 CreateSeq(u8 seq_no, va_list params)
 		HuMemDirectFree(work->data);
 	}
 	work->data = NULL;
-	work->seq_no = (s32)seq_no;
+	work->seq_no = (u8)seq_no;
 	work->time = 0;
 	work->x = info->x;
 	work->y = info->y;
@@ -1047,7 +1047,7 @@ static int SeqUpdateMGBasic(SeqWork *work)
 		work->type = -1;
 		work->work_float[0] = 0.0f;
 	}
-	if(work->type != 0) {
+	if(work->type) {
 		switch(work->type) {
 			case 1:
 			{
@@ -1176,7 +1176,6 @@ static int SeqInitMGCommon(SeqWork *work, va_list params)
 	s16 i;
 	float tp_lvl;
 	s16 j;
-	
 	s16 word_grp;
 	
 	work->work_s16[1] = va_arg(params, int);
@@ -1187,7 +1186,6 @@ static int SeqInitMGCommon(SeqWork *work, va_list params)
 	work->work_float[0] = 0;
 	tp_lvl = 1.0f;
 	for(i=0; i<4; i++) {
-		
 		if(i == 0)
 		{
 			s32 word_katakana;
@@ -1247,6 +1245,249 @@ static int SeqInitMGCommon(SeqWork *work, va_list params)
 	return 1;
 }
 
+static int SeqUpdateMGBattle(SeqWork *work)
+{
+	s16 idx;
+	float scale;
+	if(work->param[0] != 0 && work->type != -1) {
+		switch(work->param[0]) {
+			case 2:
+				if(work->param[1] != -1) {
+					(void)work; //HACK: to introduce extra branch
+				} else {
+					work->type = -1;
+					work->work_float[0] = 0.0f;
+				}
+				work->param[0] = 0;
+				break;
+				
+			case 1:
+				work->time_max = work->param[1];
+				work->param[0] = 0;
+				break;
+				
+			case 3:
+				work->type = 1;
+				work->param[0] = 0;
+				break;
+				
+			default:
+				work->param[0] = 0;
+				break;
+		}
+	}
+	if(work->type == 2) {
+		return 1;
+	}
+	work->time += seqSpeed;
+	if(work->time >= work->time_max && work->type != -1) {
+		work->stat |= 0x4;
+		work->type = -1;
+		work->work_float[0] = 0.0f;
+	}
+	if(work->type) {
+		switch(work->type) {
+			case 1:
+			{
+				s16 i, j;
+				float time;
+				float pos_x;
+				if(work->work_s16[1] == 0) {
+					if(work->time < 45) {
+						if(work->time > 10 && work->time <= 40) {
+							time = work->time-10;
+							scale = 10.0f*(1.0f-(time/30.0f));
+							pos_x = (work->x-(0.5f*(work->work_s16[3]*56)))+28.0f;
+							HuSprPosSet(work->spr_grp[0], 0, pos_x, work->y);
+							HuSprScaleSet(work->spr_grp[0], 0, work->scale_x+scale, work->scale_y+scale);
+							scale = time/30.0f;
+							HuSprTPLvlSet(work->spr_grp[0], 0, scale);
+						}
+						for(i=0; i<4; i++) {
+							time = work->time-i;
+							if(time < 0 || time > 40) {
+								continue;
+							}
+							for(j=1; j<work->work_s16[3]; j++) {
+								pos_x = (28.0f+(work->x-(0.5f*(work->work_s16[3]*56))))+(j*56);
+								if(time == 40.0f) {
+									HuSprPosSet(work->spr_grp[i], j, pos_x, work->y);
+									HuSprZRotSet(work->spr_grp[i], j, 0.0f);
+									HuSprScaleSet(work->spr_grp[i], j, work->scale_x, work->scale_y);
+									if(i != 0) {
+										HuSprAttrSet(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
+									}
+								} else {
+									s16 discard_cnt;
+									static float letterOfs[] = {
+										30, 20,
+										20, 3,
+										-4, 20,
+										-30, 20,
+										20, 20,
+										-30, 20,
+										-10, 40,
+										10, -40
+									};
+									float x, y;
+									float ofs_x, ofs_y;
+									float zrot, scale_ang;
+									x = pos_x;
+									y = work->y;
+									ofs_x = letterOfs[((j-1)&0x7)*2];
+									ofs_y = letterOfs[(((j-1)&0x7)*2)+1];
+									zrot = 0.0f;
+									discard_cnt = 0;
+									scale_ang = 0.0f;
+									for(idx=0; idx<40.0f-time; idx++) {
+										if(x+ofs_x > 576 || x+ofs_x < 0) {
+											ofs_x = -ofs_x;
+											discard_cnt++;
+										}
+										if(y+ofs_y > 480 || y+ofs_y < 0) {
+											ofs_y = -ofs_y;
+											discard_cnt++;
+										}
+										if(discard_cnt) {
+											zrot += 20.0f;
+											scale_ang = 0.0f;
+										}
+										x += ofs_x;
+										y += ofs_y;
+									}
+									HuSprPosSet(work->spr_grp[i], j, x, y);
+									HuSprScaleSet(work->spr_grp[i], j, work->scale_x*cos((M_PI*scale_ang)/180.0), work->scale_y);
+									HuSprZRotSet(work->spr_grp[i], j, zrot);
+								}
+							}
+						}
+					} else {
+						if(work->time > 60) {
+							time = work->time-60;
+							scale = 0.5*sin((M_PI*(time*9.0f))/180.0);
+							for(j=0; j<work->work_s16[3]; j++) {
+								pos_x = (28.0f*(scale+work->scale_x))+(work->x-(0.5f*((work->work_s16[3]*56)*(scale+work->scale_x))))+((j*56)*(scale+work->scale_x));
+								HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
+								HuSprScaleSet(work->spr_grp[0], j, work->scale_x+scale, work->scale_y+scale);
+							}
+						}
+					}
+					if(work->time == 60) {
+						HuAudFXPlay(36);
+						work->stat |= 0x10;
+					}
+					if(work->time == 80) {
+						work->stat |= 0x4;
+						SeqPlayStartFX();
+					}
+					if(work->time >= 80) {
+						work->type = 0;
+					}
+				} else {
+					if(work->time == 1) {
+						if(work->work_s16[1] == 1) {
+							HuAudFXPlay(37);
+						} else {
+							HuAudFXPlay(40);
+						}
+						MGSeqPauseEnableCtrl(0);
+						work->stat |= 0x10;
+					}
+					if(work->time <= 20) {
+						for(i=1; i<4; i++) {
+							for(j=0; j<work->work_s16[3]; j++) {
+								HuSprAttrSet(work->spr_grp[i], j, SPRITE_ATTR_HIDDEN);
+							}
+						}
+						time = work->time;
+						scale = work->scale_x+(0.5*sin((M_PI*(time*9.0f))/180.0));
+						for(j=0; j<work->work_s16[3]; j++) {
+							HuSprAttrReset(work->spr_grp[0], j, SPRITE_ATTR_HIDDEN);
+							pos_x = ((28.0f*scale)+(work->x-(0.5f*(scale*(work->work_s16[3]*56)))))+(scale*(j*56));
+							HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
+							HuSprScaleSet(work->spr_grp[0], j, work->scale_x+(sin((M_PI*(time*9.0f))/180.0)), work->scale_y+(sin((M_PI*(time*9.0f))/180.0)));
+						}
+						if(time == 20.0f) {
+							for(j=0; j<work->work_s16[3]; j++) {
+								HuSprAttrReset(work->spr_grp[0], j, SPRITE_ATTR_HIDDEN);
+							}
+						}
+					} else {
+						if(work->time > 80 && work->time <= 95) {
+							time = work->time-80;
+							for(j=0; j<work->work_s16[3]; j++) {
+								pos_x = (28.0f+(work->x-(0.5f*(work->work_s16[3]*56))))+(j*56);
+								HuSprPosSet(work->spr_grp[0], j, pos_x+((288.0f-pos_x)*(1.0-cos((M_PI*(time*6.0))/180.0))), work->y);
+							}
+							if(time == 15.0f) {
+								for(j=0; j<work->work_s16[3]; j++) {
+									HuSprAttrReset(work->spr_grp[1], j, SPRITE_ATTR_HIDDEN);
+									HuSprPosSet(work->spr_grp[1], j, 288.0f, work->y);
+									HuSprTPLvlSet(work->spr_grp[1], j, 1.0f);
+								}
+							}
+						} else {
+							if(work->time > 105) {
+								for(j=0; j<work->work_s16[3]; j++) {
+									time = work->time-105;
+									time -= j*3;
+									if(time < 0) {
+										continue;
+									}
+									scale = 1.0f-(time/15.0f);
+									if(scale < 0.0f) {
+										scale = 0.0f;
+									}
+									HuSprPosSet(work->spr_grp[0], j, 288.0f, work->y+((-100.0f-work->y)*(time/20.0f)));
+									HuSprTPLvlSet(work->spr_grp[0], j, scale);
+									HuSprPosSet(work->spr_grp[1], j, 288.0f, work->y+((580.0f-work->y)*(time/20.0f)));
+									HuSprTPLvlSet(work->spr_grp[1], j, scale);
+								}
+							}
+						}
+					}
+					if(work->time == 130) {
+						work->stat |= 0x4;
+					}
+					if(work->time >= 130) {
+						work->type = 0;
+						work->stat |= 0x8;
+					}
+				}
+				
+			}
+				break;
+				
+			case -1:
+			{
+				work->work_float[0] += seqSpeed*0.1f;
+				scale = 1.0f-work->work_float[0];
+				if(scale <= 0.0f) {
+					scale = 0.0f;
+					work->type = 0;
+					work->stat |= 0x8;
+					if(work->work_s16[1] == 0) {
+						MGSeqPauseEnableCtrl(1);
+					}
+				}
+				for(idx=0; idx<work->work_s16[3]; idx++) {
+					HuSprTPLvlSet(work->spr_grp[0], idx, scale);
+				}
+			}
+				break;
+				
+			default:
+				break;
+		}
+	}
+	if(seqDoneF || (work->stat & 0x8)) {
+		MGSeqSprKill(work);
+		return 0;
+	}
+	return 1;
+}
+
+
 static int SeqInitDraw(SeqWork *work, va_list params)
 {
 	

From a19c0433de63723375c079a627e84571950cce61 Mon Sep 17 00:00:00 2001
From: gamemasterplc <gamemasterplc@gmail.com>
Date: Sat, 3 Feb 2024 13:40:58 -0600
Subject: [PATCH 14/15] Document mgInfoTbl more

---
 include/game/board/main.h    |    4 +-
 include/game/gamework_data.h |    8 +-
 include/game/objsub.h        |   11 +-
 src/game/board/main.c        |   18 +-
 src/game/minigame_seq.c      |    4 +-
 src/game/objsub.c            | 1217 ++++++++++++++++------------------
 6 files changed, 597 insertions(+), 665 deletions(-)

diff --git a/include/game/board/main.h b/include/game/board/main.h
index 0a6d7c19..4377de77 100644
--- a/include/game/board/main.h
+++ b/include/game/board/main.h
@@ -87,8 +87,8 @@ s32 BoardIsKill(void);
 void BoardPauseDisableSet(s32 value);
 s32 BoardPauseDisableGet();
 void BoardSaveInit(s32 board);
-void BoardStoryConfigSet(s32 mg_type, s32 diff_story);
-void BoardPartyConfigSet(s32 team, s32 bonus_star, s32 mg_type, s32 max_turn, s32 p1_handicap, s32 p2_handicap, s32 p3_handicap, s32 p4_handicap);
+void BoardStoryConfigSet(s32 mg_list, s32 diff_story);
+void BoardPartyConfigSet(s32 team, s32 bonus_star, s32 mg_list, s32 max_turn, s32 p1_handicap, s32 p2_handicap, s32 p3_handicap, s32 p4_handicap);
 s32 BoardTurnNext(void);
 void BoardNextOvlSet(OverlayID overlay);
 s32 BoardStartCheck(void);
diff --git a/include/game/gamework_data.h b/include/game/gamework_data.h
index 70d377b7..ebd0bc77 100644
--- a/include/game/gamework_data.h
+++ b/include/game/gamework_data.h
@@ -21,7 +21,7 @@ typedef struct system_state {
         u16 bonus_star : 1;
         u16 explain_mg : 1;
         u16 show_com_mg : 1;
-        u16 mg_type : 2;
+        u16 mg_list : 2;
         u16 mess_speed : 2;
         u16 save_mode : 2;
     };
@@ -45,7 +45,7 @@ typedef struct system_state {
     };
 /* 0x32 */ s8 unk_32;
 /* 0x34 */ u16 mg_next;
-/* 0x36 */ s16 mg_next_extra;
+/* 0x36 */ s16 mg_next_type;
 /* 0x38 */ u16 unk_38;
 /* 0x3A */ u8 flag[3][16];
 /* 0x6A */ u8 unk_6A[0x72];
@@ -157,9 +157,9 @@ static inline s32 GWLanguageGet(void)
     return GWGameStat.language;
 }
 
-static inline s32 GWMGTypeGet(void)
+static inline s32 GWMGListGet(void)
 {
-    return GWSystem.mg_type;
+    return GWSystem.mg_list;
 }
 
 static inline s32 GWMessSpeedGet(void)
diff --git a/include/game/objsub.h b/include/game/objsub.h
index 5b458d18..d8501eeb 100644
--- a/include/game/objsub.h
+++ b/include/game/objsub.h
@@ -9,16 +9,11 @@ typedef struct mg_info {
     u16 ovl;
     u8 type;
     u8 flag;
-    u16 unk_4;
-    u16 unk_6;
+    s8 unk_4;
     u32 name_mess;
     u32 data_dir;
-    u32 inst_pic;
-    u32 unk_14;
-    u32 unk_18;
-    u32 mg_pic;
-    u32 unk_20;
-    u32 unk_24;
+    u32 inst_pic[3];
+    u32 mg_pic[3];
     u32 rules_mess;
     u32 control_mess[2];
     u32 advice_mess;
diff --git a/src/game/board/main.c b/src/game/board/main.c
index 6266a194..6f4de9c2 100644
--- a/src/game/board/main.c
+++ b/src/game/board/main.c
@@ -290,7 +290,7 @@ void BoardSaveInit(s32 board)
 	GWSystem.field31_bit4 = 0;
 	GWSystem.unk_32 = 1;
 	GWSystem.mg_next = 0;
-	GWSystem.mg_next_extra = 0;
+	GWSystem.mg_next_type = 0;
 	GWSystem.unk_38 = 0;
 	GWSystem.block_pos = 0;
 	memset(GWSystem.board_data, 0, 32);
@@ -334,13 +334,13 @@ void BoardSaveInit(s32 board)
 	}
 }
 
-void BoardStoryConfigSet(s32 mg_type, s32 diff_story)
+void BoardStoryConfigSet(s32 mg_list, s32 diff_story)
 {
 	GWSystem.party = 0;
 	GWSystem.team = 0;
 	GWSystem.diff_story = diff_story;
 	GWSystem.bonus_star = 0;
-	GWSystem.mg_type = mg_type;
+	GWSystem.mg_list = mg_list;
 	GWPlayer[0].handicap = 0;
 	GWPlayer[1].handicap = 0;
 	GWPlayer[2].handicap = 0;
@@ -358,13 +358,13 @@ void BoardStoryConfigSet(s32 mg_type, s32 diff_story)
 	_SetFlag(FLAG_ID_MAKE(1, 10));
 }
 
-void BoardPartyConfigSet(s32 team, s32 bonus_star, s32 mg_type, s32 max_turn, s32 p1_handicap, s32 p2_handicap, s32 p3_handicap, s32 p4_handicap)
+void BoardPartyConfigSet(s32 team, s32 bonus_star, s32 mg_list, s32 max_turn, s32 p1_handicap, s32 p2_handicap, s32 p3_handicap, s32 p4_handicap)
 {
 	GWSystem.party = 1;
 	GWSystem.team = team;
 	GWSystem.diff_story = 0;
 	GWSystem.bonus_star = bonus_star;
-	GWSystem.mg_type = mg_type;
+	GWSystem.mg_list = mg_list;
 	GWSystem.max_turn = max_turn;
 	memset(GWPlayer, 0, 4*sizeof(PlayerState));
 	GWPlayer[0].handicap = p1_handicap;
@@ -617,11 +617,11 @@ static void CreateBoard(void)
 	GWSystem.mg_next = -1;
 	if(!GWGameStat.field10E_bit5) {
 		s32 type_temp;
-		if(GWSystem.mg_type == 3) {
-			GWSystem.mg_type = 0;
+		if(GWSystem.mg_list == 3) {
+			GWSystem.mg_list = 0;
 		}
-		if(GWMGTypeGet() == 2) {
-			GWSystem.mg_type = 0;
+		if(GWMGListGet() == 2) {
+			GWSystem.mg_list = 0;
 		}
 	}
 	if(GWSystem.mess_speed == 3) {
diff --git a/src/game/minigame_seq.c b/src/game/minigame_seq.c
index 4e31c6a7..38fd3919 100644
--- a/src/game/minigame_seq.c
+++ b/src/game/minigame_seq.c
@@ -1493,12 +1493,12 @@ static int SeqInitDraw(SeqWork *work, va_list params)
 	
 }
 
-static void SeqPlayStartFX(void)
+void MGSeqPauseEnableCtrl(s32 flag)
 {
 	
 }
 
-void MGSeqPauseEnableCtrl(s32 flag)
+static void SeqPlayStartFX(void)
 {
 	
 }
\ No newline at end of file
diff --git a/src/game/objsub.c b/src/game/objsub.c
index 2a4ce6f9..414ae740 100644
--- a/src/game/objsub.c
+++ b/src/game/objsub.c
@@ -1,1219 +1,1156 @@
 #include "game/objsub.h"
 #include "game/gamework_data.h"
 #include "game/object.h"
+#include "game/data.h"
 
 MgInfo mgInfoTbl[] = {
     {
-        9, // ovl
+        OVL_M401, // ovl
         0, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170001, // name_mess
-        0x200000, // data_dir
-        0x160000, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160000, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M401), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 0), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 0), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210000, // rules_mess
         0x210001, // control_mess[0]
         0, // control_mess[1]
         0x210003, // advice_mess
     },
     {
-        10, // ovl
+        OVL_M402, // ovl
         0, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170002, // name_mess
-        0x210000, // data_dir
-        0x160001, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160001, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M402), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 1), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 1), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210004, // rules_mess
         0x210005, // control_mess[0]
         0, // control_mess[1]
         0x210007, // advice_mess
     },
     {
-        11, // ovl
+        OVL_M403, // ovl
         0, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170003, // name_mess
-        0x220000, // data_dir
-        0x160002, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160002, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M403), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 2), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 2), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210008, // rules_mess
         0x210009, // control_mess[0]
         0, // control_mess[1]
         0x21000B, // advice_mess
     },
     {
-        12, // ovl
+        OVL_M404, // ovl
         4, // type
         2, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170004, // name_mess
-        0x230000, // data_dir
-        0x160003, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160003, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M404), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 3), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 3), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x21000C, // rules_mess
         0x21000D, // control_mess[0]
         0, // control_mess[1]
         0x21000F, // advice_mess
     },
     {
-        13, // ovl
+        OVL_M405, // ovl
         0, // type
         2, // flag
-        0, // unk_4
-        0, // unk_6
+        0, // record_idx
         0x170005, // name_mess
-        0x240000, // data_dir
-        0x160004, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160004, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M405), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 4), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 4), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210010, // rules_mess
         0x210011, // control_mess[0]
         0, // control_mess[1]
         0x210013, // advice_mess
     },
     {
-        14, // ovl
+        OVL_M406, // ovl
         0, // type
         2, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170006, // name_mess
-        0x250000, // data_dir
-        0x160005, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160005, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M406), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 5), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 5), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210014, // rules_mess
         0x210015, // control_mess[0]
         0, // control_mess[1]
         0x210017, // advice_mess
     },
     {
-        15, // ovl
+        OVL_M407, // ovl
         0, // type
         3, // flag
-        256, // unk_4
-        0, // unk_6
+        1, // record_idx
         0x170007, // name_mess
-        0x260000, // data_dir
-        0x160006, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160006, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M407), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 6), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 6), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210018, // rules_mess
         0x210019, // control_mess[0]
         0, // control_mess[1]
         0x21001B, // advice_mess
     },
     {
-        16, // ovl
+        OVL_M408, // ovl
         0, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170008, // name_mess
-        0x270000, // data_dir
-        0x160007, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160007, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M408), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 7), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 7), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x21001C, // rules_mess
         0x21001D, // control_mess[0]
         0, // control_mess[1]
         0x21001F, // advice_mess
     },
     {
-        17, // ovl
+        OVL_M409, // ovl
         0, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170009, // name_mess
-        0x280000, // data_dir
-        0x160008, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160008, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M409), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 8), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 8), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210020, // rules_mess
         0x210021, // control_mess[0]
         0, // control_mess[1]
         0x210023, // advice_mess
     },
     {
-        18, // ovl
+        OVL_M410, // ovl
         0, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x17000A, // name_mess
-        0x290000, // data_dir
-        0x160009, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160009, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M410), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 9), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 9), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210024, // rules_mess
         0x210025, // control_mess[0]
         0, // control_mess[1]
         0x210027, // advice_mess
     },
     {
-        19, // ovl
+        OVL_M411, // ovl
         0, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x17000B, // name_mess
-        0x2A0000, // data_dir
-        0x16000A, // inst_pic
-        0x16000B, // unk_14
-        0x16000C, // unk_18
-        0x16003E, // mg_pic
-        0x16000B, // unk_20
-        0x16000C, // unk_24
+        MAKE_DIR_NUM(DATADIR_M411), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 10), // inst_pic[0]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 11), // inst_pic[1]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 12), // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 62), // mg_pic[0]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 11), // mg_pic[1]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 12), // mg_pic[2]
         0x210028, // rules_mess
         0x210029, // control_mess[0]
         0, // control_mess[1]
         0x21002B, // advice_mess
     },
     {
-        20, // ovl
+        OVL_M412, // ovl
         0, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x17000C, // name_mess
-        0x2B0000, // data_dir
-        0x16000D, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x16000D, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M412), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 13), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 13), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x21002C, // rules_mess
         0x21002D, // control_mess[0]
         0, // control_mess[1]
         0x21002F, // advice_mess
     },
     {
-        21, // ovl
+        OVL_M413, // ovl
         0, // type
         2, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x17000D, // name_mess
-        0x2C0000, // data_dir
-        0x16000E, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x16003F, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M413), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 14), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 63), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210030, // rules_mess
         0x210031, // control_mess[0]
         0, // control_mess[1]
         0x210033, // advice_mess
     },
     {
-        22, // ovl
+        OVL_M414, // ovl
         0, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x17000E, // name_mess
-        0x2D0000, // data_dir
-        0x16000F, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x16000F, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M414), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 15), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 15), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210034, // rules_mess
         0x210035, // control_mess[0]
         0, // control_mess[1]
         0x210037, // advice_mess
     },
     {
-        23, // ovl
+        OVL_M415, // ovl
         0, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x17000F, // name_mess
-        0x2E0000, // data_dir
-        0x160010, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160010, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M415), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 16), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 16), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210038, // rules_mess
         0x210039, // control_mess[0]
         0, // control_mess[1]
         0x21003B, // advice_mess
     },
     {
-        24, // ovl
+        OVL_M416, // ovl
         1, // type
         1, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170010, // name_mess
-        0x2F0000, // data_dir
-        0x160011, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160011, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M416), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 17), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 17), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x21003C, // rules_mess
         0x21003D, // control_mess[0]
         0x21003E, // control_mess[1]
         0x21003F, // advice_mess
     },
     {
-        25, // ovl
+        OVL_M417, // ovl
         1, // type
         1, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170011, // name_mess
-        0x300000, // data_dir
-        0x160012, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160012, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M417), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 18), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 18), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210040, // rules_mess
         0x210041, // control_mess[0]
         0x210042, // control_mess[1]
         0x210043, // advice_mess
     },
     {
-        26, // ovl
+        OVL_M418, // ovl
         1, // type
         1, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170012, // name_mess
-        0x310000, // data_dir
-        0x160013, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160013, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M418), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 19), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 19), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210044, // rules_mess
         0x210045, // control_mess[0]
         0x210046, // control_mess[1]
         0x210047, // advice_mess
     },
     {
-        27, // ovl
+        OVL_M419, // ovl
         1, // type
         1, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170013, // name_mess
-        0x320000, // data_dir
-        0x160014, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160014, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M419), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 20), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 20), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210048, // rules_mess
         0x210049, // control_mess[0]
         0x21004A, // control_mess[1]
         0x21004B, // advice_mess
     },
     {
-        28, // ovl
+        OVL_M420, // ovl
         1, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170014, // name_mess
-        0x330000, // data_dir
-        0x160015, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160015, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M420), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 21), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 21), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x21004C, // rules_mess
         0x21004D, // control_mess[0]
         0x21004E, // control_mess[1]
         0x21004F, // advice_mess
     },
     {
-        29, // ovl
+        OVL_M421, // ovl
         1, // type
         1, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170015, // name_mess
-        0x340000, // data_dir
-        0x160016, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160016, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M421), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 22), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 22), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210050, // rules_mess
         0x210051, // control_mess[0]
         0x210052, // control_mess[1]
         0x210053, // advice_mess
     },
     {
-        30, // ovl
+        OVL_M422, // ovl
         1, // type
         1, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170016, // name_mess
-        0x350000, // data_dir
-        0x160017, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160017, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M422), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 23), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 23), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210054, // rules_mess
         0x210055, // control_mess[0]
         0x210056, // control_mess[1]
         0x210057, // advice_mess
     },
     {
-        31, // ovl
+        OVL_M423, // ovl
         1, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170017, // name_mess
-        0x360000, // data_dir
-        0x160018, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160018, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M423), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 24), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 24), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210058, // rules_mess
         0x210059, // control_mess[0]
         0x21005A, // control_mess[1]
         0x21005B, // advice_mess
     },
     {
-        32, // ovl
+        OVL_M424, // ovl
         1, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170018, // name_mess
-        0x370000, // data_dir
-        0x160019, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160019, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M424), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 25), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 25), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x21005C, // rules_mess
         0x21005D, // control_mess[0]
         0x21005E, // control_mess[1]
         0x21005F, // advice_mess
     },
     {
-        33, // ovl
+        OVL_M425, // ovl
         2, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170019, // name_mess
-        0x380000, // data_dir
-        0x16001A, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x16001A, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M425), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 26), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 26), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210060, // rules_mess
         0x210061, // control_mess[0]
         0, // control_mess[1]
         0x210063, // advice_mess
     },
     {
-        34, // ovl
+        OVL_M426, // ovl
         2, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x17001A, // name_mess
-        0x390000, // data_dir
-        0x16001B, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x16001B, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M426), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 27), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 27), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210064, // rules_mess
         0x210065, // control_mess[0]
         0, // control_mess[1]
         0x210067, // advice_mess
     },
     {
-        35, // ovl
+        OVL_M427, // ovl
         2, // type
         2, // flag
-        512, // unk_4
-        0, // unk_6
+        2, // record_idx
         0x17001B, // name_mess
-        0x3A0000, // data_dir
-        0x16001C, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x16001C, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M427), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 28), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 28), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210068, // rules_mess
         0x210069, // control_mess[0]
         0, // control_mess[1]
         0x21006B, // advice_mess
     },
     {
-        36, // ovl
+        OVL_M428, // ovl
         2, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x17001C, // name_mess
-        0x3B0000, // data_dir
-        0x16001D, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x16001D, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M428), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 29), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 29), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x21006C, // rules_mess
         0x21006D, // control_mess[0]
         0, // control_mess[1]
         0x21006F, // advice_mess
     },
     {
-        37, // ovl
+        OVL_M429, // ovl
         2, // type
         2, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x17001D, // name_mess
-        0x3C0000, // data_dir
-        0x16001E, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160040, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M429), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 30), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 64), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210070, // rules_mess
         0x210071, // control_mess[0]
         0, // control_mess[1]
         0x210073, // advice_mess
     },
     {
-        38, // ovl
+        OVL_M430, // ovl
         2, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x17001E, // name_mess
-        0x3D0000, // data_dir
-        0x16001F, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x16001F, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M430), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 31), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 31), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210074, // rules_mess
         0x210075, // control_mess[0]
         0x210076, // control_mess[1]
         0x210077, // advice_mess
     },
     {
-        39, // ovl
+        OVL_M431, // ovl
         2, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x17001F, // name_mess
-        0x3E0000, // data_dir
-        0x160020, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160020, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M431), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 32), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 32), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210078, // rules_mess
         0x210079, // control_mess[0]
         0, // control_mess[1]
         0x21007B, // advice_mess
     },
     {
-        40, // ovl
+        OVL_M432, // ovl
         2, // type
         3, // flag
-        768, // unk_4
-        0, // unk_6
+        3, // record_idx
         0x170020, // name_mess
-        0x3F0000, // data_dir
-        0x160021, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160021, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M432), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 33), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 33), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x21007C, // rules_mess
         0x21007D, // control_mess[0]
         0x21007E, // control_mess[1]
         0x21007F, // advice_mess
     },
     {
-        41, // ovl
+        OVL_M433, // ovl
         7, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170021, // name_mess
-        0x400000, // data_dir
-        0x160022, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160022, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M433), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 34), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 34), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210080, // rules_mess
         0x37001F, // control_mess[0]
         0, // control_mess[1]
         0x210083, // advice_mess
     },
     {
-        42, // ovl
+        OVL_M434, // ovl
         2, // type
         2, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170022, // name_mess
-        0x410000, // data_dir
-        0x160023, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160023, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M434), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 35), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 35), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210084, // rules_mess
         0x210085, // control_mess[0]
         0, // control_mess[1]
         0x210087, // advice_mess
     },
     {
-        43, // ovl
+        OVL_M435, // ovl
         3, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170023, // name_mess
-        0x420000, // data_dir
-        0x160024, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160024, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M435), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 36), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 36), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0, // rules_mess
         0x210089, // control_mess[0]
         0, // control_mess[1]
         0, // advice_mess
     },
     {
-        44, // ovl
+        OVL_M436, // ovl
         3, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170024, // name_mess
-        0x430000, // data_dir
-        0x160025, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160025, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M436), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 37), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 37), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0, // rules_mess
         0x21008D, // control_mess[0]
         0, // control_mess[1]
         0, // advice_mess
     },
     {
-        45, // ovl
+        OVL_M437, // ovl
         3, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170025, // name_mess
-        0x440000, // data_dir
-        0x160026, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160026, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M437), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 38), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 38), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0, // rules_mess
         0x210091, // control_mess[0]
         0, // control_mess[1]
         0, // advice_mess
     },
     {
-        46, // ovl
+        OVL_M438, // ovl
         4, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170026, // name_mess
-        0x450000, // data_dir
-        0x160027, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160027, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M438), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 39), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 39), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210094, // rules_mess
         0x210095, // control_mess[0]
         0, // control_mess[1]
         0x210097, // advice_mess
     },
     {
-        47, // ovl
+        OVL_M439, // ovl
         4, // type
         2, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170027, // name_mess
-        0x460000, // data_dir
-        0x160028, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160028, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M439), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 40), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 40), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x210098, // rules_mess
         0x210099, // control_mess[0]
         0, // control_mess[1]
         0x21009B, // advice_mess
     },
     {
-        48, // ovl
+        OVL_M440, // ovl
         4, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170028, // name_mess
-        0x470000, // data_dir
-        0x160029, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160029, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M440), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 41), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 41), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x21009C, // rules_mess
         0x21009D, // control_mess[0]
         0, // control_mess[1]
         0x21009F, // advice_mess
     },
     {
-        49, // ovl
+        OVL_M441, // ovl
         4, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170029, // name_mess
-        0x480000, // data_dir
-        0x16002A, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x16002A, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M441), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 42), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 42), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x2100A0, // rules_mess
         0x2100A1, // control_mess[0]
         0, // control_mess[1]
         0x2100A3, // advice_mess
     },
     {
-        50, // ovl
+        OVL_M442, // ovl
         7, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x17002A, // name_mess
-        0x490000, // data_dir
-        0x16002B, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160041, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M442), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 43), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 65), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x2100A4, // rules_mess
         0x370010, // control_mess[0]
         0, // control_mess[1]
         0x2100A7, // advice_mess
     },
     {
-        51, // ovl
+        OVL_M443, // ovl
         0, // type
         2, // flag
-        1280, // unk_4
-        0, // unk_6
+        5, // record_idx
         0x17002B, // name_mess
-        0x4A0000, // data_dir
-        0x16002C, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x16002C, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M443), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 44), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 44), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x2100A8, // rules_mess
         0x2100A9, // control_mess[0]
         0, // control_mess[1]
         0x2100AB, // advice_mess
     },
     {
-        52, // ovl
+        OVL_M444, // ovl
         5, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x17002C, // name_mess
-        0x4B0000, // data_dir
-        0x16002D, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x16002D, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M444), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 45), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 45), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0, // rules_mess
         0, // control_mess[0]
         0, // control_mess[1]
         0, // advice_mess
     },
     {
-        53, // ovl
+        OVL_M445, // ovl
         6, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x17002D, // name_mess
-        0x4C0000, // data_dir
-        0x16002E, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x16002E, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M445), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 46), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 46), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x2100AC, // rules_mess
         0x2100AD, // control_mess[0]
         0, // control_mess[1]
         0x2100AF, // advice_mess
     },
     {
-        54, // ovl
+        OVL_M446, // ovl
         6, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x17002E, // name_mess
-        0x4D0000, // data_dir
-        0x16002F, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x16002F, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M446), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 47), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 47), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x2100B0, // rules_mess
         0x2100B1, // control_mess[0]
         0, // control_mess[1]
         0x2100B3, // advice_mess
     },
     {
-        55, // ovl
+        OVL_M447, // ovl
         6, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x17002F, // name_mess
-        0x4E0000, // data_dir
-        0x160030, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160030, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M447), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 48), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 48), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x2100B4, // rules_mess
         0x2100B5, // control_mess[0]
         0, // control_mess[1]
         0x2100B7, // advice_mess
     },
     {
-        56, // ovl
+        OVL_M448, // ovl
         6, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170030, // name_mess
-        0x4F0000, // data_dir
-        0x160031, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160031, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M448), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 49), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 49), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x2100B8, // rules_mess
         0x2100B9, // control_mess[0]
         0, // control_mess[1]
         0x2100BB, // advice_mess
     },
     {
-        57, // ovl
+        OVL_M449, // ovl
         6, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170031, // name_mess
-        0x500000, // data_dir
-        0x160032, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160032, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M449), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 50), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 50), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x2100BC, // rules_mess
         0x2100BD, // control_mess[0]
         0, // control_mess[1]
         0x2100BF, // advice_mess
     },
     {
-        58, // ovl
+        OVL_M450, // ovl
         8, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170032, // name_mess
-        0x510000, // data_dir
-        0x160033, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160033, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M450), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 51), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 51), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x2100C0, // rules_mess
         0x2100C1, // control_mess[0]
         0, // control_mess[1]
         0x2100C3, // advice_mess
     },
     {
-        59, // ovl
+        OVL_M451, // ovl
         7, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170033, // name_mess
-        0x520000, // data_dir
-        0x160034, // inst_pic
-        0x160035, // unk_14
-        0x160036, // unk_18
-        0x160034, // mg_pic
-        0x160035, // unk_20
-        0x160036, // unk_24
+        MAKE_DIR_NUM(DATADIR_M451), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 52), // inst_pic[0]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 53), // inst_pic[1]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 54), // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 52), // mg_pic[0]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 53), // mg_pic[1]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 54), // mg_pic[2]
         0x2100C4, // rules_mess
         0x37000D, // control_mess[0]
         0, // control_mess[1]
         0x2100C7, // advice_mess
     },
     {
-        58, // ovl
+        OVL_M450, // ovl
         7, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170033, // name_mess
-        0x510000, // data_dir
-        0x160037, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160037, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M450), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 55), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 55), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0, // rules_mess
         0, // control_mess[0]
         0, // control_mess[1]
         0, // advice_mess
     },
     {
-        60, // ovl
+        OVL_M453, // ovl
         7, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170034, // name_mess
-        0x510000, // data_dir
-        0x160032, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160032, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M450), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 50), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 50), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x2100C8, // rules_mess
         0x37000A, // control_mess[0]
         0, // control_mess[1]
         0x2100CB, // advice_mess
     },
     {
-        58, // ovl
+        OVL_M450, // ovl
         7, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170033, // name_mess
-        0x510000, // data_dir
-        0x160037, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160037, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M450), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 55), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 55), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0, // rules_mess
         0, // control_mess[0]
         0, // control_mess[1]
         0, // advice_mess
     },
     {
-        61, // ovl
+        OVL_M455, // ovl
         4, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170035, // name_mess
-        0x540000, // data_dir
-        0x160038, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160038, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M455), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 56), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 56), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x2100CC, // rules_mess
         0x2100CD, // control_mess[0]
         0, // control_mess[1]
         0x2100CF, // advice_mess
     },
     {
-        62, // ovl
+        OVL_M456, // ovl
         0, // type
         3, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170036, // name_mess
-        0x550000, // data_dir
-        0x160039, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160039, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M456), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 57), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 57), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0x2100D0, // rules_mess
         0x2100D1, // control_mess[0]
         0, // control_mess[1]
         0x2100D3, // advice_mess
     },
     {
-        63, // ovl
+        OVL_M457, // ovl
         8, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170037, // name_mess
-        0x560000, // data_dir
-        0x16003A, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x16003A, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M457), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 58), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 58), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0, // rules_mess
         0, // control_mess[0]
         0, // control_mess[1]
         0, // advice_mess
     },
     {
-        64, // ovl
+        OVL_M458, // ovl
         8, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170038, // name_mess
-        0x570000, // data_dir
-        0x16003B, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x16003B, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M458), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 59), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 59), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0, // rules_mess
         0, // control_mess[0]
         0, // control_mess[1]
         0, // advice_mess
     },
     {
-        65, // ovl
+        OVL_M459, // ovl
         7, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170038, // name_mess
-        0x570000, // data_dir
-        0x160032, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160032, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M458), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 50), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 50), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0, // rules_mess
         0x370013, // control_mess[0]
         0, // control_mess[1]
         0, // advice_mess
     },
     {
-        66, // ovl
+        OVL_M460, // ovl
         7, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170038, // name_mess
-        0x570000, // data_dir
-        0x160032, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160032, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M458), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 50), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 50), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0, // rules_mess
         0x370016, // control_mess[0]
         0, // control_mess[1]
         0, // advice_mess
     },
     {
-        67, // ovl
+        OVL_M461, // ovl
         7, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170038, // name_mess
-        0x570000, // data_dir
-        0x160032, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160032, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M458), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 50), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 50), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0, // rules_mess
         0x370019, // control_mess[0]
         0, // control_mess[1]
         0, // advice_mess
     },
     {
-        68, // ovl
+        OVL_M462, // ovl
         7, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170038, // name_mess
-        0x570000, // data_dir
-        0x160032, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160032, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M458), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 50), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 50), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0, // rules_mess
         0x37001C, // control_mess[0]
         0, // control_mess[1]
         0, // advice_mess
     },
     {
-        69, // ovl
+        OVL_M463, // ovl
         7, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0x170038, // name_mess
-        0x570000, // data_dir
-        0x160032, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0x160032, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        MAKE_DIR_NUM(DATADIR_M458), // data_dir
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 50), // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        MAKE_DATA_NUM(DATADIR_INSTPIC, 50), // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0, // rules_mess
         0x370007, // control_mess[0]
         0, // control_mess[1]
         0, // advice_mess
     },
     {
-        0xFFFF, // ovl
+        ((u16)OVL_INVALID), // ovl
         0, // type
         0, // flag
-        65280, // unk_4
-        0, // unk_6
+        255, // record_idx
         0, // name_mess
         0, // data_dir
-        0, // inst_pic
-        0, // unk_14
-        0, // unk_18
-        0, // mg_pic
-        0, // unk_20
-        0, // unk_24
+        0, // inst_pic[0]
+        0, // inst_pic[1]
+        0, // inst_pic[2]
+        0, // mg_pic[0]
+        0, // mg_pic[1]
+        0, // mg_pic[2]
         0, // rules_mess
         0, // control_mess[0]
         0, // control_mess[1]
@@ -1243,7 +1180,7 @@ s16 omMgIndexGet(s16 overlay) {
 
     info = mgInfoTbl;
     
-    for (i = 0; info->ovl != 0xFFFF; i++) {
+    for (i = 0; info->ovl != ((u16)OVL_INVALID); i++) {
         if (info->ovl == overlay) {
             return i;
         }

From ce056b82a07efedf789ed396d24d7662c08bb815 Mon Sep 17 00:00:00 2001
From: gamemasterplc <gamemasterplc@gmail.com>
Date: Sat, 3 Feb 2024 14:12:58 -0600
Subject: [PATCH 15/15] Fix record_idx name

---
 include/game/objsub.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/game/objsub.h b/include/game/objsub.h
index d8501eeb..e4926f22 100644
--- a/include/game/objsub.h
+++ b/include/game/objsub.h
@@ -9,7 +9,7 @@ typedef struct mg_info {
     u16 ovl;
     u8 type;
     u8 flag;
-    s8 unk_4;
+    u8 record_idx;
     u32 name_mess;
     u32 data_dir;
     u32 inst_pic[3];